analytics/webcontent/bi/js/gemini/features/dashboard/dnD/api/impl/CanvasDnD.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
 * US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

/**
 * @class CanvasDnD
 * @hideconstructor
 *
 * @classdesc
 * Represents the drag and drop action within the dashboard canvas
 */
define(['../CanvasDnDAPI', '../../../../../lib/@waca/dashboard-common/dist/core/APIFactory'], function (CanvasDnDAPI, APIFactory) {

	var PIN = 'pin';
	var WIDGET = 'widget';
	var GROUP_CONTENT = 'groupContent'; //this type occurs when grouped a few widgets into a single group, select a group, click on one of the widget within the group to select it and move it. When move it the type is 'groupContent'

	var DASHBOARD_DND_TYPES = [PIN, WIDGET];

	return function () {
		function CanvasDnD() {
			_classCallCheck(this, CanvasDnD);

			this._api = APIFactory.createAPI(this, [CanvasDnDAPI]);
			this.providers = [];
		}

		CanvasDnD.prototype.destroy = function destroy() {
			this.api = null;
			this.providers = [];
		};

		CanvasDnD.prototype.getAPI = function getAPI() {
			return this._api;
		};

		CanvasDnD.prototype.registerProvider = function registerProvider(provider) {
			var registered = this.providers.find(function (registeredProvider) {
				return registeredProvider.getImplType() === provider.getImplType();
			});

			if (typeof registered === 'undefined' || registered === null) {
				this.providers.push(provider);
			}
		};

		CanvasDnD.prototype.accepts = function accepts() {
			var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
			var options = arguments[1];

			var types = this._getSupportedTypes(options);

			if (types.indexOf(payload.type) !== -1) {
				return true;
			}

			var providerAccepted = this.providers.find(function (provider) {
				return provider.accepts(payload, options);
			});

			return providerAccepted ? true : false;
		};

		CanvasDnD.prototype.onDrop = function onDrop() {
			var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			if (payload.data && payload.data.operation === 'new') {
				return Promise.resolve(payload.data.model);
			}

			var promise = Promise.resolve();
			this.providers.forEach(function (provider) {
				promise = promise.then(function (model) {
					return model ? model : provider.onDrop(payload);
				});
			});

			return promise;
		};

		CanvasDnD.prototype._getSupportedTypes = function _getSupportedTypes(options) {
			if (options && options.fromMultipurposeWidget) {
				return [];
			}

			var types = [].concat(DASHBOARD_DND_TYPES);

			if (options && options.fromCanvas) {
				types.push(GROUP_CONTENT);
			}

			return types;
		};

		return CanvasDnD;
	}();
});
//# sourceMappingURL=CanvasDnD.js.map