analytics/webcontent/bi/js/gemini/canvas/Content.js

'use strict';

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

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/**
 * Licensed Materials - Property of IBM
 * IBM Cognos Products: BI Cloud (C) Copyright IBM Corp. 2019, 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['underscore', '../lib/@waca/dashboard-common/dist/core/APIFactory', './ContentAPISpec', '../api/ContentAPI', '../features/FeatureLoader', '../dashboard/util/PropertyLayoutHelper', '../features/content/state/impl/StateImpl', '../features/content/internalModels/InternalModels', '../features/content/contentFilter/ContentFilter', '../features/content/serializer/Serializer', '../dashboard/util/DashboardSpecHelper'], function (_, APIFactory, ContentAPISpec, ContentAPI, FeatureLoader, PropertyLayoutHelper, State, InternalModels, ContentFilter, Serializer, DashboardSpecHelper) {
	var Content = function (_ContentAPISpec) {
		_inherits(Content, _ContentAPISpec);

		function Content(options) {
			_classCallCheck(this, Content);

			var _this = _possibleConstructorReturn(this, _ContentAPISpec.call(this));

			_this.boardModel = options.boardModel;
			_this.layoutModel = options.layoutModel;
			_this.profile = options.profile;
			_this.creationTransctionToken = options.transactionToken;

			_this.contentFeatureCollection = options.contentFeatureCollection || [];

			// TODO: revisit this
			// The widget model can be resolved based on the layout model and the boardModel
			// The only time it is passed in here is for the case of the LiveWidgetPreview
			// where we need to create a content API for a widget model that is disconnected
			_this.widgetModel = options.widgetModel;
			_this.contentMap = {};
			_this.container = options.container;
			_this.featureLoaderClass = options.featureLoaderClass || FeatureLoader;
			_this.featureLoader = options.featureLoader;
			_this.canvas = options.canvas;

			_this.dashboardFeatures = options.dashboardFeatures;
			_this.transaction = _this.dashboardFeatures.getFeature('Transaction');
			_this.lifeCycleManager = _this.dashboardFeatures.getFeature('LifeCycle');
			_this.logger = _this.dashboardFeatures.getFeature('Logger');
			_this.contentFactory = _this.dashboardFeatures.getFeature('ContentFactory');

			if (!_this.featureLoader) {
				_this.createFeatureLoader();
			}
			_this._updateContentModelFeatures();

			var model = _this._getModel();
			model.on('add:item', _this.onAddItem, _this);
			model.on('remove:item', _this.onRemoveItem, _this);
			model.on('change:parent', _this.onChangeParent, _this);
			model.on('pre:remove:item', _this.preRemoveItem, _this);
			return _this;
		}

		/**
   * In this method we are directly modifing the content model
   * (ContentModel.js) instance's "features" property object.
   * Eventually ContentModel will go away at which point the following
   * will required to be changed to not modify another object's instance
   * @private
   */


		Content.prototype._updateContentModelFeatures = function _updateContentModelFeatures() {
			var _this2 = this;

			var getLoadedFeatures = this.featureLoader.getLoadedFeatures.bind(this.featureLoader);

			var _getModel$getContentM = this._getModel().getContentModel(),
			    contentModelFeatures = _getModel$getContentM.features;

			var IGNORE_CONTENT_FEATURES = ['toJSON', 'Serializer'];
			contentModelFeatures.toJSON = function () {
				var loadedFeatures = getLoadedFeatures();
				var featureNames = Object.keys(loadedFeatures).concat(Object.keys(contentModelFeatures)).filter(function (item) {
					return IGNORE_CONTENT_FEATURES.indexOf(item) === -1;
				});

				var features = {};
				featureNames.forEach(function (featureName) {
					var feature = null;
					if (loadedFeatures[featureName] && typeof loadedFeatures[featureName].toJSON === 'function') {
						feature = loadedFeatures[featureName].toJSON();
					} else if (contentModelFeatures[featureName]) {
						feature = contentModelFeatures[featureName];
					} else {
						_this2.logger.info('Data for feature "' + featureName + '" is not persisted');
					}

					if (feature && Object.keys(feature).length > 0) {
						features[featureName] = feature;
					}
				});

				if (features.hasOwnProperty('Models.internal')) {
					features['Models_internal'] = features['Models.internal'];
					delete features['Models.internal'];
				}

				return features;
			};
		};

		Content.prototype.onAddItem = function onAddItem(payload) {
			var newModelId = payload.value.parameter.model.id;
			//currently, in getContentInstance(), we will auto-generate the missing contentInstance.
			this.getContentInstance(newModelId, false, payload.data ? payload.data.transactionToken : null);
		};

		Content.prototype.preRemoveItem = function preRemoveItem(payload) {
			var childId = payload.value.parameter;
			var contentImpl = this.getContentInstance(childId);
			if (contentImpl) {
				var content = contentImpl.getAPI();
				var contentViewDom = content.getFeature('ContentViewDOM');
				var contentNode = contentViewDom && contentViewDom.getNode();
				if (contentNode) {
					var dashboardAPI = this.dashboardFeatures.getFeature('API');
					var controller = dashboardAPI.getFeature('InteractionController.internal');
					controller.selectionHandler.deselectNode(contentNode);
				}
			}
		};

		Content.prototype.onRemoveItem = function onRemoveItem(payload) {
			var childId = payload.value.parameter;
			var contentImpl = this.getContentInstance(childId);
			if (contentImpl) {
				contentImpl.destroy();
				delete this.contentMap[childId];
			}
		};

		Content.prototype.onChangeParent = function onChangeParent(payload) {
			var newParentId = payload.value.parameter.parentId;
			if (this.getContainer().getId() !== newParentId) {
				var newContainerInst = this.canvas.getRootContentInstance().getContentInstance(newParentId);
				this.moveToContainer(newContainerInst);
			}
		};

		/**
   * create the feature loader, and register core features before initialization,
   * the core features includes:
   * - state
   * - Models.internal
   * - ContentFilter
   * - Serializer
   */


		Content.prototype.createFeatureLoader = function createFeatureLoader() {
			var type = this.getType();
			var types = [type];

			if (type !== this._getModel().type) {
				types.push(this._getModel().type);
			}

			this.featureLoader = new this.featureLoaderClass({
				featureParams: {
					// todo - we should not pass the dashboard API to the features like this
					dashboardAPI: this.dashboardFeatures.getFeature('API'),
					content: this.getAPI(),
					featureSpecs: this._getModel().getContentModel().features,
					transactionToken: this.creationTransctionToken
				},
				externalFeatures: this.dashboardFeatures,
				lifeCycleManager: this.lifeCycleManager,
				types: types,
				parentAPI: this
			});

			// State feature is a core feature that requires to be available prior to initialize
			this.featureLoader.registerFeature('state', new State({
				logger: this.logger
			}), {
				'containerId': 'com.ibm.bi.dashboard.content-features',
				'name': 'state',
				'types': ['widget']
			});

			this.featureLoader.registerFeature('Models.internal', new InternalModels({
				widgetModel: this.widgetModel,
				layoutModel: this.layoutModel
			}), {
				'containerId': 'com.ibm.bi.dashboard.content-features',
				'name': 'InternalModels'
			});

			// Content filter is required to be available before initialization
			this.featureLoader.registerFeature('ContentFilter', new ContentFilter({
				content: this,
				logger: this.logger
			}), {
				'containerId': 'com.ibm.bi.dashboard.content-features',
				'name': 'ContentFilter'
			});

			// Content serializer is required to be available before initialization,
			// as the toJSON can be called in the middle of creation of a content
			this.featureLoader.registerFeature('Serializer', new Serializer({
				layoutModel: this.layoutModel,
				content: this,
				logger: this.logger
			}), {
				'containerId': 'com.ibm.bi.dashboard.content-features.Serializer',
				'name': 'Serializer'
			});
			this._createdFeatureLoader = true;
		};

		Content.prototype.initialize = function initialize() {
			var _this3 = this;

			if (!this._initializePromise) {
				var promises = [];
				promises.push(this.featureLoader.loadFeaturesFromArray(this.contentFeatureCollection));
				var items = this._getModelItems();
				if (items) {
					// Walk the children and initialize the child content
					items.forEach(function (element) {
						var childContent = _this3.getContentInstance(element.id, true, _this3.creationTransctionToken);
						if (childContent) {
							promises.push(childContent.initialize());
						}
					});
				}
				this._initializePromise = Promise.all(promises);
			}
			return this._initializePromise.then(function () {
				return _this3.getAPI();
			});
		};

		Content.prototype.registerFeatures = function registerFeatures(features) {
			return this.featureLoader.loadFeaturesFromArray(features);
		};

		/**
   * A function to manually register a feature. Could be used by the dashboard framework to register low level features.
   * This method should be exposed through the content API interface
   *  @param {String} name
   *  @param {Object} instance
   *  @param {Object} spec
   */


		Content.prototype.registerFeature = function registerFeature(name, instance, spec, skipInitialization) {
			var _this4 = this;

			return this.initialize().then(function () {
				return _this4.featureLoader.registerFeature(name, instance, spec, skipInitialization);
			});
		};

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

		Content.prototype.destroyContentMap = function destroyContentMap() {
			var _this5 = this;

			Object.keys(this.contentMap).forEach(function (childID) {
				var childContent = _this5.contentMap[childID];
				childContent && childContent.destroy && childContent.destroy();
			});
		};

		Content.prototype.destroy = function destroy() {
			var model = this._getModel();
			model.off('add:item', this.onAddItem, this);
			model.off('remove:item', this.onRemoveItem, this);
			model.off('change:parent', this.onChangeParent, this);

			this.destroyContentMap();
			if (this._createdFeatureLoader) {
				this.featureLoader.destroy();
			}
			this.featureLoader = null;
			this.dashboardFeatures = null;
			this.boardModel = null;
			this.layoutModel = null;
			this.widgetModel = null;
			this.contentMap = null;
			this.canvas = null;
			this.api = null;
		};

		Content.prototype.getId = function getId() {
			return this._getModel().getId();
		};

		Content.prototype._getWidgetModel = function _getWidgetModel() {
			if (!this.widgetModel) {
				this.widgetModel = this.boardModel.getWidgetModel(this.getId());
			}
			return this.widgetModel;
		};

		Content.prototype.getType = function getType() {
			var type = this.layoutModel.type;

			var widgetModel = this._getWidgetModel();
			if (widgetModel) {
				type += '.' + widgetModel.type;
			}

			return type;
		};

		Content.prototype.addContent = function addContent(options, transactionToken) {
			var _this6 = this;

			if (_.isNumber(options.position)) {
				var beforeContent = this.getChildren()[options.position];
				options.insertBefore = beforeContent && beforeContent.getId();
			}

			if (options.content) {
				return this._getContentSpec(options.content).then(function (spec) {
					if (spec) {
						options.type = options.content.getType();
						spec.layout = spec.layout[0];
						options.spec = spec;
					}
					return _this6._addModel(options, transactionToken);
				});
			}
			return this._addModel(options, transactionToken);
		};

		Content.prototype._addModel = function _addModel(options, transactionToken) {
			var _this7 = this;

			//Todo: temporary until all uses are updated to use the properties
			options.properties = Object.assign(options.properties || {}, options.layout);
			delete options.layout;

			return this.contentFactory.addModel(options, {
				boardModel: this.boardModel,
				canvas: this.canvas,
				canvasContent: this
			}, transactionToken).then(function (modelId) {
				return _this7.getContentInstance(modelId).initialize();
			}).then(function (contentApi) {
				var properties = options.properties || {};
				Object.keys(properties).forEach(function (propertyName) {
					contentApi.setPropertyValue(propertyName, properties[propertyName], transactionToken);
				});
				return contentApi;
			});
		};

		Content.prototype._getContentSpec = function _getContentSpec(content) {
			// This is a unique case for addContent where the added content may be coming from a different dashboard.
			// Conscious choice not to expose a content api to get the dashboard api since:
			// 1. This can go away when the Serializer is able to return the currently missing dashboard level information relating to a content. See DashboardSpecHelper for specifics.
			// 2. Worried it may be abused, especially in content features.
			var dashboard = content.getFeature('Models.internal').getLayoutModel().boardModel.dashboardApi;
			var layoutController = dashboard.getFeature('LegacyViewControllers').getLayoutController();
			return layoutController.getInteractionController().then(function (controller) {
				var specHelper = new DashboardSpecHelper(controller);
				var contentSpec = specHelper.getContentsToJSONSpec(content).spec;
				return specHelper.validateDashboardSpec(contentSpec);
			});
		};

		Content.prototype.removeChildContent = function removeChildContent(id, transactionToken) {
			// Content can only delete its children.. make sure the content belongs to this container before deleting it
			var content = this.getContentInstance(id);
			if (content) {
				this.boardModel.removeLayouts(id, 'api', this._convertOptions(transactionToken));
			}
		};

		Content.prototype.removeContentReference = function removeContentReference(content) {
			delete this.contentMap[content.getId()];
		};

		Content.prototype.addContentReference = function addContentReference(content) {
			this.contentMap[content.getId()] = content;
		};

		Content.prototype.moveToContainer = function moveToContainer(newContainerInst) {
			this.container.removeContentReference(this);
			this.container = newContainerInst;
			newContainerInst.addContentReference(this);
		};

		Content.prototype.moveContent = function moveContent(containerId, contentIdList, transactionToken, insertBeforeMap) {
			var _this8 = this;

			var containerInst = containerId === this.getId() ? this : this.getContentInstance(containerId);
			if (containerInst) {
				var moveOptions = {
					updateArray: []
				};

				var contentInstList = contentIdList.map(function (id) {
					return _this8.canvas.getContentInstance(id);
				});
				contentInstList.forEach(function (content) {
					if (content) {
						var id = content.getId();
						var contentEntry = {
							id: id,
							parentId: containerInst.getId()
						};
						if (insertBeforeMap && insertBeforeMap[id]) {
							contentEntry.insertBefore = insertBeforeMap[id];
						}
						moveOptions.updateArray.push(contentEntry);
						content.moveToContainer(containerInst);
					}
				});

				if (moveOptions.updateArray.length > 0) {
					this.layoutModel.getTopLayoutModel().updateModel(moveOptions, null, this._convertOptions(transactionToken));
				}

				return contentInstList.map(function (instance) {
					return instance.getAPI();
				});
			} else {
				this.logger.error('cannot find container ' + containerId);
			}
		};

		Content.prototype.removeContent = function removeContent(id, transactionToken) {
			this.removeChildContent(id, transactionToken);
		};

		Content.prototype.getContentInstance = function getContentInstance(id, doNotInitialize, transactionToken) {
			var content = this.contentMap[id];
			var items = this._getModelItems();
			if (!content && items) {
				var matchedModel = items.find(function (model) {
					return model.id === id;
				});

				if (matchedModel) {

					// TODO -- we should not get here but it is ok for now
					// All direct children content API should be available and initialized
					//  Today, we will get here, if a widget was added in authoring, and someone is trying to get the content API
					// The right way is to go through the content API to add content which will give the parent content to properly create and initalize, or use model event to monitor the add/remove of content
					content = this.contentFactory.createContent({
						contentFeatureCollection: this.contentFeatureCollection,
						dashboardFeatures: this.dashboardFeatures,
						boardModel: this.boardModel,
						layoutModel: matchedModel,
						featureLoaderClass: this.featureLoaderClass,
						canvas: this.canvas,
						container: this,
						profile: this.profile,
						transactionToken: transactionToken,
						type: matchedModel.type
					});

					APIFactory.setParentChildRelation(this.canvas, content);

					if (!doNotInitialize) {
						content.initialize();
					}

					this.contentMap[id] = content;
				} else {
					// Ask the children to find the instance;
					for (var i = 0; i < items.length && !content; i++) {
						var contentInstance = this.getContentInstance(items[i].id, false, transactionToken);
						content = contentInstance.getContentInstance(id, doNotInitialize, transactionToken);
					}
				}
			}
			return content;
		};

		Content.prototype.getContentPosition = function getContentPosition(id) {
			var position = -1;
			var items = this._getModelItems();
			if (items && items.length) {
				position = items.findIndex(function (model) {
					return model.id === id;
				});
				if (position === -1) {
					// Find the instance from children and return its position
					for (var i = 0; i < items.length && position === -1; i++) {
						var contentInstance = this.getContentInstance(items[i].id);
						position = contentInstance.getContentPosition(id);
					}
				}
			}
			return position;
		};

		Content.prototype.getContent = function getContent(id) {
			var content = this.getContentInstance(id);
			return content ? content.getAPI() : null;
		};

		Content.prototype.getContainer = function getContainer() {
			var containerInst = this.getContainerInstance();
			return containerInst && containerInst.getAPI();
		};

		Content.prototype.getContainerInstance = function getContainerInstance() {
			return this.container;
		};

		Content.prototype.getChildren = function getChildren() {
			var _this9 = this;

			var items = this._getModelItems() || [];
			return items.map(function (item) {
				return _this9.getContent(item.id);
			});
		};

		Content.prototype.findContent = function findContent() {
			var _this10 = this;

			var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			if (_.isEmpty(selector)) {
				selector.type = 'widget';
			}
			var contents = [];
			var items = this._getModelItems();
			if (items) {
				items.forEach(function (item) {
					var content = _this10.getContent(item.id);
					var contentFilter = content.getFeature('ContentFilter');
					if (contentFilter.match({ selector: selector, layout: item })) {
						contents.push(content);
					}
					contents.push.apply(contents, content.findContent(selector));
				});
			}
			return contents;
		};

		Content.prototype._convertOptions = function _convertOptions(transactionToken) {
			var oldOptions = {
				skipUndoRedo: true
			};
			if (transactionToken && transactionToken.transactionId) {
				oldOptions.undoRedoTransactionId = transactionToken.transactionId;
				oldOptions.transactionToken = transactionToken;
			}
			return oldOptions;
		};

		Content.prototype.getPropertyLayoutList = function getPropertyLayoutList() {
			var properties = this.getFeature('Properties');
			var layoutList = properties.getPropertyLayoutList();
			var propertyList = this.getPropertyList();
			return PropertyLayoutHelper.getExpandedLayoutList(layoutList, propertyList, this.profile);
		};

		Content.prototype.getPropertyNameList = function getPropertyNameList() {
			var properties = this.getFeature('Properties');
			return properties.getPropertyList().map(function (prop) {
				return prop.id;
			});
		};

		// TODO: the third param options should always be only transactionToken
		// but currently in several places we call setPropertyValue with
		// the `options` being transactionToken + some other options, we should avoid pollute transactionToken


		Content.prototype.setPropertyValue = function setPropertyValue(name, value, options) {
			var property = this.getPropertyList().find(function (property) {
				return property.id === name;
			});
			if (property) {
				return property.setPropertyValue(value, options);
			} else {
				return this._getModel().getContentModel().setPropertyValue(name, value, options);
			}
		};

		Content.prototype.getPropertyValue = function getPropertyValue(name) {
			var property = this.getPropertyList().find(function (property) {
				return property.id === name;
			});
			if (property) {
				return property.getPropertyValue();
			} else {
				return this._getModel().getContentModel().getPropertyValue(name);
			}
		};

		Content.prototype.__getPropertyValueFunc = function __getPropertyValueFunc(getterFunction, property) {
			var propValue = void 0;
			if (getterFunction) {
				propValue = getterFunction();
			} else {
				propValue = this._getModel().getContentModel().getPropertyValue(property.id);
			}
			// Use == instead of === to check for both null and underfined
			if (propValue == null && property.defaultValue != null) {
				propValue = property.defaultValue;
			}

			return propValue;
		};

		Content.prototype.getPropertyList = function getPropertyList() {
			var _this11 = this;

			var propertiesFeature = this.getFeature('Properties');
			if (!propertiesFeature) {
				return [];
			}
			var properties = propertiesFeature.getPropertyList();

			// Default any missing get/set methods
			// This is the case for any new property added through the property provider

			var _loop = function _loop(i) {
				var property = properties[i];

				if (!property.isGetterSet) {
					// Make sure we don't set the getPropertyValue over and over against
					// The property list get s called everytime..
					property.isGetterSet = true;
					var originalPropertyGetter = property.getPropertyValue && property.getPropertyValue.bind(property);
					property.getPropertyValue = _this11.__getPropertyValueFunc.bind(_this11, originalPropertyGetter, property);
				}
				if (!property.setPropertyValue) {
					// If a setPropertyValue is not defined, we assume it is a new property added by a feature provider
					// in this case will tag it to support api events
					property.setPropertyValue = function (value, options) {
						_this11._getModel().getContentModel().setPropertyValue(property.id, value, options);
					};
				}
			};

			for (var i = 0; i < properties.length; i++) {
				_loop(i);
			}

			return properties;
		};

		Content.prototype.getFeature = function getFeature(id) {
			if (this.featureLoader) {
				return this.featureLoader.getFeature(id);
			}
		};

		Content.prototype.setFeatureEnabled = function setFeatureEnabled(id, isEnabled) {
			if (this.featureLoader) {
				this.featureLoader.setFeatureEnabled(id, isEnabled);
			}
		};

		Content.prototype._getModel = function _getModel() {
			return this.layoutModel;
		};

		Content.prototype._getModelItems = function _getModelItems() {
			return this.layoutModel.items;
		};

		return Content;
	}(ContentAPISpec);

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