analytics/webcontent/bi/js/gemini/features/dashboard/contentProvider/api/impl/BaseContentProvider.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 Business Analytics (C) Copyright IBM Corp. 2019, 2020
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

/**
 * @class ContentFactory
 * @hideconstructor
 * @classdesc API class that is used to generate content specs and create them
 */
define(['../../../../../lib/@waca/dashboard-common/dist/core/APIFactory', '../../../../../canvas/Content', '../../../../../dashboard/layout/LayoutHelper', '../../../../../dashboard/glass/util/InstrumentationUtil', '../../../../../lib/@waca/dashboard-common/dist/api/ContentProviderAPI'], function (APIFactory, Content, LayoutHelper, InstrumentationUtil, ContentProviderAPI) {
	var BaseContentProvider = function () {
		function BaseContentProvider(options) {
			_classCallCheck(this, BaseContentProvider);

			this.dashboardApi = options.features['API'];
			options.features['ContentFactory'].registerProvider(this);
		}

		BaseContentProvider.prototype.getAPI = function getAPI() {
			return APIFactory.createAPI(this, [ContentProviderAPI]);
		};

		BaseContentProvider.prototype.getTypeList = function getTypeList() {
			var types = [null, undefined, ''];
			if (!this._contentTypes) {
				this._contentTypes = this.dashboardApi.getFeature('ContentTypeRegistry');
			}
			return this._contentTypes ? this._contentTypes.getRegisteredTypes().concat(types) : types;
		};

		BaseContentProvider.prototype.addModel = function addModel(options, _ref, transactionToken) {
			var canvas = _ref.canvas,
			    boardModel = _ref.boardModel,
			    canvasContent = _ref.canvasContent;

			var addOptions = {
				parentId: options.containerId,
				insertBefore: options.insertBefore,
				copyPaste: options.copyPaste,
				model: options.spec,
				modelIdsValid: options.modelIdsValid === true,
				layoutProperties: {
					style: options.spec.style || {}
				}
			};
			if (options.properties) {
				['left', 'top', 'height', 'width'].forEach(function (prop) {
					if (options.properties[prop] !== undefined) {
						addOptions.layoutProperties.style[prop] = options.properties[prop];
						delete options.properties[prop];
					}
				});
			}
			LayoutHelper.setPreferredAddOptions(addOptions, boardModel.layout, this.dashboardApi);
			if (!addOptions.parentId && !canvasContent.getFeature('ContentViewDOM')) {
				addOptions.parentId = canvasContent.getId();
			}
			var isLayout = canvas.isLayoutType(options.spec.type);
			var contentRegistry = this.dashboardApi.getFeature('ContentTypeRegistry');
			var isTypeRegistered = contentRegistry ? contentRegistry.isTypeRegistered(options.spec.type) : false;

			var _add = void 0;
			if (options.spec.type === 'widget') {
				// this is the case we are adding a layout of type widget
				// it will follow the new structure where the widget model is under the features secfion
				_add = this._addContent.bind(this);
			} else if (!isLayout && (options.spec.widgets || options.spec.layout && options.spec.layout.items)) {
				_add = this._addFragment.bind(this);
			} else if (!isLayout) {
				if (isTypeRegistered) {
					_add = this._addContent.bind(this);
				} else {
					_add = this._addWidget.bind(this);
				}
			} else {
				_add = this._addLayout.bind(this);
			}

			var id = _add(addOptions, boardModel, {
				undoRedoTransactionId: transactionToken.transactionId,
				transactionToken: transactionToken,
				skipUndoRedo: true
			});
			return Promise.resolve(id);
		};

		BaseContentProvider.prototype.createContent = function createContent(options) {
			return new Content(options);
		};

		BaseContentProvider.prototype._addWidget = function _addWidget(addOptions, boardModel, options) {
			this._track(addOptions);
			var payload = boardModel.addWidget(addOptions, null, options);
			var parameter = payload && payload.value && payload.value.parameter;
			return parameter && parameter.model && parameter.model.id;
		};

		BaseContentProvider.prototype._addFragment = function _addFragment(addOptions, boardModel, options) {
			var payload = boardModel.addFragment(addOptions, null, options);
			var parameter = payload && payload.value && payload.value.parameter;
			return parameter && parameter.model && parameter.model.layout && parameter.model.layout.id;
		};

		BaseContentProvider.prototype._addContent = function _addContent(addOptions, boardModel, options) {
			this._track(addOptions);
			return boardModel.addContent(addOptions, null, options);
		};

		BaseContentProvider.prototype._addLayout = function _addLayout(addOptions, boardModel, options) {
			var payload = boardModel.addLayouts({ addLayoutArray: [addOptions] }, null, options);
			return payload.value.parameter.addLayoutArray[0].model.id;
		};

		BaseContentProvider.prototype._track = function _track() {
			var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			var model = options.model;
			if (model) {
				InstrumentationUtil.trackWidget('created', this.dashboardApi, {
					name: model.name,
					type: model.type,
					data: model.data
				});
			}
		};

		return BaseContentProvider;
	}();

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