858 lines
34 KiB
JavaScript
858 lines
34 KiB
JavaScript
|
var _ = require('underscore');
|
||
|
|
var $ = require('jquery');
|
||
|
|
var nodeIds = require('builder/value-objects/analysis-node-ids');
|
||
|
|
var MetricsTracker = require('builder/components/metrics/metrics-tracker');
|
||
|
|
var MetricsTypes = require('builder/components/metrics/metrics-types');
|
||
|
|
|
||
|
|
var SimpleStyleDefaults = require('builder/editor/style/style-defaults/simple-style-defaults');
|
||
|
|
var camshaftReference = require('./camshaft-reference');
|
||
|
|
var layerTypesAndKinds = require('./layer-types-and-kinds');
|
||
|
|
var layerColors = require('./layer-colors');
|
||
|
|
var Notifier = require('builder/components/notifier/notifier');
|
||
|
|
var resetStylePerNode = require('builder/helpers/reset-style-per-node');
|
||
|
|
var Router = require('builder/routes/router');
|
||
|
|
|
||
|
|
var TABLE_ORIGIN = 'table';
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Coordinate side-effects done on explicit interactions.
|
||
|
|
* @param {Object} params
|
||
|
|
* @param {Object} params.userModel
|
||
|
|
* @param {Object} params.analysisDefinitionsCollection
|
||
|
|
* @param {Object} params.analysisDefinitionNodesCollection
|
||
|
|
* @param {Object} params.widgetDefinitionsCollection
|
||
|
|
* @return {Object} that contains all user-actions that the user may do related to a map
|
||
|
|
*/
|
||
|
|
module.exports = function (params) {
|
||
|
|
if (!params.userModel) throw new Error('userModel is required');
|
||
|
|
if (!params.analysisDefinitionsCollection) throw new Error('analysisDefinitionsCollection is required');
|
||
|
|
if (!params.analysisDefinitionNodesCollection) throw new Error('analysisDefinitionNodesCollection is required');
|
||
|
|
if (!params.layerDefinitionsCollection) throw new Error('layerDefinitionsCollection is required');
|
||
|
|
if (!params.widgetDefinitionsCollection) throw new Error('widgetDefinitionsCollection is required');
|
||
|
|
|
||
|
|
var userModel = params.userModel;
|
||
|
|
var analysisDefinitionsCollection = params.analysisDefinitionsCollection;
|
||
|
|
var analysisDefinitionNodesCollection = params.analysisDefinitionNodesCollection;
|
||
|
|
var layerDefinitionsCollection = params.layerDefinitionsCollection;
|
||
|
|
var widgetDefinitionsCollection = params.widgetDefinitionsCollection;
|
||
|
|
|
||
|
|
var createDefaultCartoDBAttrs = function (oldLayerStyle) {
|
||
|
|
return {
|
||
|
|
kind: 'carto',
|
||
|
|
options: {
|
||
|
|
interactivity: '',
|
||
|
|
tile_style: (oldLayerStyle && oldLayerStyle.options.tile_style) || camshaftReference.getDefaultCartoCSSForType(),
|
||
|
|
cartocss: (oldLayerStyle && oldLayerStyle.options.tile_style) || camshaftReference.getDefaultCartoCSSForType(),
|
||
|
|
style_version: '2.1.1',
|
||
|
|
visible: true,
|
||
|
|
style_properties: (oldLayerStyle && oldLayerStyle.options.style_properties),
|
||
|
|
sql_wrap: (oldLayerStyle && oldLayerStyle.options.sql_wrap)
|
||
|
|
},
|
||
|
|
tooltip: oldLayerStyle ? oldLayerStyle.tooltip : {},
|
||
|
|
infowindow: oldLayerStyle ? oldLayerStyle.infowindow : {}
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
var deleteOrphanedAnalyses = function () {
|
||
|
|
analysisDefinitionNodesCollection
|
||
|
|
.toArray()
|
||
|
|
.forEach(function (nodeDefModel) {
|
||
|
|
if (!layerDefinitionsCollection.anyContainsNode(nodeDefModel)) {
|
||
|
|
nodeDefModel.destroy();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
analysisDefinitionsCollection
|
||
|
|
.toArray()
|
||
|
|
.forEach(function (analysisDefModel) {
|
||
|
|
if (!analysisDefModel.getNodeDefinitionModel()) {
|
||
|
|
analysisDefModel.destroy();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
var restoreWidgetsFromLayer = function (affectedWidgets, layerDefModel, callback, callbackOptions) {
|
||
|
|
if (!affectedWidgets || !_.isArray(affectedWidgets)) throw new Error('affectedWidgets is required');
|
||
|
|
if (!layerDefModel) throw new Error('layerDefModel is required');
|
||
|
|
if (!callback) throw new Error('callback is required');
|
||
|
|
|
||
|
|
var notification;
|
||
|
|
var restoringError;
|
||
|
|
var onWidgetFinished = _.after(affectedWidgets.length, function () {
|
||
|
|
if (notification) {
|
||
|
|
if (!restoringError) {
|
||
|
|
notification.set({
|
||
|
|
status: 'success',
|
||
|
|
info: _t('notifications.widgets.restored'),
|
||
|
|
closable: true
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
Notifier.removeNotification(notification);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
callback(layerDefModel, callbackOptions);
|
||
|
|
});
|
||
|
|
|
||
|
|
if (affectedWidgets.length > 0) {
|
||
|
|
notification = Notifier.addNotification({
|
||
|
|
status: 'loading',
|
||
|
|
info: _t('notifications.widgets.restoring'),
|
||
|
|
closable: false
|
||
|
|
});
|
||
|
|
|
||
|
|
// Create widgets with new source and layer_id
|
||
|
|
_.each(affectedWidgets, function (attrs) {
|
||
|
|
attrs.layer_id = attrs.layer_id || layerDefModel.id;
|
||
|
|
|
||
|
|
widgetDefinitionsCollection.create(
|
||
|
|
attrs, {
|
||
|
|
wait: true,
|
||
|
|
success: onWidgetFinished,
|
||
|
|
error: function (e, mdl) {
|
||
|
|
notification = Notifier.addNotification({
|
||
|
|
status: 'error',
|
||
|
|
info: _t('notifications.widgets.error.title') +
|
||
|
|
_t('notifications.widgets.error.body', {
|
||
|
|
body: '',
|
||
|
|
error: mdl && mdl.get('title')
|
||
|
|
}),
|
||
|
|
closable: true
|
||
|
|
});
|
||
|
|
restoringError = true;
|
||
|
|
onWidgetFinished();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
);
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
callback(layerDefModel, callbackOptions);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
return {
|
||
|
|
_resetStylePerNode: function (nodeDefModel, layerDefModel, forceStyleUpdate, resetQueryReady) {
|
||
|
|
resetStylePerNode(nodeDefModel, layerDefModel, forceStyleUpdate, resetQueryReady);
|
||
|
|
},
|
||
|
|
|
||
|
|
saveAnalysis: function (analysisFormModel) {
|
||
|
|
if (!analysisFormModel.isValid()) return;
|
||
|
|
|
||
|
|
var nodeDefModel = analysisDefinitionNodesCollection.get(analysisFormModel.id);
|
||
|
|
|
||
|
|
if (nodeDefModel) {
|
||
|
|
analysisFormModel.updateNodeDefinition(nodeDefModel);
|
||
|
|
var layerDefModel = layerDefinitionsCollection.findOwnerOfAnalysisNode(nodeDefModel);
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
|
||
|
|
MetricsTracker.track(MetricsTypes.MODIFIED_ANALYSIS, {
|
||
|
|
analysis: {
|
||
|
|
id: analysisFormModel.attributes['id'],
|
||
|
|
natural_id: analysisFormModel.attributes['id'],
|
||
|
|
type: analysisFormModel.attributes['type']
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
this._resetStylePerNode(nodeDefModel, layerDefModel, false, true);
|
||
|
|
} else {
|
||
|
|
nodeDefModel = analysisFormModel.createNodeDefinition(this); // delegate creation to the form, but expect it to call userActions.createAnalysisNode when done with its internal stuff
|
||
|
|
}
|
||
|
|
nodeDefModel.USER_SAVED = true;
|
||
|
|
return nodeDefModel;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a new analysis node on a particular layer.
|
||
|
|
* It's assumed to be created on top of an existing node.
|
||
|
|
* @param {Object} nodeAttrs
|
||
|
|
* @param {Object} layerDefModel - instance of layer-definition-model
|
||
|
|
* @return {Object} instance of analysis-definition-node-model
|
||
|
|
*/
|
||
|
|
createAnalysisNode: function (nodeAttrs, layerDefModel) {
|
||
|
|
var nodeDefModel = analysisDefinitionNodesCollection.add(nodeAttrs, { parse: false });
|
||
|
|
|
||
|
|
layerDefModel.save({
|
||
|
|
cartocss: camshaftReference.getDefaultCartoCSSForType(),
|
||
|
|
source: nodeDefModel.id
|
||
|
|
});
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
|
||
|
|
MetricsTracker.track(MetricsTypes.CREATED_ANALYSIS, {
|
||
|
|
analysis: {
|
||
|
|
id: nodeDefModel.attributes['id'],
|
||
|
|
natural_id: nodeDefModel.attributes['id'],
|
||
|
|
type: nodeDefModel.attributes['type']
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
this._resetStylePerNode(nodeDefModel, layerDefModel);
|
||
|
|
|
||
|
|
return nodeDefModel;
|
||
|
|
},
|
||
|
|
|
||
|
|
saveAnalysisSourceQuery: function (query, nodeDefModel, layerDefModel) {
|
||
|
|
if (!nodeDefModel) throw new Error('nodeDefModel is required');
|
||
|
|
if (nodeDefModel.get('type') !== 'source') throw new Error('nodeDefModel must be a source node');
|
||
|
|
|
||
|
|
nodeDefModel.set('query', query || '');
|
||
|
|
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
this._resetStylePerNode(nodeDefModel, layerDefModel);
|
||
|
|
layerDefModel.save(); // to make sure layer's source ref is persisted
|
||
|
|
},
|
||
|
|
|
||
|
|
saveWidgetOption: function (widgetOptionModel) {
|
||
|
|
if (!widgetOptionModel) throw new Error('widgetOptionModel is required');
|
||
|
|
|
||
|
|
if (widgetOptionModel.analysisDefinitionNodeModel()) { // Might not always have a node-definition, e.g. time-series none-option
|
||
|
|
var layerDefModel = widgetOptionModel.layerDefinitionModel();
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
}
|
||
|
|
|
||
|
|
// delegate back to form model to decide how to save
|
||
|
|
return widgetOptionModel.save(widgetDefinitionsCollection);
|
||
|
|
},
|
||
|
|
|
||
|
|
goToEditWidget: function (widgets) {
|
||
|
|
if (widgets.length === 1) {
|
||
|
|
Router.goToWidget(widgets[0].id);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
updateWidgetsOrder: function (widgets) {
|
||
|
|
return widgetDefinitionsCollection.updateWidgetsOrder(widgets);
|
||
|
|
},
|
||
|
|
|
||
|
|
saveWidget: function (widgetDefModel) {
|
||
|
|
if (!widgetDefModel) throw new Error('widgetDefModel is required');
|
||
|
|
|
||
|
|
var widgetLayerId = widgetDefModel.get('layer_id');
|
||
|
|
layerDefinitionsCollection.some(function (layerDefModel) {
|
||
|
|
if (layerDefModel.id === widgetLayerId) {
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
return true; // aborts the "some"-iterator
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
widgetDefModel.save();
|
||
|
|
},
|
||
|
|
|
||
|
|
deleteAnalysisNode: function (nodeId) {
|
||
|
|
var nodeDefModel = analysisDefinitionNodesCollection.get(nodeId);
|
||
|
|
if (!nodeDefModel) return false; // abort if there is no node-definition; nothing to delete/change
|
||
|
|
if (!nodeDefModel.canBeDeletedByUser()) return false;
|
||
|
|
|
||
|
|
var layerDefModel = layerDefinitionsCollection.findOwnerOfAnalysisNode(nodeDefModel);
|
||
|
|
var primarySourceNode = nodeDefModel.getPrimarySource();
|
||
|
|
|
||
|
|
var containsNode = function (m) {
|
||
|
|
return m !== layerDefModel && m !== nodeDefModel && m.containsNode(nodeDefModel);
|
||
|
|
};
|
||
|
|
_
|
||
|
|
.flatten([
|
||
|
|
widgetDefinitionsCollection.filter(containsNode),
|
||
|
|
layerDefinitionsCollection.filter(containsNode),
|
||
|
|
analysisDefinitionsCollection.filter(containsNode),
|
||
|
|
analysisDefinitionNodesCollection.filter(containsNode),
|
||
|
|
nodeDefModel
|
||
|
|
], true)
|
||
|
|
.forEach(function (m) {
|
||
|
|
m.destroy();
|
||
|
|
});
|
||
|
|
|
||
|
|
// Try to restore old styles if we have them, reset them if not
|
||
|
|
var oldNodeStyle = primarySourceNode.getStyleHistoryForLayer(layerDefModel.id);
|
||
|
|
if (oldNodeStyle) {
|
||
|
|
layerDefModel.set({ source: primarySourceNode.id }, { ignoreSchemaChange: true });
|
||
|
|
layerDefModel.styleModel.set(layerDefModel.styleModel.parse(oldNodeStyle.options.style_properties));
|
||
|
|
layerDefModel.set({
|
||
|
|
cartocss: oldNodeStyle.options.tile_style,
|
||
|
|
infowindow: oldNodeStyle.infowindow,
|
||
|
|
tooltip: oldNodeStyle.tooltip,
|
||
|
|
sql_wrap: oldNodeStyle.options.sql_wrap
|
||
|
|
});
|
||
|
|
} else {
|
||
|
|
layerDefModel.set({ source: primarySourceNode.id });
|
||
|
|
}
|
||
|
|
layerDefModel.save();
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
|
||
|
|
MetricsTracker.track(MetricsTypes.DELETED_ANALYSIS, {
|
||
|
|
analysis: {
|
||
|
|
id: nodeDefModel.attributes['id'],
|
||
|
|
natural_id: nodeDefModel.attributes['id'],
|
||
|
|
type: nodeDefModel.attributes['type']
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
this._resetStylePerNode(primarySourceNode, layerDefModel);
|
||
|
|
|
||
|
|
deleteOrphanedAnalyses();
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a new layer for a given table name
|
||
|
|
* @param {model} [tableModel]
|
||
|
|
* @param {object} [options]
|
||
|
|
* @param {number} [options.at]
|
||
|
|
*/
|
||
|
|
createLayerFromTable: function (tableModel, options) {
|
||
|
|
options = options || {};
|
||
|
|
|
||
|
|
var tableName = tableModel.getUnqualifiedName();
|
||
|
|
var ownerName = tableModel.getOwnerName() || userModel.get('username');
|
||
|
|
var tableGeometry = tableModel.getGeometryType() && tableModel.getGeometryType()[0];
|
||
|
|
|
||
|
|
// Setting at assumes there to be at least one non-basemap layer
|
||
|
|
var at = options.at || layerDefinitionsCollection.length;
|
||
|
|
var layerOnTop = layerDefinitionsCollection.getLayerOnTop();
|
||
|
|
var layerOnTopPos = layerDefinitionsCollection.indexOf(layerOnTop);
|
||
|
|
var hasTorque = layerDefinitionsCollection.isThereAnyTorqueLayer();
|
||
|
|
var hasLabels = layerOnTop &&
|
||
|
|
!layerTypesAndKinds.isCartoDBType(layerOnTop.get('type')) &&
|
||
|
|
!layerTypesAndKinds.isTorqueType(layerOnTop.get('type'));
|
||
|
|
|
||
|
|
if (hasTorque || hasLabels) {
|
||
|
|
layerOnTop.set('order', layerOnTopPos + 1); // persisted on collection.save in success callback below
|
||
|
|
|
||
|
|
if (hasLabels) { at--; }
|
||
|
|
if (hasTorque) { at--; }
|
||
|
|
}
|
||
|
|
|
||
|
|
var newLetter = layerDefinitionsCollection.nextLetter();
|
||
|
|
var attrs = createDefaultCartoDBAttrs();
|
||
|
|
attrs.letter = newLetter;
|
||
|
|
attrs.options.table_name = tableName;
|
||
|
|
if (ownerName) {
|
||
|
|
attrs.options.user_name = ownerName;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (tableGeometry) {
|
||
|
|
attrs.options.style_properties = {
|
||
|
|
type: 'simple',
|
||
|
|
properties: SimpleStyleDefaults.generateAttributes(tableGeometry)
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
analysisDefinitionNodesCollection.addRelatedTableData(tableModel.toJSON());
|
||
|
|
|
||
|
|
return layerDefinitionsCollection.create(attrs, {
|
||
|
|
wait: true,
|
||
|
|
at: at,
|
||
|
|
error: options.error,
|
||
|
|
origin: TABLE_ORIGIN,
|
||
|
|
success: function () {
|
||
|
|
layerDefinitionsCollection.each(function (layerDefModel) {
|
||
|
|
if (!layerDefModel.isDataLayer()) return;
|
||
|
|
if (analysisDefinitionsCollection.findAnalysisForLayer(layerDefModel)) return;
|
||
|
|
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
});
|
||
|
|
layerDefinitionsCollection.save();
|
||
|
|
|
||
|
|
var newLayerModel = _.last(layerDefinitionsCollection.models);
|
||
|
|
options.success && options.success(newLayerModel);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A layer for an existing node have different side-effects depending on the context in which the node exists.
|
||
|
|
* @param {string} nodeid
|
||
|
|
* @param {string} letter of the layer where the node change comes
|
||
|
|
* @param {object} cfg
|
||
|
|
* @param {number} cfg.at
|
||
|
|
*/
|
||
|
|
createLayerForAnalysisNode: function (nodeId, fromLayerLetter, cfg) {
|
||
|
|
var userMaxLayers = userModel.get('limits').max_layers;
|
||
|
|
if (layerDefinitionsCollection.getNumberOfDataLayers() >= userMaxLayers) {
|
||
|
|
var err = new Error('max layers reached');
|
||
|
|
err.userMaxLayers = userMaxLayers;
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
|
||
|
|
var nodeDefModel = analysisDefinitionNodesCollection.get(nodeId);
|
||
|
|
if (!nodeDefModel) throw new Error('node with id ' + nodeId + ' does not exist');
|
||
|
|
if (!cfg) throw new Error('cfg is required');
|
||
|
|
if (isNaN(cfg.at) || cfg.at <= 0) throw new Error('cfg.at must be on top of the base layer');
|
||
|
|
|
||
|
|
var newPosition = cfg.at;
|
||
|
|
|
||
|
|
var attrs;
|
||
|
|
var tableName;
|
||
|
|
var tableNameAlias;
|
||
|
|
var ownerName;
|
||
|
|
var oldNodeStyle;
|
||
|
|
var movementType;
|
||
|
|
var newLetter = layerDefinitionsCollection.nextLetter();
|
||
|
|
var affectedWidgetAttrsBySourceChange = [];
|
||
|
|
|
||
|
|
var onNewLayerSaved = function (layer, forceResetStyles) {
|
||
|
|
this._resetStylePerNode(layer.getAnalysisDefinitionNodeModel(), layer, forceResetStyles);
|
||
|
|
layerDefinitionsCollection.save(); // to persist layers order
|
||
|
|
MetricsTracker.track(MetricsTypes.DRAGGED_NODE);
|
||
|
|
}.bind(this);
|
||
|
|
|
||
|
|
var prevLayer = layerDefinitionsCollection.findWhere({ source: nodeId, letter: fromLayerLetter });
|
||
|
|
if (prevLayer) {
|
||
|
|
if (nodeDefModel.hasPrimarySource()) {
|
||
|
|
// Node is head of a layer, e.g. given nodeId A3 it should rename prev layer (A => B), and create a new layer (A)
|
||
|
|
// where the prev layer was to take over its letter identity and its primary source (A2).
|
||
|
|
// The motivation for this is to maintain the layer's state (styles, popup etc.) which really depends on the
|
||
|
|
// last analysis output than the layer itself:
|
||
|
|
// _______ _______ ______
|
||
|
|
// | A | | A | | B | <-- note that B is really A which just got moved & had it's nodes renamed
|
||
|
|
// | | | | | |
|
||
|
|
// | {A3} | => | | | {B1} |
|
||
|
|
// | [A2] | | [A2] | | [A2] |
|
||
|
|
// | [A1] | | [A1] | | |
|
||
|
|
// | [A0] | | [A0] | | |
|
||
|
|
// |______| |______| |______|
|
||
|
|
movementType = '1';
|
||
|
|
var prevOrder = layerDefinitionsCollection.indexOf(prevLayer);
|
||
|
|
var prevLetter = fromLayerLetter;
|
||
|
|
|
||
|
|
// Change identity of prevLayer (A) so it appears as the new layer (B), including its analysis
|
||
|
|
var renamedNodeId = newLetter + '1';
|
||
|
|
var renamedNodeDefModel = nodeDefModel.clone(renamedNodeId); // e.g. A3 => B1
|
||
|
|
analysisDefinitionNodesCollection.invoke('changeSourceIds', nodeId, renamedNodeId);
|
||
|
|
|
||
|
|
// We have to manage all widgets associated with the layer due to the operations we do
|
||
|
|
// creating a new one and managing the previous one
|
||
|
|
var prevLayerNodeIds = _.pluck(prevLayer.ownedPrimaryAnalysisNodes(), 'id');
|
||
|
|
var affectedWidgetsBySourceChange = widgetDefinitionsCollection.filter(function (widgetDefModel) {
|
||
|
|
return _.contains(prevLayerNodeIds, widgetDefModel.get('source'));
|
||
|
|
});
|
||
|
|
|
||
|
|
_.each(affectedWidgetsBySourceChange, function (widgetDefModel) {
|
||
|
|
var attrs;
|
||
|
|
var widgetSourceId = widgetDefModel.get('source');
|
||
|
|
|
||
|
|
// If this widget doesn't point to the "dragged" node, it will
|
||
|
|
// keep the source but the layer_id will be totally different
|
||
|
|
if (widgetSourceId !== nodeId) {
|
||
|
|
attrs = _.extend(
|
||
|
|
_.omit(widgetDefModel.toJSON(), 'id', 'layer_id', 'order'),
|
||
|
|
{
|
||
|
|
avoidNotification: true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
} else {
|
||
|
|
// On the other hand, if there is a widget pointing to the dragged node,
|
||
|
|
// it will keep the layer_id but the source will be different
|
||
|
|
attrs = _.extend(
|
||
|
|
_.omit(widgetDefModel.toJSON(), 'id', 'source', 'order'),
|
||
|
|
{
|
||
|
|
source: {
|
||
|
|
id: renamedNodeId
|
||
|
|
},
|
||
|
|
avoidNotification: true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
affectedWidgetAttrsBySourceChange.push(attrs);
|
||
|
|
widgetDefModel.attributes.avoidNotification = true;
|
||
|
|
widgetDefModel.destroy();
|
||
|
|
});
|
||
|
|
|
||
|
|
analysisDefinitionsCollection.newAnalysisForNode(renamedNodeDefModel); // will be saved by saveAnalysisForLayer later since containing that layer's node
|
||
|
|
|
||
|
|
// Modify all layers using the old node as top source and it doesn't have an analysis definition associated
|
||
|
|
layerDefinitionsCollection.each(function (layerDefModel) {
|
||
|
|
var containsAnalysisDefinition = analysisDefinitionsCollection.findAnalysisForLayer(layerDefModel);
|
||
|
|
if (!containsAnalysisDefinition && layerDefModel.get('source') === nodeId) {
|
||
|
|
layerDefModel
|
||
|
|
.set('source', renamedNodeId)
|
||
|
|
.save();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
// New layer takes over the identity of the old layer (A), and its primary source as its head node
|
||
|
|
// We apply the styles from the new header node (A2) if available
|
||
|
|
oldNodeStyle = nodeDefModel.getPrimarySource().getStyleHistoryForLayer(prevLayer.id);
|
||
|
|
tableName = prevLayer.get('table_name');
|
||
|
|
tableNameAlias = prevLayer.get('table_name_alias');
|
||
|
|
ownerName = prevLayer.get('user_name') || userModel.get('username');
|
||
|
|
attrs = createDefaultCartoDBAttrs(oldNodeStyle);
|
||
|
|
attrs.options = _.extend({}, attrs.options, {
|
||
|
|
sql: 'SELECT * FROM ' + tableName,
|
||
|
|
table_name: tableName,
|
||
|
|
table_name_alias: tableNameAlias,
|
||
|
|
letter: prevLetter,
|
||
|
|
color: layerColors.getColorForLetter(prevLetter),
|
||
|
|
source: nodeDefModel.getPrimarySource().id
|
||
|
|
});
|
||
|
|
|
||
|
|
if (ownerName) {
|
||
|
|
attrs.options.user_name = ownerName;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Tell the backend that this layer is a copy of the old one, and how to rename the analysis nodes.
|
||
|
|
// This is used to keep the style_history valid in both the old a new layer
|
||
|
|
attrs.from_layer_id = prevLayer.get('id');
|
||
|
|
attrs.from_letter = prevLetter;
|
||
|
|
var newLayerDefModel = layerDefinitionsCollection.add(attrs, { at: prevOrder });
|
||
|
|
var saveAnalysis = analysisDefinitionsCollection.saveAnalysisForLayer(newLayerDefModel);
|
||
|
|
|
||
|
|
$.when(saveAnalysis)
|
||
|
|
.done(function () {
|
||
|
|
// Update the layer after the analyses request
|
||
|
|
prevLayer.save({
|
||
|
|
letter: newLetter,
|
||
|
|
color: layerColors.getColorForLetter(newLetter),
|
||
|
|
source: renamedNodeId
|
||
|
|
}, { ignoreSchemaChange: true });
|
||
|
|
})
|
||
|
|
.fail(function () {
|
||
|
|
Notifier.addNotification({
|
||
|
|
status: 'error',
|
||
|
|
info: _t('notifications.analysis.failed'),
|
||
|
|
closable: true
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
// Remove and add prevLayer (A), to move the layers to expected positions
|
||
|
|
layerDefinitionsCollection.remove(prevLayer, { silent: true }); // silent to avoid unwanted side-effects; re-added again later
|
||
|
|
layerDefinitionsCollection.add(prevLayer, { at: newPosition });
|
||
|
|
|
||
|
|
// Reset styles from previous layer
|
||
|
|
this._resetStylePerNode(prevLayer.getAnalysisDefinitionNodeModel(), prevLayer);
|
||
|
|
|
||
|
|
newLayerDefModel.save(null, {
|
||
|
|
success: function () {
|
||
|
|
restoreWidgetsFromLayer(affectedWidgetAttrsBySourceChange, newLayerDefModel, onNewLayerSaved, !oldNodeStyle);
|
||
|
|
},
|
||
|
|
error: function () {
|
||
|
|
Notifier.addNotification({
|
||
|
|
status: 'error',
|
||
|
|
info: _t('notifications.layer.error'),
|
||
|
|
closable: true
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
nodeDefModel.destroy(); // replaced by new node
|
||
|
|
} else {
|
||
|
|
// Node is the source of a prevLayer
|
||
|
|
// Create a new layer which simply points to that source
|
||
|
|
// _______ _______ ______
|
||
|
|
// | A | | A | | B |
|
||
|
|
// | | | | | |
|
||
|
|
// | [A0] | => | [A0] | | [A0] |
|
||
|
|
// |______| |______| |______|
|
||
|
|
|
||
|
|
movementType = '2';
|
||
|
|
// Keep the same style in the new layer
|
||
|
|
oldNodeStyle = {
|
||
|
|
options: {
|
||
|
|
tile_style: prevLayer.get('cartocss'),
|
||
|
|
sql_wrap: prevLayer.get('sql_wrap'),
|
||
|
|
style_properties: prevLayer.get('style_properties')
|
||
|
|
},
|
||
|
|
infowindow: prevLayer.get('infowindow'),
|
||
|
|
tooltip: prevLayer.get('tooltip')
|
||
|
|
};
|
||
|
|
tableName = prevLayer.get('table_name');
|
||
|
|
tableNameAlias = prevLayer.get('table_name_alias');
|
||
|
|
ownerName = prevLayer.get('user_name') || userModel.get('username');
|
||
|
|
attrs = createDefaultCartoDBAttrs(oldNodeStyle);
|
||
|
|
attrs.options = _.extend({}, attrs.options, {
|
||
|
|
sql: 'SELECT * FROM ' + tableName,
|
||
|
|
table_name: tableName,
|
||
|
|
table_name_alias: tableNameAlias,
|
||
|
|
letter: newLetter,
|
||
|
|
color: layerColors.getColorForLetter(newLetter),
|
||
|
|
source: nodeId
|
||
|
|
});
|
||
|
|
if (ownerName) {
|
||
|
|
attrs.options.user_name = ownerName;
|
||
|
|
}
|
||
|
|
newLayerDefModel = layerDefinitionsCollection.create(attrs, {
|
||
|
|
at: newPosition,
|
||
|
|
success: function () {
|
||
|
|
onNewLayerSaved(newLayerDefModel, false);
|
||
|
|
},
|
||
|
|
error: function () {
|
||
|
|
Notifier.addNotification({
|
||
|
|
status: 'error',
|
||
|
|
info: _t('notifications.layer.error'),
|
||
|
|
closable: true
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Node is NOT a head of a node, e.g. given nodeId is 'a2' this would create a new layer B which takes over the
|
||
|
|
// ownership of the given node and its underlying nodes
|
||
|
|
// _______ _______ ______
|
||
|
|
// | A | | A | | B |
|
||
|
|
// | | | | | |
|
||
|
|
// | [A3] | | [A3] | | {B2} |
|
||
|
|
// | {A2} | => | {B2} | | [B1] |
|
||
|
|
// | [A1] | | | | [B0] |
|
||
|
|
// | [A0] | | | | |
|
||
|
|
// |______| |______| |______|
|
||
|
|
|
||
|
|
movementType = '3';
|
||
|
|
var linkedNodesList = nodeDefModel.linkedListBySameLetter();
|
||
|
|
|
||
|
|
var moveNode = function (oldNode) {
|
||
|
|
var newId = nodeIds.changeLetter(oldNode.id, newLetter);
|
||
|
|
var newNode = oldNode.clone(newId);
|
||
|
|
var affectedWidgetsBySourceChange = widgetDefinitionsCollection.where({ source: oldNode.id });
|
||
|
|
|
||
|
|
analysisDefinitionNodesCollection.invoke('changeSourceIds', oldNode.id, newId);
|
||
|
|
|
||
|
|
_.each(affectedWidgetsBySourceChange, function (m) {
|
||
|
|
// Store attrs from affected widget for creating a new
|
||
|
|
// instance when layer is created
|
||
|
|
affectedWidgetAttrsBySourceChange.push(
|
||
|
|
_.extend(
|
||
|
|
_.omit(m.toJSON(), 'id', 'layer_id', 'source', 'order'),
|
||
|
|
{
|
||
|
|
avoidNotification: true,
|
||
|
|
source: {
|
||
|
|
id: newId
|
||
|
|
}
|
||
|
|
}
|
||
|
|
)
|
||
|
|
);
|
||
|
|
|
||
|
|
// Destroy widgets pointing to that source until new layer is created
|
||
|
|
m.attributes.avoidNotification = true;
|
||
|
|
m.destroy();
|
||
|
|
});
|
||
|
|
|
||
|
|
return newNode;
|
||
|
|
};
|
||
|
|
var newLayerHeadNode = moveNode(linkedNodesList[0]);
|
||
|
|
_.rest(linkedNodesList).forEach(moveNode);
|
||
|
|
|
||
|
|
// Create the new layer (B). Copy the layer style from the dragged node.
|
||
|
|
var ownerLayer = layerDefinitionsCollection.findOwnerOfAnalysisNode(nodeDefModel);
|
||
|
|
oldNodeStyle = nodeDefModel.getStyleHistoryForLayer(ownerLayer.id);
|
||
|
|
tableName = ownerLayer.get('table_name');
|
||
|
|
tableNameAlias = ownerLayer.get('table_name_alias');
|
||
|
|
ownerName = ownerLayer.get('user_name') || userModel.get('username');
|
||
|
|
attrs = createDefaultCartoDBAttrs(oldNodeStyle);
|
||
|
|
attrs.options = _.extend({}, attrs.options, {
|
||
|
|
sql: 'SELECT * FROM ' + tableName,
|
||
|
|
table_name: tableName,
|
||
|
|
table_name_alias: tableNameAlias,
|
||
|
|
letter: newLetter,
|
||
|
|
color: layerColors.getColorForLetter(newLetter),
|
||
|
|
source: newLayerHeadNode.id
|
||
|
|
});
|
||
|
|
if (ownerName) {
|
||
|
|
attrs.options.user_name = ownerName;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Tell the backend that this layer is a copy of the old one, and how to rename the analysis nodes.
|
||
|
|
// This is used to keep the style_history valid in both the old a new layer
|
||
|
|
attrs.from_layer_id = ownerLayer.get('id');
|
||
|
|
attrs.from_letter = ownerLayer.get('letter');
|
||
|
|
newLayerDefModel = layerDefinitionsCollection.add(attrs, { at: newPosition });
|
||
|
|
$.when(analysisDefinitionsCollection.saveAnalysisForLayer(newLayerDefModel))
|
||
|
|
.done(function () {
|
||
|
|
newLayerDefModel.save()
|
||
|
|
.done(function () {
|
||
|
|
restoreWidgetsFromLayer(affectedWidgetAttrsBySourceChange, newLayerDefModel, onNewLayerSaved, !oldNodeStyle);
|
||
|
|
})
|
||
|
|
.fail(function () {
|
||
|
|
Notifier.addNotification({
|
||
|
|
status: 'error',
|
||
|
|
info: _t('notifications.layer.error'),
|
||
|
|
closable: true
|
||
|
|
});
|
||
|
|
});
|
||
|
|
})
|
||
|
|
.fail(function () {
|
||
|
|
Notifier.addNotification({
|
||
|
|
status: 'error',
|
||
|
|
info: _t('notifications.analysis.failed'),
|
||
|
|
closable: true
|
||
|
|
});
|
||
|
|
});
|
||
|
|
nodeDefModel.destroy(); // replaced by new node
|
||
|
|
}
|
||
|
|
|
||
|
|
deleteOrphanedAnalyses();
|
||
|
|
|
||
|
|
window.FS && window.FS.log('log', 'Node dragged out case - ' + movementType);
|
||
|
|
},
|
||
|
|
|
||
|
|
moveLayer: function (d) {
|
||
|
|
var from = d.from;
|
||
|
|
var to = d.to;
|
||
|
|
|
||
|
|
var movingLayer = layerDefinitionsCollection.at(from);
|
||
|
|
layerDefinitionsCollection.remove(movingLayer, { silent: true });
|
||
|
|
layerDefinitionsCollection.add(movingLayer, { at: to, parse: false, silent: true });
|
||
|
|
|
||
|
|
var saveAnalysisPromises = layerDefinitionsCollection
|
||
|
|
.chain()
|
||
|
|
.map(function (layerDefModel) {
|
||
|
|
var nodeDefModel = layerDefModel.getAnalysisDefinitionNodeModel();
|
||
|
|
if (nodeDefModel) {
|
||
|
|
return analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
}
|
||
|
|
})
|
||
|
|
.compact()
|
||
|
|
.value();
|
||
|
|
|
||
|
|
$.when.apply($, saveAnalysisPromises).done(function () { // http://api.jquery.com/jQuery.when/
|
||
|
|
layerDefinitionsCollection.save({
|
||
|
|
success: function () {
|
||
|
|
layerDefinitionsCollection.trigger('layerMoved', movingLayer, from, to);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
});
|
||
|
|
},
|
||
|
|
|
||
|
|
deleteLayer: function (id) {
|
||
|
|
var layerToDelete = layerDefinitionsCollection.get(id);
|
||
|
|
if (!layerToDelete.canBeDeletedByUser()) return;
|
||
|
|
|
||
|
|
var parentLayer;
|
||
|
|
var toDestroy = [];
|
||
|
|
|
||
|
|
// Iterate over each node in the list, to decide how to remove dependent objects or fold nodes (if possible)
|
||
|
|
// under another layer's linked nodes list.
|
||
|
|
var linkedNodesList = layerToDelete.ownedPrimaryAnalysisNodes();
|
||
|
|
var nodeDefModel;
|
||
|
|
|
||
|
|
for (var i = 0; i < linkedNodesList.length; i++) {
|
||
|
|
nodeDefModel = linkedNodesList[i];
|
||
|
|
|
||
|
|
parentLayer = layerDefinitionsCollection.findPrimaryParentLayerToAnalysisNode(nodeDefModel, { exclude: toDestroy });
|
||
|
|
|
||
|
|
// No parent layer? delete all dependent objects, since can't move current nodeDefModel elsewhere
|
||
|
|
if (!parentLayer) {
|
||
|
|
toDestroy.push(nodeDefModel);
|
||
|
|
|
||
|
|
layerDefinitionsCollection.each(function (layer) {
|
||
|
|
if (layer.containsNode(nodeDefModel)) {
|
||
|
|
if (!_.contains(toDestroy, layer)) {
|
||
|
|
toDestroy.push(layer);
|
||
|
|
}
|
||
|
|
|
||
|
|
widgetDefinitionsCollection.each(function (widget) {
|
||
|
|
if (!_.contains(toDestroy, widget) && widget.containsNode(nodeDefModel)) {
|
||
|
|
toDestroy.unshift(widget);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
continue; // to process all sequent nodes in the linekd list, and their (possibly) dependent objects
|
||
|
|
}
|
||
|
|
|
||
|
|
var newParentLinkedNodesList = parentLayer
|
||
|
|
.ownedPrimaryAnalysisNodes()
|
||
|
|
.concat(nodeDefModel.linkedListBySameLetter());
|
||
|
|
|
||
|
|
// Since will reassign ids from the start of list need to calculate which sequence id to start on
|
||
|
|
var idSequence = newParentLinkedNodesList.length;
|
||
|
|
var firstSequence = nodeIds.sequence(newParentLinkedNodesList[0].id);
|
||
|
|
|
||
|
|
// If first node has a higher sequence start from that one to avoid issues on renaming nodes
|
||
|
|
if (idSequence <= firstSequence) {
|
||
|
|
idSequence = firstSequence;
|
||
|
|
}
|
||
|
|
|
||
|
|
var lastNode = _.last(newParentLinkedNodesList);
|
||
|
|
if (lastNode.get('type') !== 'source') {
|
||
|
|
idSequence++; // to start on right id sequence, so last item in newParentLinkedNodesList gets assigned x1 as id, since its source will be a none-source node belong to another layer
|
||
|
|
}
|
||
|
|
|
||
|
|
// Reassign ids one-by-one, from start of list to avoid ids overlapping (e.g. [c2,c1]+[b2,b1] = [c4,c3,c2,c1])
|
||
|
|
var prevId = parentLayer.get('letter') + idSequence;
|
||
|
|
var moveNodeToParentLayer = function (node) {
|
||
|
|
var oldNodeId = node.id;
|
||
|
|
var newId = nodeIds.prev(prevId);
|
||
|
|
|
||
|
|
node.set('id', newId);
|
||
|
|
|
||
|
|
// Update any depending objects' source
|
||
|
|
analysisDefinitionNodesCollection.each(function (m) {
|
||
|
|
if (!_.contains(toDestroy, m)) {
|
||
|
|
m.changeSourceIds(oldNodeId, newId, true);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
var maybeUpdateSource = function (m) {
|
||
|
|
if (m.get('source') === oldNodeId && !_.contains(toDestroy, m)) {
|
||
|
|
m.save({ source: newId }, { silent: true });
|
||
|
|
}
|
||
|
|
};
|
||
|
|
layerDefinitionsCollection.each(maybeUpdateSource);
|
||
|
|
widgetDefinitionsCollection.each(maybeUpdateSource);
|
||
|
|
|
||
|
|
prevId = newId;
|
||
|
|
|
||
|
|
return node;
|
||
|
|
};
|
||
|
|
var newParentLayerNode = moveNodeToParentLayer(newParentLinkedNodesList[0]);
|
||
|
|
_.rest(newParentLinkedNodesList).forEach(moveNodeToParentLayer);
|
||
|
|
|
||
|
|
parentLayer.save({ source: newParentLayerNode.id });
|
||
|
|
|
||
|
|
break; // since the remaining nodes have been move to a parent layer
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!_.contains(toDestroy, layerToDelete)) {
|
||
|
|
toDestroy.push(layerToDelete);
|
||
|
|
}
|
||
|
|
|
||
|
|
var promise = $.when.apply($, // http://api.jquery.com/jQuery.when/
|
||
|
|
_.chain(toDestroy)
|
||
|
|
.reduce(function (memo, m) {
|
||
|
|
memo.push(m);
|
||
|
|
var layerDefModel = layerDefinitionsCollection.get(m.id);
|
||
|
|
if (layerDefModel) { // Also delete analyses associated with layers that are being deleted
|
||
|
|
var aDefModel = analysisDefinitionsCollection.findAnalysisForLayer(layerDefModel);
|
||
|
|
if (aDefModel) {
|
||
|
|
memo.push(aDefModel);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return memo;
|
||
|
|
}, [])
|
||
|
|
.unique()
|
||
|
|
.map(function (m) {
|
||
|
|
m.set({ avoidNotification: true }, { silent: true });
|
||
|
|
return m.destroy();
|
||
|
|
})
|
||
|
|
.value());
|
||
|
|
|
||
|
|
if (parentLayer) {
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(parentLayer);
|
||
|
|
}
|
||
|
|
deleteOrphanedAnalyses();
|
||
|
|
|
||
|
|
return promise;
|
||
|
|
},
|
||
|
|
|
||
|
|
/**
|
||
|
|
* E.g. for styles, infowindows etc.
|
||
|
|
* @param {object} layerDefModel - layer-definition-model
|
||
|
|
* @param {object} options
|
||
|
|
*/
|
||
|
|
saveLayer: function (layerDefModel, options) {
|
||
|
|
if (!layerDefModel) throw new Error('layerDefModel is required');
|
||
|
|
|
||
|
|
if (layerDefModel.isDataLayer()) {
|
||
|
|
analysisDefinitionsCollection.saveAnalysisForLayer(layerDefModel);
|
||
|
|
}
|
||
|
|
|
||
|
|
deleteOrphanedAnalyses();
|
||
|
|
|
||
|
|
var saveDefaultOptions = {
|
||
|
|
shouldPreserveAutoStyle: false
|
||
|
|
};
|
||
|
|
options = _.extend({}, saveDefaultOptions, options);
|
||
|
|
|
||
|
|
return layerDefModel.save(null, options);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
};
|