analytics/webcontent/bi/js/dashboard-analytics/widgets/livewidget/query/QueryService.js

'use strict';

/**
 * Licensed Materials - Property of IBM
 * IBM Cognos Products: BI Cloud (C) Copyright IBM Corp. 2017, 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 *
 */
define(['./ServiceBase', '../../../prompts/PromptManager', 'underscore'], function (Class, PromptManager, _) {
	'use strict';

	//TODO Unify QueryManager between Legacy one and new Endor one
	// Declare the class

	var QueryService = Class.extend({

		init: function init(options) {
			QueryService.inherited('init', this, arguments);
			this.dashboardApi = options.dashboardApi;
			this.ajaxSvc = this.dashboardApi.getGlassCoreSvc('.Ajax');
			this.logger = this.dashboardApi.getGlassCoreSvc('.Logger');
			this.queryParameters = null;
		},

		_querySpecString: function _querySpecString(queryOptions, module) {
			if (_.isNumber(queryOptions.dataRowLimit)) {
				queryOptions.querySpec.limit = queryOptions.dataRowLimit;
			}

			if (this.queryParameters) {
				queryOptions.querySpec.parameterValues = this.queryParameters;
			}

			var metadataSubsetIds = module && module.getMetadataSubsetIds();
			if (metadataSubsetIds && metadataSubsetIds.length > 0) {
				queryOptions.querySpec.queryHints = _.extend(queryOptions.querySpec.queryHints || {}, {
					metadataSubsetIDs: metadataSubsetIds
				});
			}
			return this.isMockServer ? '\\Q' + JSON.stringify(queryOptions.querySpec) + '\\E' : JSON.stringify(queryOptions.querySpec);
		},

		/**
   * @public api to excute query against DSS.
   *
   * @param {Object} options.querySpec Mandatory: the query specification to be sent to DSS.
   * @param {Object} options.sourceIdOrModule: The sourceId or module object which we're querying
   * @param {Object} options.requestOptions: additional request options
   *
   * @returns a promise.
   */
		runQuery: function runQuery(options) {
			return this._sendRequest(options, this.getRequestId(options.sender));
		},

		runPredictQuery: function runPredictQuery(options) {
			var _this = this;

			return this._getModule(options.sourceIdOrModule).then(function (module) {
				var querySpec = _this._querySpecString(options);
				return module.queryPredictData(querySpec).then(function (response) {
					return response ? response.data : null;
				}, function (jqXHR) {
					return _this.handleQueryError(jqXHR, options, _this.runPredictQuery.bind(_this));
				});
			});
		},

		_sendRequest: function _sendRequest(options, requestId) {
			var _this2 = this;

			// reset the parameters for subsequent predict query
			if (!options.querySpec.parameterValues) {
				this.queryParameters = null;
			}

			return this._getModule(options.sourceIdOrModule).then(function (module) {
				var querySpec = _this2._querySpecString(options, module);
				var queryUserId = _this2.dashboardApi.getService('.UserProfile').userAccount.id;
				return _this2._getDataSourceModifiedTime(options.sourceIdOrModule).then(function (modTime) {
					return module.queryData(querySpec, {
						senderId: options.senderId,
						lastModified: modTime,
						queryUserId: queryUserId,
						qfb: options.requestOptions && options.requestOptions.qfb || 'none',
						qfbMode: options && options.requestOptions.qfbMode || undefined
					});
				});
			}).then(function (response) {
				var promptControlFunctions = options.promptControlFunctions;
				if (promptControlFunctions && promptControlFunctions.updatePromptSpecCache) {
					promptControlFunctions.updatePromptSpecCache(options);
				}
				var data = response ? response.data : null;
				var ETag = response ? response.getResponseHeader('ETag') : null;
				var requestTime = response ? response.getResponseHeader('x-ca-requesttime') : null;

				if (_this2.isActiveRequest(requestId, options.sender)) {
					return {
						data: data,
						requestTime: requestTime,
						ETag: ETag
					};
				} else {
					return Promise.reject(_.extend(new Error(), {
						reason: 'staleRequest'
					}));
				}
			}).catch(function (jqXHR) {
				return _this2.handleQueryError(jqXHR, options);
			});
		},

		_getModule: function _getModule(sourceIdOrModule) {
			var _this3 = this;

			var isDataModule = typeof sourceIdOrModule.queryData === 'function' || typeof sourceIdOrModule.queryPredictData === 'function';
			if (isDataModule) {
				return Promise.resolve(sourceIdOrModule);
			}
			var dataSources = this.dashboardApi.getFeature('dataSources.deprecated');
			return dataSources.getModule(sourceIdOrModule).then(function (module) {
				if (!module) {
					var dataSets = _this3.dashboardApi.getFeature('DataSets.internal');
					module = dataSets.getModule(sourceIdOrModule);
				}
				if (!module) {
					return Promise.reject(new Error('Data source with ID ' + sourceIdOrModule + ' not found.'));
				}
				return module;
			});
		},

		_getDataSourceModifiedTime: function _getDataSourceModifiedTime(sourceIdOrModule) {
			var datasource = this.dashboardApi.getFeature('DataSources').getDataSource(sourceIdOrModule);
			if (!datasource) {
				var dataSets = this.dashboardApi.getFeature('DataSets.internal');
				datasource = dataSets.getDataSource(sourceIdOrModule);
				if (!datasource) {
					return Promise.reject(new Error('Datasource with source ID: ' + sourceIdOrModule + ' not found'));
				}
			}
			return datasource.getModificationTime();
		},

		/**
   * Make the rest API call to query the map data for locations.
   * @param locations Array of locations to be mapped
   * @param useMapbox - flag to tell smarter maps to return mapbox style geojson
   */
		runGeoQuery: function runGeoQuery(payload, endpoint) {
			this.logger.debug('runGeoQuery');

			return this.ajaxSvc.ajax({
				url: endpoint || 'v1/geo/~',
				type: 'POST',
				headers: {
					'Content-Type': 'application/json'
				},
				data: JSON.stringify(payload),
				processData: false
			}).then(function (response) {
				return response.data;
			});
		},

		/**
   * Make the rest API call to perform a top or bottom query the module.
   * @param querySpec The query specification to run
   */
		runTopBottomQuery: function runTopBottomQuery(queryOptions) {
			return this.runQuery(queryOptions);
		},

		handleQueryError: function handleQueryError(jqXHR, queryOptions, queryHandler) {
			var _this4 = this;

			var result = void 0;
			if (jqXHR && jqXHR.status && PromptManager.isPromptFault(jqXHR)) {
				if (!queryOptions.promptControlFunctions) {
					return Promise.reject(jqXHR);
				}

				var promptControlFunctions = queryOptions.promptControlFunctions;

				result = PromptManager.openPromptView({
					'logger': this.logger,
					'preferences': this.dashboardApi.getGlassCoreSvc('.UserProfile').preferences,
					'promptSpec': promptControlFunctions.preparePromptSpec(jqXHR),
					'whenSingleItemQueryReady': promptControlFunctions.whenSingleItemQueryReady.bind(this),
					'whenColumnsMinMaxQueryReady': promptControlFunctions.whenColumnsMinMaxQueryReady.bind(this),
					'getPromptSpec': promptControlFunctions.getPromptSpec.bind(this),
					'isPreview': queryOptions.isPreview
				}).then(function (promptResponses) {
					var aPromptInfo = _this4._resolvePromptValues(promptResponses, promptControlFunctions);

					// re-send the request with resolved parameter.
					queryOptions.querySpec.parameterValues = aPromptInfo;
					// the parameters needs to be re-applied to the subsequent query (predict)
					_this4.queryParameters = aPromptInfo;
					return queryHandler ? queryHandler(queryOptions) : _this4.runQuery(queryOptions);
				}).catch(function (error) {
					if (error) {
						switch (error.message) {
							case 'cancel':
							case 'cancelPromptDialog':
								if (promptControlFunctions.onCancelPromptDialog) {
									promptControlFunctions.onCancelPromptDialog();
								}
								break;
							case 'unSupportedPromptType':
								if (promptControlFunctions.onUnSupportedPrompt) {
									promptControlFunctions.onUnSupportedPrompt();
								}
								break;
						}
						throw error;
					} else {
						return Promise.reject(jqXHR);
					}
				});
			} else {
				result = Promise.reject(jqXHR);
			}
			return result;
		},

		/**
   * resolve prompt values from query response and saved values.
   */
		_resolvePromptValues: function _resolvePromptValues(promptResponses, promptControlFunctions) {
			var aPromptInfo = [];
			var queryProperties = ['name', 'values', 'dataType', 'capabilities', 'modelFilterItem'];
			var savedPrompts = promptControlFunctions.getPromptSpec ? promptControlFunctions.getPromptSpec() : null;

			// push the newly resolved parameter values and save them if savePromptSpec is a function.
			_.each(promptResponses, function (promptResponse) {
				var promptResult = _.pick(promptResponse, queryProperties);
				aPromptInfo.push(promptResult);
				if (promptControlFunctions.savePromptSpec) {
					promptControlFunctions.savePromptSpec(promptResponse);
				}
			});

			// push saved parameter values when they are not in promptResponse.
			if (savedPrompts) {
				_.each(savedPrompts, function (savedPrompt) {
					if (!_.find(promptResponses, function (resolvedPrompt) {
						return savedPrompt.name === resolvedPrompt.name;
					})) {
						aPromptInfo.push(_.pick(savedPrompt, queryProperties));
					}
				});
			}

			_.each(aPromptInfo, function (promptInfo) {
				// MUN based dataType expect a useValue while all other types expect a displayValue for a parameter.
				if (promptInfo.capabilities.optional) {
					promptInfo.values = [promptInfo.values[0].mun];
				} else {
					// promptInfo.values
					if (promptInfo.dataType === 'memberUniqueName' || promptInfo.dataType === 'hierarchyUniqueName') {
						// use value (and not label)
						if (promptInfo.values[0].value) {
							promptInfo.values = _.pluck(promptInfo.values, 'value');
						} else {
							promptInfo.values = _.pluck(promptInfo.values, 'u');
						}
					} else {
						// use label
						if (promptInfo.values[0].label) {
							promptInfo.values = _.pluck(promptInfo.values, 'label');
						} else {
							promptInfo.values = _.pluck(promptInfo.values, 'd');
						}
					}
				}
			});

			return aPromptInfo;
		}
	});

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