analytics/webcontent/bi/js/gemini/extension/Extensions.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 Extensions = function () {
		function Extensions(dashboardApi) {
			_classCallCheck(this, Extensions);

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

			this.consumeViews = {
				absolute: 'dashboard-core/js/dashboard/layout/views/LayoutBaseView',
				genericPage: 'dashboard-core/js/dashboard/layout/views/GenericPage',
				tab: 'dashboard-core/js/dashboard/layout/views/Tab',
				hub: 'dashboard-core/js/dashboard/layout/views/Tab',
				longscroll: 'dashboard-core/js/dashboard/layout/views/Tab',
				group: 'dashboard-core/js/dashboard/layout/views/LayoutBaseView',
				singlePage: 'dashboard-core/js/dashboard/layout/views/SinglePage'
			};

			this.authoringViews = {
				absolute: 'dashboard-core/js/dashboard/layout/authoring/views/Absolute',
				tab: 'dashboard-core/js/dashboard/layout/authoring/views/Tab',
				hub: 'dashboard-core/js/dashboard/layout/authoring/views/Tab',
				longscroll: 'dashboard-core/js/dashboard/layout/authoring/views/Tab',
				group: 'dashboard-core/js/dashboard/layout/authoring/views/Group',
				templateDropZone: 'dashboard-core/js/dashboard/layout/authoring/views/TemplateDropZone',
				templateIndicator: 'dashboard-core/js/dashboard/layout/authoring/views/TemplateIndicator',
				scalingAbsolute: 'dashboard-core/js/dashboard/layout/authoring/views/ScalingAbsolute',
				genericPage: 'dashboard-core/js/dashboard/layout/authoring/views/GenericPage',
				container: 'dashboard-core/js/dashboard/layout/authoring/views/TemplateContainer',
				singlePage: 'dashboard-core/js/dashboard/layout/authoring/views/SinglePage'
			};
		}

		Extensions.prototype.getBoardModelExtensions = function getBoardModelExtensions() {
			return this.boardModelExtensions;
		};

		Extensions.prototype.getLayoutModelExtensions = function getLayoutModelExtensions() {
			return this.layoutExtensions && this.layoutExtensions.modelExtensions;
		};

		Extensions.prototype.getLayoutViewExtensions = function getLayoutViewExtensions() {
			if (!this.layoutViewExtensions) {
				var consumeViews = this.layoutExtensions && this.layoutExtensions.consumeViews;
				if (consumeViews) {
					Object.keys(consumeViews).forEach(function (key) {
						this.consumeViews[key] = consumeViews[key];
					}.bind(this));
				}

				var authoringViews = this.layoutExtensions && this.layoutExtensions.authoringViews;
				if (authoringViews) {
					Object.keys(authoringViews).forEach(function (key) {
						this.authoringViews[key] = authoringViews[key];
					}.bind(this));
				}

				this.layoutViewExtensions = {
					authoringViews: this.authoringViews,
					consumeViews: this.consumeViews,
					modelExtensions: this.layoutExtensions && this.layoutExtensions.modelExtensions
				};
			}

			return this.layoutViewExtensions;
		};

		Extensions.prototype.getCanvasExtensions = function getCanvasExtensions() {
			return this.canvasExtensions;
		};

		Extensions.prototype.load = function load() {
			var _this = this;

			return this.loadLayoutAndCanvasExtensions().then(function (extensions) {
				_this.layoutExtensions = extensions[0];
				_this.canvasExtensions = extensions[1];
				return _this.loadBoardModelExtensions().then(function (boardModelExtensions) {
					_this.boardModelExtensions = boardModelExtensions;
				});
			});
		};

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

		Extensions.prototype._getLayoutExtensions = function _getLayoutExtensions() {
			var _this2 = 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 _this2.loadLayoutModelExtensions(collection);
				});
			}
			return promise;
		};

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

		Extensions.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;
		};

		Extensions.prototype._loadModelExtensions = function _loadModelExtensions(layoutExtensions) {
			var _this3 = this;

			var modelExtensions = layoutExtensions.modelExtensions;
			if (modelExtensions) {
				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) {
						_this3.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);
		};

		Extensions.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();
		};

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

		Extensions.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 Extensions;
	}();

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