analytics/webcontent/bi/js/dashboard-analytics/features/content/dataQueryExecution/QueryDefinitionProvider.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 Cognos Products: BI Cloud (C) Copyright IBM Corp. 2019, 2021
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['../../../lib/@waca/dashboard-common/dist/core/APIFactory', './api/QueryDefinitionProviderAPI'], function (APIFactory, QueryDefinitionProviderAPI) {
	var _class, _temp;

	var QueryDefinitionProvider = (_temp = _class = function () {
		function QueryDefinitionProvider(_ref) {
			var content = _ref.content,
			    features = _ref.features;

			_classCallCheck(this, QueryDefinitionProvider);

			this.content = content;
			this.features = features;
		}

		QueryDefinitionProvider.prototype.initialize = function initialize() {
			this.features['DataQueryExecution'].registerQueryDefinitionProvider(this.getAPI());
		};

		QueryDefinitionProvider.prototype.supports = function supports() {
			return true;
		};

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

		QueryDefinitionProvider.prototype.getType = function getType() {
			return 'main';
		};

		QueryDefinitionProvider.prototype.getQueryDefinitionList = function getQueryDefinitionList() {
			var _this = this;

			var definitionList = [];
			var queryService = this.features['Dashboard.QueryService2'];
			var visualization = this.features['Visualization'];
			var summariesEnabled = !this.content.getPropertyValue('hideSummaries');
			var expandEnabled = this.content.getPropertyValue('expandCollapse');
			var suppressionEnabled = this.content.getPropertyValue('suppression') !== QueryDefinitionProvider.SUPPRESSION_NONE;
			var slotsByDataset = this._getSlotsByDataset(visualization);
			var internalVisualization = this.features['Visualization.internal'];
			var filters = [];
			if (visualization) {
				filters = [].concat(visualization.getLocalFilters().getFilterList(), internalVisualization.getSearchFilterList());
			}

			var _loop = function _loop(datasetId) {
				var definition = queryService.createQueryDefinition(datasetId, _this.getType());

				definition.setSummariesEnabled(summariesEnabled);
				definition.setExpandEnabled(expandEnabled);
				//There are only two values for suppression: rowsAndColumns and none
				definition.setSuppressionEnabled(suppressionEnabled);
				definition.setDataSource(visualization.getDataSource());

				slotsByDataset[datasetId].forEach(function (slot) {
					var dataItems = slot.getDataItemList();
					if (slot.getDefinition().isStackItems()) {
						return _this._nestDataItems({ definition: definition, dataItems: dataItems });
					} else {
						return _this._composeDataItems({ definition: definition, dataItems: dataItems });
					}
				});
				if (filters && filters.length > 0) {
					definition.addFilters(filters);
				}
				definitionList.push(definition);
			};

			for (var datasetId in slotsByDataset) {
				_loop(datasetId);
			}
			return Promise.resolve(definitionList);
		};

		/**
   * Get list of slots for each datasets
   * @param {VisualizationAPI} visualization
   * @returns {Object} array of slots mapped by the datasetId as the key
   */


		QueryDefinitionProvider.prototype._getSlotsByDataset = function _getSlotsByDataset(visualization) {
			var slotMap = {};
			var mappedSlots = visualization && visualization.getSlots().getMappedSlotList() || [];
			mappedSlots.forEach(function (slot) {
				var slotDefinition = slot.getDefinition();
				var datasetIds = slotDefinition.getDatasetIdList() || [];
				// single slot can be shared among multiple datasets
				datasetIds.forEach(function (datasetId) {
					if (!slotMap[datasetId]) {
						slotMap[datasetId] = [slot];
					} else {
						slotMap[datasetId].push(slot);
					}
				});
			});
			return slotMap;
		};

		QueryDefinitionProvider.prototype._composeDataItems = function _composeDataItems(_ref2) {
			var definition = _ref2.definition,
			    dataItems = _ref2.dataItems;

			definition.createDataItemSet(dataItems);
		};

		QueryDefinitionProvider.prototype._nestDataItems = function _nestDataItems(_ref3) {
			var definition = _ref3.definition,
			    dataItems = _ref3.dataItems;

			var parent = definition;
			dataItems.forEach(function (dataItem) {
				parent = parent.createDataItemSet([dataItem]);
			});
		};

		return QueryDefinitionProvider;
	}(), _class.DEFAULT_ROWLIMIT = 3000, _class.SUPPRESSION_NONE = 'none', _temp);

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