'use strict';
/**
* Licensed Materials - Property of IBM
* IBM Cognos Products: BI Cloud (C) Copyright IBM Corp. 2014, 2021
* US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
*/
define(['jquery', '../../lib/@waca/dashboard-common/dist/core/Model', './WidgetModel', './LayoutModel', './ModelUtils', 'underscore', './EventGroups', './properties/PropertiesModel', '../../lib/@waca/core-client/js/core-client/utils/UniqueId'], function ($, BaseModel, WidgetModel, LayoutModel, ModelUtils, _, EventGroupCollection, PropertiesModel, UniqueId) {
function createLayoutModel_default(spec, env) {
return new LayoutModel(spec, env.boardModel, env.logger);
}
var Model = BaseModel.extend({
nestedCollections: {
eventGroups: EventGroupCollection
},
nestedModels: {
properties: PropertiesModel
},
init: function init(boardSpec, options) {
var _this = this;
this._initBoardSpec = boardSpec;
options = options || {};
this.logger = options.logger;
// TODO: remove depenendency on dashboardApi here. currently needed to be passed to the "pageContext" board model extension
this.dashboardApi = options.dashboardApi;
this.createLayoutModel = options.createLayoutModel || createLayoutModel_default;
// Make sure the extensions are processed before we call the parents init
if (options.whitelistAttrs) {
this.whitelistAttrs = options.whitelistAttrs;
} else {
this.whitelistAttrs = ['name', 'layout', 'theme', 'version', 'eventGroups', 'datasetShaping', 'properties', 'content'];
}
var excludedProperties = ['dashboardColorSet', 'customColors', 'localCache', 'defaultLocale', 'fredIsRed'];
this.content = ModelUtils.initializeContentModel(boardSpec, excludedProperties);
options.boardModel = this;
if (!boardSpec.properties) {
boardSpec.properties = {};
}
// Need to set these since the boardModel is passed as the options when building the layout model.
// Weird, but don't want to change the flow of layout model creation in R release
this.defaultLocale = boardSpec.properties.defaultLocale;
if (this.dashboardApi) {
var userProfileService = this.dashboardApi.getGlassCoreSvc('.UserProfile');
if (userProfileService) {
this.contentLocale = userProfileService.preferences.contentLocale;
}
}
_.extend(options, this.getLanguageModelOptions());
this._updateNestedInfoWithExtensions(options.boardModelExtensions);
Model.inherited('init', this, arguments);
this.eventRouter = options.eventRouter;
this._autoCreateExtensionModelsAndCollections(options.boardModelExtensions, boardSpec);
this.id = options.id;
this.name = options.name || this.name;
this.widgetRegistry = options.widgetRegistry;
this.layoutExtensions = options.layoutExtensions;
this.widgetInstances = {};
// TODO: Add reference to cleanup item here when it is created in Jira.
// CADBC-832 is item that caused it to change. Eventually this block
// of code will go away.
Object.keys(boardSpec.widgets || {}).forEach(function (widgetId) {
_this.createLegacyWidgetModel(boardSpec.widgets[widgetId]);
});
// Explore expects the BoardModel to populate the widgetInstances
// within this init method but because of changes to how widgets are
// instantiated they are now created from the LayoutModel though still
// from a method in this class (see createLegacyWidgetModel below)
// This doesn't work in Explore's case so the following continues
// to allow Explore to function properly
if (this.createLayoutModel !== createLayoutModel_default) {
this._instantiateWidgetModels(boardSpec.layout.items);
}
this.layout = this.createLayoutModel(boardSpec.layout, {
boardModel: this,
logger: this.logger,
dashboardApi: this.dashboardApi
});
if (!this.eventGroups) {
this.set({
eventGroups: new EventGroupCollection()
}, {
silent: true
});
}
// cache the extensions, the boardmodel editor needs this to re-create the model after a manual edit.
this.boardModelExtensions = options.boardModelExtensions;
// The first layout item will be displayed by default. Keep the selected layout property in sync.
if (this.layout.items && this.layout.items.length > 0) {
var item = this.layout.items[0];
this.setSelectedLayout(item.id);
}
// Keep the selected layout in sync.
this.eventRouter && this.eventRouter.on('tab:tabChanged', this.onTabChanged, this);
this.isUpgraded = options.isUpgraded;
this.type = 'dashboard';
},
_instantiateWidgetModels: function _instantiateWidgetModels() {
var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
for (var i = 0; i < items.length; i++) {
var item = items[i];
if (item.items && item.items.length) {
this._instantiateWidgetModels(item.items);
} else {
if (item.type === 'widget' && item.features && item.features['Models_internal']) {
this.createLegacyWidgetModel(item.features['Models_internal']);
}
}
}
},
/**
* Returns the ContentModel
* @return {Object}
*/
getContentModel: function getContentModel() {
return this.content;
},
/**
* In Endor R7 (11.1.7) onward we now allow for features to load
* their own data from the board spec. Through this mechanism this method
* is called by the LayoutModel for specific content model objects that
* have a 'Models.internal' feature on them.
* 'Models.internal' is the place that widget data resides for now
* instead of a top-level "widgets" property in the BoardModel here.
* The BoardModel will still hold all widget instances though.
* @param {Object} widgetSpec An object that represents a widget model
*/
createLegacyWidgetModel: function createLegacyWidgetModel(widgetSpec) {
if (!this.getWidgetModel(widgetSpec.id)) {
this._addWidgetModel(widgetSpec, {
addDashboardTranslatedLocales: false
});
}
},
/**
* Adds the board model extension info to the the nestedCollections and nestedModels
*/
_updateNestedInfoWithExtensions: function _updateNestedInfoWithExtensions(boardModelExtensions) {
var _this2 = this;
if (!boardModelExtensions) {
return;
}
boardModelExtensions.forEach(function (extensionInfo) {
var extensionName = extensionInfo.name;
_this2.whitelistAttrs.push(extensionName);
if (extensionInfo.type === 'collection') {
_this2.nestedCollections[extensionName] = extensionInfo.class;
} else {
_this2.nestedModels[extensionName] = extensionInfo.class;
}
});
},
/**
* Handles adding the model extension points to the whitelistAttrs array and as nestedModels
* @param {Object} boardModelExtensions
* @param {Object} boardSpec
*/
_autoCreateExtensionModelsAndCollections: function _autoCreateExtensionModelsAndCollections(boardModelExtensions, boardSpec) {
var _this3 = this;
if (!boardModelExtensions) {
return;
}
boardModelExtensions.forEach(function (extensionInfo) {
var extensionName = extensionInfo.name;
/**
* If it's already in the boardSpec do nothing since the base Model class should of already made sure we were
* dealing with actual Models and Collections. If it's missing and autoCreate is set to true then create the
* Model or Collection
*/
if (!boardSpec[extensionName] && extensionInfo.autoCreate) {
if (extensionInfo.type === 'collection') {
_this3._setCollection(extensionName, boardSpec[extensionName] || null, {
silent: true,
logger: _this3.logger,
boardModel: _this3,
dashboardApi: _this3.dashboardApi // FIXME - models should not rely on dashboardApi -- currently used by the pageContext
});
} else {
_this3._setNestedModel(extensionName, boardSpec[extensionName] || {}, {
silent: true,
logger: _this3.logger,
boardModel: _this3
});
}
}
});
this._registerBoardModelExtensionTriggers(boardModelExtensions);
},
setDefaultLocale: function setDefaultLocale(locale) {
this.defaultLocale = locale;
},
setTranslationLocale: function setTranslationLocale(locale) {
this.properties.set({
translationModeLocale: locale
});
this.translationLocale = locale;
},
_registerBoardModelExtensionTriggers: function _registerBoardModelExtensionTriggers(boardModelExtensions) {
if (boardModelExtensions) {
boardModelExtensions.forEach(function (extension) {
if (extension.triggers && extension.triggers.length > 0) {
extension.triggers.forEach(function (trigger) {
this[extension.name].on(trigger.eventName, this.trigger.bind(this, trigger.event));
}, this);
}
}, this);
}
},
onTabChanged: function onTabChanged(event) {
this.setSelectedLayout(event.modelId);
},
/**
* @deprecated, use findWidgetById
*/
getWidgetModel: function getWidgetModel(id) {
return this.widgetInstances ? this.widgetInstances[id] : null;
},
getTimeLineEpisode: function getTimeLineEpisode(id) {
return this.timeline ? this.timeline.episodes.get(id) : null;
},
setSelectedLayout: function setSelectedLayout(id) {
this.selectedLayout = id;
},
getSelectedLayout: function getSelectedLayout() {
return this.selectedLayout;
},
/**
* Add a content to the model
*
* @param options
* @param options.model - layout model to add
* @param options.parentId - id of the parent layout
* @param [options.insertBefore] - id of the layout to insert before
* @param options.layoutProperties
* @param sender - If available, the sender will be added to the event payload.
* @param payloadData - Additional data that will be included in the event payload.
* @throws throws an exception if any of the mandatory options are not provided
*/
addContent: function addContent(options, sender, payloadData) {
if (!options.parentId) {
throw new Error('Invalid argument options.parentId provided');
}
if (!options.model) {
throw new Error('Invalid argument options.model provided');
}
payloadData = this.checkPayloadData(payloadData);
var model = Object.assign({}, options.model);
// if no id provided on the model, generate a unique id
// TODO: verify that drag and drop works as expected;
// possibly will need to always refresh the id or check if model does not already exist
if (!model.id || !options.modelIdsValid) {
model.id = UniqueId.get('content');
}
if (options.layoutProperties && options.layoutProperties.style) {
model.style = Object.assign({}, model.style || {}, options.layoutProperties.style);
}
this.layout.addArray([{
parentId: options.parentId,
insertBefore: options.insertBefore,
model: model
}], sender, payloadData);
return model.id;
},
/**
* Remove a content from the model.
*
* @param id
* @param sender
* @param payloadData - Additional data that will be included in the event payload.
*/
removeContent: function removeContent(id, sender, payloadData) {
payloadData = this.checkPayloadData(payloadData);
this.layout.removeArray([id], sender, payloadData);
},
/**
* Add a widget to the model.
*
* @param options
* options.model
* options.parentId
* options.insertBefore
* options.layoutProperties
* @param sender - If available, the sender will be added to the event payload.
* @param payloadData - Additional data that will be included in the event payload.
*/
addWidget: function addWidget(options, sender, payloadData) {
//If no parent id was passed in, cancel the add
if (!options.parentId) {
return;
}
// Create a default transaction id if none is provided so that it is easier to bundler subsequent operation with this one
payloadData = this.checkPayloadData(payloadData);
var model = this._addWidgetModel(options.model, { id: options.id });
if (options.id) {
//this is when a widget was already loaded (but not added to canvas)
//adding to canvas here will use the same id as in the widget for the widget and layout model
//adding will not result in reloading of the widget, but will just add the required models (and layout view obj, which will contain the
//pre-loaded widget)
model.id = options.id;
}
var id = model.id;
// Add to the layout
var layoutModel = _.extend({}, options.layoutProperties, {
type: 'widget',
id: id
});
this.layout.addArray([{
parentId: options.parentId,
insertBefore: options.insertBefore,
model: layoutModel
}], sender, payloadData);
return this._triggerAddRemove('addWidget', {
op: 'addWidget',
parameter: _.extend({}, options, {
model: model.toJSON(),
layoutProperties: $.extend(true, {}, layoutModel)
})
}, {
op: 'removeWidget',
parameter: id
}, sender, payloadData);
},
/**
*
* Add a fragment to the model.
*
* passed model can contain a parent layout or array of layouts
*
* @param options
* options.model which contains
* {
* layout: {
* //one parent layout or parent layout with nested layouts
* //one or widgets can be one or more of these layouts
* id: xxxx
* type: yyy
* items: [{
* id: x1
* type: x2
* },
* ...
* ],
* style: {
* height: aaa
* width: bbb
* top: ccc
* left: ddd
* }
* },
* episodes : [
* {
* "id": "x1",
* "type": "widget",
* "acts": [
* {
* "id": "act1",
* "timer": 0,
* "action": "show"
* },
* {
* "id": "act2",
* "timer": 5000,
* "action": "hide"
* }
* ]
* }
* widgets : [
* {
* id: xxxx
* type: yyyy
* widget model data
* },
* ...
* ],
* datasetShapings : [
* {
* id: xxxx,
* calculations: []
* },
* ...
* ]
* }
* options.parentId
* options.insertBefore
*
* If layout is an array, it should like:
* layout: [{
* id: xxxx
* type: yyy
* items: [{
* id: x1
* type: x2
* },
* ...
* ],
* style: {
* height: aaa
* width: bbb
* top: ccc
* left: ddd
* }
* }, {
* id: xxxx
* type: yyy
* items: [{
* id: x1
* type: x2
* },
* ...
* ]
* }]
* @param sender - If available, the sender will be added to the event payload.
* @param payloadData - Additional data that will be included in the event payload.
*/
addFragment: function addFragment(options, sender, payloadData) {
var _this4 = this;
// TODO this logic should be moved out of the model and into a BoardModelManager class
// Create a default transaction id if none is provided so that it is easier to bundler subsequent operation with this one
payloadData = this.checkPayloadData(payloadData);
//make a copy
var fragSpec = _.extend({}, options.model);
var datasources = this.dashboardApi.getFeature('dataSources.deprecated');
var sourceCollection = datasources ? datasources.getSourcesCollection() : undefined;
var sourceIdMap = sourceCollection ? sourceCollection.addSourcesForPin(fragSpec, { payloadData: payloadData }) : {};
//add all widgets in fragment spec
var widgetIdMap = {};
_.each(fragSpec.widgets, function (widgetModel) {
// replace widget ids in fragment with actual ones if the options tell us to
// in some cases the id is already unique and valid. Mainly in the redo after undo case
var oldId = widgetModel.id;
if (!options.modelIdsValid) {
widgetModel.id = undefined;
}
// Update the modelRef to the new sourceId if necessary
var dataViews = widgetModel.data ? widgetModel.data.dataViews : null;
if (dataViews) {
dataViews.forEach(function (dataView) {
if (sourceIdMap[dataView.modelRef]) {
dataView.modelRef = sourceIdMap[dataView.modelRef];
}
});
}
var model = _this4._addWidgetModel(widgetModel);
//keep a note of them, so that we can update layout spec
widgetIdMap[oldId] = model.id;
//update id in widgetModel with the new id from the model
//That solves the redo (adding pin back) not working problem
widgetModel.id = model.id;
});
//update the position information in layout if layoutProperies is defined
//layoutProperties is defined when pin is created by clicking on create button
if (options.layoutProperties && !_.isArray(fragSpec.layout)) {
fragSpec.layout.style = fragSpec.layout.style || {};
fragSpec.layout.style = _.extend(fragSpec.layout.style, options.layoutProperties.style);
}
//update widget ids in fragment spec to reflect new widget ids if we have not done it already
if (!options.modelIdsValid) {
fragSpec.layout = this._updateFragmentSpecLayout(fragSpec.layout, widgetIdMap, options);
}
//update drill through definitions
var drillThroughService = void 0;
try {
drillThroughService = this.dashboardApi.getDashboardCoreSvc('DrillThroughService');
} catch (error) {
this.logger.info(error);
}
if (drillThroughService) {
drillThroughService.addDrillThroughOnAddFragment(options.model, sourceIdMap, widgetIdMap, fragSpec);
}
// Add any custom colors
if (fragSpec.properties && fragSpec.properties.customColors && fragSpec.properties.customColors.colors) {
this.properties.customColors.addCustomColor(fragSpec.properties.customColors.colors);
}
if (fragSpec.fredIsRed && _.isEmpty(this.fredIsRed.colorMap)) {
this.fredIsRed.colorMap = fragSpec.fredIsRed.colorMap;
}
//create layout using layout spec
var layoutPayload = this.layout.addArray(this._getAddArrayPayload(fragSpec, options), sender, payloadData);
//undo relies on just removing parent layout of the fragment
var modelArray = layoutPayload.prevValue.parameter;
// update pageContext
_.each(fragSpec.pageContext, function (pageContextItem) {
// TODO: For now, only origin=filter and tupleSet or conditions are handled
if (pageContextItem.origin === 'filter') {
var _options = void 0;
if (pageContextItem.tupleSet) {
_options = {
values: _.values(JSON.parse(pageContextItem.tupleSet))
};
// TODO: Why is pagecontext conditions an array with'from' and 'to' arrays as well? I tried to see if it is possible
// TODO: to have more than one value in the conditions property from the UI, I couldn't find a way. The code in
// TODO: LiveWidget:PageContextRangeConditions.js expects values, it doesn't seem to handle arrays. This should be
// TODO: looked at to be only scalar values, not arrays and handled in the spec schema accordingly so it validates
} else if (pageContextItem.conditions) {
_options = {
'condition': {
attributeUniqueNames: pageContextItem.conditions[0].attributeUniqueNames,
from: pageContextItem.conditions[0].from[0],
to: pageContextItem.conditions[0].to[0]
}
};
} else {
_this4.logger.error('Error: AddFragment() - Only able to handle pageContext tupleSet and conditions, can not handle ' + JSON.stringify(pageContextItem));
}
_options = _.extend(_options, {
scope: pageContextItem.scope,
openViewOnLoad: false,
exclude: pageContextItem.exclude,
payloadData: payloadData
});
_this4.dashboardApi.getCanvasWhenReady().then(function (canvas) {
canvas.filterApi.addFilter({
sourceId: pageContextItem.sourceId,
itemId: pageContextItem.hierarchyUniqueNames[0]
}, _options);
}).catch(function (error) {
_this4.logger.error(error);
});
} else {
_this4.logger.error('Error: AddFragment() - Only able to handle pagecontext.origin=filter, not ' + pageContextItem.origin);
}
});
//trigger event
return this._triggerAddRemove('addFragment', {
op: 'addFragment',
parameter: _.extend({}, options, {
model: fragSpec,
modelIdsValid: true,
widgetIdMap: widgetIdMap
})
}, {
op: 'removeFragment',
parameter: modelArray
}, sender, payloadData);
},
_getAddArrayPayload: function _getAddArrayPayload(fragSpec, options) {
var aResult = [];
if (_.isArray(fragSpec.layout)) {
_.each(fragSpec.layout, function (entry) {
aResult.push({
parentId: options.parentId,
insertBefore: options.insertBefore,
model: entry
});
});
return aResult;
}
return [{
parentId: options.parentId,
insertBefore: options.insertBefore,
model: fragSpec.layout
}];
},
_updateFragmentSpecLayout: function _updateFragmentSpecLayout(layout, widgetIdMap) {
var boardModel = this;
var update = function update(layout, widgetIdMap) {
if (_.isArray(layout)) {
_.each(layout, function (item) {
update(item, widgetIdMap);
});
} else {
if (layout.type !== 'widget') {
// create a empty model to get an new ID.
var layoutModel = boardModel.createLayoutModel({
items: []
}, {
boardModel: boardModel,
logger: boardModel.logger
});
layoutModel.off();
widgetIdMap[layout.id] = layoutModel.id;
layout.id = layoutModel.id;
} else {
layout.id = widgetIdMap[layout.id];
}
_.each(layout.items, function (item) {
update(item, widgetIdMap);
});
}
return layout;
};
if (layout) {
return update(layout, widgetIdMap);
} else {
var addLayout = function addLayout(id) {
return {
id: id,
type: 'widget'
};
};
//this just adds widgets to a group layout - but does nothing about location of widgets or style applied
//not sure if this is the best strategy
//add a group layout if spec does not contain a layout
return {
type: 'group',
items: _.map(_.values(widgetIdMap), addLayout)
};
}
},
_getObjectFromArrayById: function _getObjectFromArrayById(array) {
var object = _.object(_.map(array, function (item) {
return [item.id, item];
}));
return object;
},
/**
*
* removes a fragment from the model
*
* @param modelIds array of layout identifiers (typically will be one container id)
*
* @param sender - If available, the sender will be added to the event payload.
* @param payloadData - Additional data that will be included in the event payload.
*/
removeFragment: function removeFragment(modelIds, sender, payloadData) {
return this.removeLayouts(modelIds, sender, payloadData);
},
/**
* Remove a widget from the model.
*
* @param id
* @param sender
* @param payloadData - Additional data that will be included in the event payload.
*/
removeWidget: function removeWidget(id, sender, payloadData) {
// Create a default transaction id if none is provided so that it is easier to bundler subsequent operation with this one
payloadData = this.checkPayloadData(payloadData);
this.trigger('pre:removeWidget', {
id: id,
sender: sender,
data: _.extend({ runtimeOnly: true }, payloadData)
});
var payload = this.layout.removeArray([id], sender, payloadData);
if (payload) {
var widgetModel = this.widgetInstances[id];
var evtData = this._triggerAddRemove('removeWidget', {
op: 'removeWidget',
parameter: id
}, {
op: 'addWidget',
parameter: {
parentId: payload.prevValue.parameter[0].parentId,
model: widgetModel.toJSON(),
layoutProperties: _.extend({}, payload.prevValue.parameter[0].model)
}
}, sender, payloadData);
this.widgetInstances[id].off('change', this.onWidgetModelChange, this);
delete this.widgetInstances[id];
return evtData;
}
},
getUsedCustomColors: function getUsedCustomColors(customColors) {
var usedColors = Model.inherited('getUsedCustomColors', this, arguments);
if (this.widgetInstances) {
for (var widgetModel in this.widgetInstances) {
usedColors = usedColors.concat(this.widgetInstances[widgetModel].getUsedCustomColors(customColors));
}
}
if (this.layout) {
usedColors = usedColors.concat(this.layout.getUsedCustomColors(customColors));
}
return _.uniq(usedColors, false);
},
/**
* Remove a list of layouts from the board model. This method will also remove all the widgets contained in the layouts being removed
*
* @param id - could be a string with one id or an array if IDs
* @param sender
* @param payloadData - Additional data that will be included in the event payload.
*/
removeLayouts: function removeLayouts(id, sender, payloadData) {
// Create a default transaction id if none is provided so that it is easier to bundler subsequent operation with this one
payloadData = this.checkPayloadData(payloadData);
var idArray = _.isArray(id) ? id : [id];
this.trigger('pre:removeLayouts', {
idArray: idArray,
sender: sender,
data: _.extend({ runtimeOnly: true }, payloadData)
});
var widgetIds = this.layout.listWidgets(idArray);
var payload = this.layout.removeArray(idArray, sender, payloadData);
if (payload) {
var removedWidgets = {};
var widgetId;
for (var i = 0; i < widgetIds.length; i++) {
widgetId = widgetIds[i];
var widgetModel = this.widgetInstances[widgetId];
if (widgetModel) {
removedWidgets[widgetId] = widgetModel.toJSON();
widgetModel.off();
delete this.widgetInstances[widgetId];
}
}
return this._triggerAddRemove('removeLayouts', {
op: 'removeLayouts',
parameter: idArray,
removedWidgets: removedWidgets
}, {
op: 'addLayouts',
parameter: {
widgetSpecMap: removedWidgets,
addLayoutArray: payload.prevValue.parameter
}
}, sender, payloadData);
}
},
/**
* Add layouts to the board. Layouts can contain widgets
*
* options.widgetSpecMap A map of widget model json to be added. The map key is the id used in the layout to reference the widget
* options.addLayoutArray = [{
* parentId - layout parent id where to add this layout
* model - layout model json
* }]
*
* @param options - widgetSpecMap, addLayoutArray
* @param sender
* @param payloadData - Additional data that will be included in the event payload.
*/
addLayouts: function addLayouts(options, sender, payloadData) {
// Create a default transaction id if none is provided so that it is easier to bundler subsequent operation with this one
payloadData = this.checkPayloadData(payloadData);
// Add widgets
if (options.widgetSpecMap) {
for (var id in options.widgetSpecMap) {
if (options.widgetSpecMap.hasOwnProperty(id)) {
this._addWidgetModel(options.widgetSpecMap[id], { id: id });
}
}
}
var layout = options.parentId ? this.layout.findModel(options.parentId) : this.layout;
if (!layout) {
layout = this.layout;
}
// Add layouts
var payload = layout.addArray(options.addLayoutArray, sender, payloadData);
return this._triggerAddRemove('addLayouts', {
op: 'addLayouts',
parameter: _.extend({}, options, {
widgetSpecMap: options.widgetSpecMap,
addLayoutArray: payload.value.parameter
})
}, {
op: 'removeLayouts',
parameter: payload.prevValue.parameter
}, sender, payloadData);
},
_isTypeRegistered: function _isTypeRegistered(type) {
var contentTypeRegistry = this.dashboardApi.getFeature('ContentTypeRegistry');
return contentTypeRegistry.isTypeRegistered(type);
},
duplicateLayout: function duplicateLayout(layoutId, sender, payload) {
var _this5 = this;
payload = this.checkPayloadData(payload);
var layoutModel = this.layout.findModel(layoutId);
var idMap = {};
var clone = function clone() {
if (layoutModel) {
if (_this5._isTypeRegistered(layoutModel.type)) {
var containerId = layoutModel.getParent().id;
var content = _this5.dashboardApi.getFeature('Canvas').getContent(layoutId);
return _this5.dashboardApi.getFeature('Canvas').addContent({
containerId: containerId,
spec: content.getFeature('Serializer').toJSON(),
copyPaste: true
}).then(function (newContent) {
var newId = newContent.getId();
idMap[layoutId] = newId;
return newId;
});
} else {
var widgetSpecMap = _this5._cloneWidgets(layoutModel, idMap);
var _clone = _this5._cloneLayout(layoutModel, idMap, payload);
var options = {
parentId: layoutModel.getParent().id,
widgetSpecMap: widgetSpecMap,
addLayoutArray: [{
model: _clone.toJSON(),
insertBefore: layoutModel.type === 'widget' ? null : layoutModel.getNextSiblingId()
}]
};
_this5.addLayouts(options, sender, payload);
return Promise.resolve(_clone.id);
}
}
return Promise.resolve();
};
return clone().then(function (cloneId) {
// all work in being done in other methods that take care of the undo/redo stack management
// however we still want to notify interested classes that a duplicate occurred.
// simplest way is to manually trigger an event and not include a senders context
// this should bypass the undoduplicateLayout/redo stack since this method did not do anything that needs to be undone.
// we still send the payload data in case someone else needs to do some undoable work in this transaction.
_this5.trigger('duplicateLayout', {
layoutId: layoutId,
cloneId: cloneId,
idMap: idMap,
sender: sender,
data: payload
});
return cloneId;
});
},
duplicateSelection: function duplicateSelection(options, sender, payload) {
var ids = [];
var payloadData = this.checkPayloadData(payload);
payloadData.limitToBounds = [];
_.each(options.modelIds, function (id) {
if (options.outBoundIds && options.outBoundIds.filter(function (e) {
return e.id === id;
}).length > 0) {
payloadData.limitToBounds.push(options.outBoundIds.filter(function (e) {
return e.id === id;
}));
}
ids.push(this.duplicateLayout(id, sender, payloadData));
}.bind(this));
return ids;
},
updateLayoutType: function updateLayoutType(options, sender, payloadData) {
payloadData = this.checkPayloadData(payloadData);
var layout = options.id ? this.layout.findModel(options.id) : this.layout;
if (layout && options.type) {
layout.set({
type: options.type
}, {
sender: sender,
payloadData: payloadData
});
}
},
/**
* Update a layout's drop zones only if the layout has at least one drop zone.
* All existing widgets will go untouched as this is purely a layout drop zone change
*
* @param options.id {string} The id of the layout that has the template/drop zones to be removed/added to
* @param options.model {object} The user selected layout model that contains the drop zones
* @param sender {object} use if a previous action has taken place and we want to combine this action with it
* @param payload {object} the payload of a previous action that has taken place
*/
updateLayoutDropZones: function updateLayoutDropZones(options, sender, payload) {
/*
* This little bit of code looks odd but the LayoutModel.findModel() method can potentially return null.
* For this reason we need to do the check that the layout variable is a falsey value and if
* so then we use the boardModel's layout instance
*/
var layout;
if (options.id) {
layout = this.layout.findModel(options.id);
}
if (!layout) {
layout = this.layout;
}
// Try to get a list of drop zones in the selected layout
var dropZones = layout.findDropZones();
// If no drop zones then there is nothing else to do
if (!dropZones) {
return payload;
}
// Remove the drop zones while saving the payload because it is needed when adding the new drop zones
payload = this.removeLayouts(dropZones.ids, sender, payload);
/*
* Create the array list of drop zone layouts to add
* Set the 'insertBefore' property to be the first widget as all widgets need to come after drop zone layouts.
* If there are no widgets then firstWidget returns undefined which is fine
*/
var firstWidget = layout.listWidgets([layout.id])[0];
var addArray = [];
for (var i = 0; i < options.model.items[0].items.length; i++) {
addArray.push({
parentId: dropZones.parentId,
model: options.model.items[0].items[i],
insertBefore: firstWidget
});
}
payload = this.addLayouts({
parentId: dropZones.parentId,
addLayoutArray: addArray
}, payload.sender, payload.data);
return payload;
},
_cloneWidgets: function _cloneWidgets(layoutModel, idMap) {
var widgetSpecMap = {};
var widgets = layoutModel.listWidgets([layoutModel.id]);
_.each(widgets, function (widgetId) {
var widgetModel = this.widgetInstances[widgetId];
var clonedWidget = widgetModel.cloneWidget(idMap);
widgetSpecMap[clonedWidget.id] = clonedWidget.toJSON();
}.bind(this));
return widgetSpecMap;
},
_cloneLayout: function _cloneLayout(layoutModel, idMap, payload) {
var clone = layoutModel.cloneLayout(idMap);
if ((clone.type === 'widget' || clone.type === 'group') && clone.style && payload.limitToBounds && payload.limitToBounds.length <= 0) {
// offset layout by 5% / 25px down/right for the cloned
clone.style.top = clone.incrementStyleValue(clone.style.top);
clone.style.left = clone.incrementStyleValue(clone.style.left);
} else if (payload.limitToBounds && payload.limitToBounds.length > 0) {
payload.limitToBounds[0].forEach(function (element) {
if (element.bottom) {
clone.style.top = clone.incrementStyleValue(clone.style.top);
}
if (element.right) {
clone.style.left = clone.incrementStyleValue(clone.style.left);
}
if (!element.right && !element.bottom) {
if (parseFloat(clone.decrementStyleValue(clone.style.top)) > 0) {
clone.style.top = clone.decrementStyleValue(clone.style.top);
}
if (parseFloat(clone.decrementStyleValue(clone.style.left)) > 0) {
clone.style.left = clone.decrementStyleValue(clone.style.left);
}
}
});
}
return clone;
},
getLanguageModelOptions: function getLanguageModelOptions() {
var addDashboardTranslatedLocales = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
var languageOptions = {
defaultLocale: this.defaultLocale,
contentLocale: this.contentLocale,
translationLocale: this.translationLocale
};
// Add in all the locales the dashboard is currently translated in. This is needed so that new MultilingualAttributes
// default to the correct locale
if (addDashboardTranslatedLocales) {
var translationService = this.dashboardApi.getDashboardCoreSvc('TranslationService');
languageOptions.availableDashboardLocales = translationService.getSelectedLanguages();
}
return languageOptions;
},
_addWidgetModel: function _addWidgetModel(widgetSpec) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (!widgetSpec.name) {
widgetSpec.name = '';
}
//The widget registry supports plugin model classes for times when custom models need to be defined.
//Live Widget (for example) is defined in an external component and has a custom model class.
var WidgetModelClass = WidgetModel;
if (widgetSpec && this.widgetRegistry && this.widgetRegistry[widgetSpec.type] && this.widgetRegistry[widgetSpec.type].ModelClass) {
WidgetModelClass = this.widgetRegistry[widgetSpec.type].ModelClass;
}
var id = options.id,
_options$addDashboard = options.addDashboardTranslatedLocales,
addDashboardTranslatedLocales = _options$addDashboard === undefined ? true : _options$addDashboard;
var languageModelOptions = this.getLanguageModelOptions(addDashboardTranslatedLocales);
var model = new WidgetModelClass(widgetSpec, languageModelOptions);
model.on('change', this.onWidgetModelChange, this);
this.widgetInstances[id || model.id] = model;
return model;
},
/**
* Called when a layout change happens that we want to propagate. (e.g. layout move, resize, etc..)
* The layout model takes care of creating the event payload with the undo/redo handler.
*
* @param payload
* @param sender
*/
onLayoutChange: function onLayoutChange(payload, sender) {
this.trigger('change:layout', payload, sender);
},
/**
* Helper function used to trigger the add/remove event
*
* @param eventName
* @param value
* @param prevValue
* @param sender
* @param payloadData - Additional data that will be included in the event payload.
*/
_triggerAddRemove: function _triggerAddRemove(eventName, value, prevValue, sender, payloadData) {
var payload = {
value: value,
prevValue: prevValue,
sender: sender,
senderContext: {
applyFn: this.applyFn.bind(this)
},
data: payloadData
};
this.trigger(eventName, payload);
return payload;
},
/**
* Function used to handler the undo/redo for the board model updates
* @param value
* @param sender
*/
applyFn: function applyFn(value, sender, name, payload) {
if (value.op && typeof this[value.op] === 'function') {
var args = [value.parameter];
args.push(sender);
args.push(payload);
this[value.op].apply(this, args);
} else {
Model.inherited('applyFn', this, arguments);
}
},
/**
* Handles changes from widget models (which can be added/removed as widgets are added/removed) and notifies
* listener of the change (so listener does not need to track addition/deletion of widget models
*
* @param payload
*/
onWidgetModelChange: function onWidgetModelChange(payload) {
var senderContext = payload.senderContext || {};
var modelId = _.isObject(payload.sender) ? payload.sender.id : payload.sender;
//TODO: Need to revist this when porting to Endor, why are we overwriting the applyFn?
//https://github.ibm.com/BusinessAnalytics/dashboard-core/pull/1311
if (payload && payload.senderContext && this.widgetInstances[modelId]) {
payload.senderContext.applyFn = function () {
var model = this.widgetInstances[modelId];
if (model) {
model.applyFn.apply(model, arguments);
}
}.bind(this);
}
this.trigger('widget:change', _.extend({
modelId: payload.model ? payload.model.id : modelId,
senderContext: senderContext
}, payload));
},
toJSON: function toJSON() {
var spec = Model.inherited('toJSON', this, [null, ['layout']]);
var canvas = this.dashboardApi.getFeature('Canvas');
var topLevelContent = canvas.findContent({ type: this.layout.type })[0];
spec.layout = topLevelContent.getFeature('Serializer').toJSON();
return spec;
},
/**
* Check the payload data
* Create a default transaction id if none is provided so that it is easier to bundler subsequent operation with this one
* @param {Object} payloadData
*/
// TODO: we're actually not "checking" anything in this method, should this be renamed?
checkPayloadData: function checkPayloadData(payloadData) {
if (payloadData) {
return payloadData;
}
return {
undoRedoTransactionId: _.uniqueId('boardModelTransaction')
};
},
/**
* Find widget model by id and type.
*
* @param {string} id - widget id
*
* @return {WidgetModel} widget model instance found
*/
findWidgetById: function findWidgetById(id) {
return this.widgetInstances ? this.widgetInstances[id] : null;
},
/**
* Find widget model matching one of the ids
*
* @param {string[]} ids - widget ids to match
*
* @return {WidgetModel} widget model instance found
*/
findWidgetByIds: function findWidgetByIds(ids) {
var finding;
ids.some(function (id) {
var breakLoop = false;
var widget = this.findWidgetById(id);
if (widget) {
finding = widget;
breakLoop = true;
}
return breakLoop;
}.bind(this));
return finding;
},
findWidgetByCriteriaFn: function findWidgetByCriteriaFn(criteriaFn) {
var finding;
for (var key in this.widgetInstances) {
if (this.widgetInstances.hasOwnProperty(key)) {
var widgetInstance = this.widgetInstances[key];
if (criteriaFn(widgetInstance)) {
finding = widgetInstance;
break;
}
}
}
return finding;
},
filterWidgetsByCriteriaFn: function filterWidgetsByCriteriaFn(criteriaFn) {
var findings = [];
for (var key in this.widgetInstances) {
if (this.widgetInstances.hasOwnProperty(key)) {
var widgetInstance = this.widgetInstances[key];
if (criteriaFn(widgetInstance)) {
findings.push(widgetInstance);
}
}
}
return findings;
},
/**
* Override the base method since we need to deal with our widgetModels and layoutModel which are
* not real nested models
*/
getContentReferences: function getContentReferences() {
var deploymentRefs = Model.inherited('getContentReferences', this, arguments);
if (this.widgetInstances) {
for (var widgetModel in this.widgetInstances) {
deploymentRefs = deploymentRefs.concat(this.widgetInstances[widgetModel].getContentReferences());
}
}
if (this.layout) {
deploymentRefs = deploymentRefs.concat(this.layout.getContentReferences());
}
return _.uniq(deploymentRefs, false, function (ref) {
return ref.value;
});
},
/**
* Should only be used by dashboard Serializer feature
* @return {Object} the inital board spec
*/
getInitialSpec: function getInitialSpec() {
return this._initBoardSpec;
},
/**
* Delete the initial board spec, it is invoked only once when canvas is ready
*/
deleteInitialSpec: function deleteInitialSpec() {
delete this._initBoardSpec;
}
});
return Model;
});
//# sourceMappingURL=BoardModel.js.map