analytics/webcontent/bi/js/gemini/dashboard/loader/ExtensionsHelper.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. 2018
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['../../lib/@waca/core-client/js/core-client/utils/ClassFactory', 'underscore'], function (ClassFactory, _) {

	/**
 *	Helper class used to create the required dashboard extensions.
 * This includes the board model, layout and canvas extensions as well as the dashboard service extensions.
 */

	var ExtensionHelper = function () {
		function ExtensionHelper(dashboardApi) {
			_classCallCheck(this, ExtensionHelper);

			this.dashboardApi = dashboardApi;
			this.logger = this.dashboardApi.getGlassCoreSvc('.Logger');
		}

		ExtensionHelper.prototype.registerExtensions = function registerExtensions() {
			return Promise.all([this._getLayoutExtensions(), this._getCanvasExtensions()]).then(function (result) {
				return result;
			}.bind(this));
		};

		ExtensionHelper.prototype._getLayoutExtensions = function _getLayoutExtensions() {
			var _this = this;

			var promise = Promise.resolve();
			var layoutExtensions = this.dashboardApi.getCollectionConfig('layoutExtension');
			if (layoutExtensions) {
				var collectionId = layoutExtensions.id;
				promise = Promise.all([this.dashboardApi.findGlassCollection(collectionId)]).then(function (collections) {
					var collection = collections[0] || [];
					return _this.loadLayoutModelExtensions(collection);
				});
			}
			return promise;
		};

		ExtensionHelper.prototype.loadLayoutModelExtensions = function loadLayoutModelExtensions(collections) {
			var combinedExtensions = this._combineLayoutModelExtensions(collections);
			return this._loadModelExtensions(combinedExtensions);
		};

		ExtensionHelper.prototype._combineLayoutModelExtensions = function _combineLayoutModelExtensions(collection) {
			var combinedExtensions = {};
			//this is where it gets squirrely, we should edevour to simplify this... Yeah, and when monkeys fly
			collection.forEach(function (entry) {
				var extensions = entry.extensions;
				Object.keys(extensions).forEach(function (key) {
					var layoutMode = extensions[key];
					if (!combinedExtensions[key]) {
						combinedExtensions[key] = {};
					}
					Object.keys(layoutMode).forEach(function (layoutKey) {
						combinedExtensions[key][layoutKey] = layoutMode[layoutKey];
					});
				});
			});
			return combinedExtensions;
		};

		ExtensionHelper.prototype._loadModelExtensions = function _loadModelExtensions(layoutExtensions) {
			var modelExtensions = layoutExtensions.modelExtensions;
			if (modelExtensions) {
				var logger = this.logger;
				return Promise.all(Object.keys(modelExtensions).map(function (key) {
					return ClassFactory.loadModule(modelExtensions[key]).then(function (module) {
						var _ref;

						return _ref = {}, _ref[key] = module, _ref;
					}).catch(function (err) {
						logger.error(err);
						return {};
					});
				})).then(function (results) {
					// each array member contains a single key/value so we merge them all into 1 object;
					layoutExtensions.modelExtensions = _.extend.apply(_, results);
					return layoutExtensions;
				});
			}
			return Promise.resolve(layoutExtensions);
		};

		ExtensionHelper.prototype._getCanvasExtensions = function _getCanvasExtensions() {
			var promise;
			var canvasExtension = this.dashboardApi.getCollectionConfig('canvasExtension');
			if (canvasExtension) {
				var collectionId = canvasExtension.id;
				promise = Promise.all([this.dashboardApi.findGlassCollection(collectionId)]).then(function (collections) {
					var canvasExtensions = [];
					if (collections.length > 0 && collections[0]) {
						collections[0].forEach(function (collection) {
							canvasExtensions.push(collection);
						}.bind(this));
					}
					return canvasExtensions;
				}.bind(this));
			}
			return promise || Promise.resolve();
		};

		ExtensionHelper.prototype.getBoardModelExtensions = function getBoardModelExtensions() {
			var boardModelCollection = this.dashboardApi.getCollectionConfig('boardModel');
			var collectionId = boardModelCollection.id;
			return this.dashboardApi.findGlassCollection(collectionId).then(function (extensionCollection) {
				return this._loadBoardModelExtensions(extensionCollection);
			}.bind(this));
		};

		ExtensionHelper.prototype.loadBoardModelExtensions = function loadBoardModelExtensions(extensionsCollection) {
			return this._loadBoardModelExtensions(extensionsCollection);
		};

		ExtensionHelper.prototype._loadBoardModelExtensions = function _loadBoardModelExtensions(extensionCollection) {
			if (!extensionCollection) {
				return;
			}
			var promises = [];
			extensionCollection.forEach(function (extensionObj) {
				if (!extensionObj.name || !extensionObj.class) {
					return;
				}
				promises.push(ClassFactory.loadModule(extensionObj.class).then(function (ModelExtension) {
					return {
						'name': extensionObj.name,
						'type': extensionObj.type || 'model',
						'class': ModelExtension,
						'triggers': extensionObj.triggers || [],
						// backward compatible default is true unless value is explicitly false.
						'autoCreate': extensionObj.autoCreate !== false
					};
				}.bind(this)).catch(function (error) {
					this.logger.error(error);
				}.bind(this)));
			}, this);

			return Promise.all(promises).then(function (results) {
				// Failed promises will return an undefined extension in the results. Make sure we filter it out
				return results.filter(function (n) {
					return n != undefined;
				});
			});
		};

		return ExtensionHelper;
	}();

	return ExtensionHelper;
});
//# sourceMappingURL=ExtensionsHelper.js.map