analytics/webcontent/bi/js/dashboard-analytics/features/dashboard/queryService/Query.js

'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Licensed Materials - Property of IBM
 * IBM Business Analytics (C) Copyright IBM Corp. 2019, 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

/**
 * @class QueryAPI
 * @hideconstructor
 * @classdesc Query API class that is used to construct and run a query.
 */
define(['underscore', '../../../lib/@waca/dashboard-common/dist/core/APIFactory', './QueryDataItem', './api/QueryAPI', '../../../filters/FilterQuerySpec', './QuerySelectionBuilder', '../../content/dataQueryExecution/DataQueryUtils', '../../../lib/@waca/dashboard-common/dist/core/UniqueHashIdBuilder'], function (_, APIFactory, QueryDataItem, QueryAPI, FilterQuerySpec, QuerySelectionBuilder, DataQueryUtils, UniqueHashIdBuilder) {
	var Query = function () {
		function Query(dashboard, queryService, type) {
			_classCallCheck(this, Query);

			this.VERSION = '1';
			this.DEFAULT_ROW_LIMIT = 1000;
			this.DEFAULT_OFFSET = 0;

			this._dashboard = dashboard;
			this._queryService = queryService;
			this._logger = dashboard.getGlassCoreSvc('.Logger');
			this._type = type;
		}

		Query.prototype.getAPI = function getAPI() {
			if (!this.api) {
				this.api = APIFactory.createAPI(this, [QueryAPI]);
			}
			return this.api;
		};

		Query.prototype.setDataSource = function setDataSource(sourceId) {
			var dataSources = this._dashboard.getFeature('DataSources');
			this._dataSource = dataSources.getDataSource(sourceId);
			return this._dataSource.loadMetadata();
		};

		Query.prototype.addColumns = function addColumns(columnIdList) {
			var _this = this;

			if (!this._dataItems) {
				this._dataItems = [];
				this.dataItemIdsMap = {};
			}

			columnIdList.forEach(function (columnId) {
				var metadataColumn = _this._dataSource.getMetadataColumn(columnId);
				if (metadataColumn) {
					_this._dataItems.push(_this._createQueryDataItem(metadataColumn, columnId));
				} else {
					_this._logger.error('Could not find metadata column ' + columnId + ' in ' + _this._dataSource.getId());
				}
			});

			return this._dataItems;
		};

		Query.prototype.addDataItems = function addDataItems(dataItemList) {
			var _this2 = this;

			if (!this._dataItems) {
				this._dataItems = [];
				this.dataItemIdsMap = {};
			}

			if (dataItemList) {
				dataItemList.forEach(function (dataItem) {
					var metadataColumn = dataItem.getMetadataColumn();
					_this2._dataItems.push(_this2._createQueryDataItem(metadataColumn, null, dataItem));
				});
			}

			return this._dataItems;
		};

		Query.prototype._createQueryDataItem = function _createQueryDataItem(metadataColumn, columnId, dataItem) {
			var idOrigin = dataItem && dataItem.getId() || columnId;
			var dataItemId = UniqueHashIdBuilder.createUniqueHashId(idOrigin, this.dataItemIdsMap);
			this.dataItemIdsMap[dataItemId] = dataItemId;
			return new QueryDataItem(metadataColumn, dataItemId, dataItem).getAPI();
		};

		Query.prototype.addFilters = function addFilters(filters) {
			if (!this._filters) {
				this._filters = [];
			}
			if (filters && filters.length > 0) {
				var _filters;

				(_filters = this._filters).push.apply(_filters, filters);
			}
		};

		Query.prototype.addSearchTerms = function addSearchTerms(columnId) {
			var searchTermList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

			if (!this._searchTerms) {
				this._searchTerms = [];
			}

			if (!Array.isArray(searchTermList) || !searchTermList.length > 0) {
				return;
			}

			var filter = {
				id: columnId,
				columnId: columnId,
				values: searchTermList
			};

			if (searchTermList.length > 1) {
				filter.operator = 'in';
				filter.ignoreCase = true;
				filter.type = 'display';
			} else {
				filter.operator = 'containsignorecase';
			}

			this._searchTerms.push(filter);
		};

		Query.prototype.setLimit = function setLimit() {
			var dataRowLimit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.DEFAULT_ROW_LIMIT;

			this._dataRowLimit = dataRowLimit;
		};

		Query.prototype.setOffset = function setOffset() {
			var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.DEFAULT_OFFSET;

			this._offset = offset;
			return this._offset;
		};

		Query.prototype._toJSON = function _toJSON() {
			var _this3 = this;

			var dataItems = [];
			var projections = [];
			var querySelectionBuilder = new QuerySelectionBuilder(this._dataItems);
			if (this._dataItems) {
				this._dataItems.forEach(function (dataItem) {
					var resultItem = {
						id: dataItem.getId(),
						itemId: dataItem.getColumnId()
					};
					var selectionMap = {};
					// Use DataItemAPI to generate the selection
					//todo: second param is filterList
					_.each(querySelectionBuilder.build(dataItem, [], _this3._searchTerms), function (selection) {
						selectionMap[selection.operation] = selection;
					});

					_.each(dataItem.getCommandList(), function (command) {
						selectionMap[command.operation] = command;
					});
					var selections = _.values(selectionMap);
					if (selections && selections.length) {
						resultItem.selection = selections;
					}

					var aggregation = dataItem.getAggregation();
					if (!_.isNull(aggregation) && aggregation !== 'none' && (dataItem.getType() === 'fact' || !dataItem.hasDefaultAggregation())) {
						resultItem.aggregate = dataItem.getAggregation();
					}
					dataItems.push(resultItem);
					var projected = dataItem.getProjected();
					if (projected === undefined || projected) {
						projections.push(dataItem.getId());
					}
				});
			}

			var queryFilters = [];
			var filterQuerySpec = void 0;
			if (this._filters && this._filters.length) {
				var keptFilters = DataQueryUtils.convertExcludeEmptyValuesFilters(this._filters, this._dataSource);
				filterQuerySpec = new FilterQuerySpec();
				filterQuerySpec.addFiltersToSpec(keptFilters);
			}

			if (this._searchTerms && this._searchTerms.length) {
				filterQuerySpec = filterQuerySpec || new FilterQuerySpec();
				filterQuerySpec.addFiltersToSpec(this._searchTerms);
			}

			if (filterQuerySpec) {
				queryFilters = filterQuerySpec.getFilterSpec();
			}

			var spec = {
				version: this.VERSION,
				dataItems: dataItems,
				projections: projections,
				limit: this._dataRowLimit || this.DEFAULT_ROW_LIMIT,
				filters: queryFilters
			};

			if (this._type) {
				spec.type = this._type;
			}

			if (this._offset) {
				spec.offset = this._offset;
			}

			return spec;
		};

		Query.prototype.executeQuery = function executeQuery() {
			var requestOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			var querySpec = this._toJSON();
			return this._queryService.executeQuery(this._dataSource.getId(), querySpec, this.constructor.name, requestOptions);
		};

		return Query;
	}();

	return Query;
});
//# sourceMappingURL=Query.js.map