@jylups/cmmn-js 0.0.0-stage → 0.21.0

package/lib/features/modeling/ElementFactory.js

@@ -0,0 +1,215 @@
+'use strict';
+
+var assign = require('min-dash').assign,
+    inherits = require('inherits');
+
+var BaseElementFactory = require('diagram-js/lib/core/ElementFactory').default,
+    LabelUtil = require('../../util/LabelUtil');
+
+var is = require('../../util/ModelUtil').is,
+    getDefinition = require('../../util/ModelUtil').getDefinition,
+    isCasePlanModel = require('../../util/ModelUtil').isCasePlanModel;
+
+var isCollapsed = require('../../util/DiUtil').isCollapsed;
+
+/**
+ * A cmmn-aware factory for diagram-js shapes
+ */
+function ElementFactory(cmmnFactory, moddle) {
+  BaseElementFactory.call(this);
+
+  this._cmmnFactory = cmmnFactory;
+  this._moddle = moddle;
+}
+
+inherits(ElementFactory, BaseElementFactory);
+
+
+ElementFactory.$inject = [ 'cmmnFactory', 'moddle' ];
+
+module.exports = ElementFactory;
+
+ElementFactory.prototype.baseCreate = BaseElementFactory.prototype.create;
+
+ElementFactory.prototype.create = function(elementType, attrs) {
+  // no special magic for labels,
+  // we assume their businessObjects have already been created
+  // and wired via attrs
+  if (elementType === 'label') {
+    return this.baseCreate(elementType, assign({ type: 'label' }, LabelUtil.DEFAULT_LABEL_SIZE, attrs));
+  }
+
+  if (elementType === 'root') {
+    return this.baseCreate(elementType, attrs);
+  }
+
+  return this.createCmmnElement(elementType, attrs);
+};
+
+
+ElementFactory.prototype.createCmmnElement = function(elementType, attrs) {
+
+  attrs = assign({}, attrs || {});
+
+  var size;
+
+  var businessObject = attrs.businessObject;
+
+  if (!businessObject) {
+    if (!attrs.type) {
+      throw new Error('no shape type specified');
+    }
+
+    var props = {};
+
+    if (attrs.name) {
+      assign(props, {
+        name: attrs.name
+      });
+    }
+
+    businessObject = this._cmmnFactory.create(attrs.type, props);
+  }
+
+
+  if (elementType === 'connection') {
+
+    if (!is(businessObject, 'cmmndi:CMMNEdge')) {
+      businessObject = this._cmmnFactory.createDiEdge(businessObject, [], {
+        id: businessObject.id + '_di'
+      });
+    }
+
+    if (!businessObject.label) {
+      businessObject.label = this._cmmnFactory.createDiLabel();
+    }
+
+    attrs.type = 'cmmndi:CMMNEdge';
+  }
+
+  if (attrs.definitionType) {
+    var definition = this._cmmnFactory.create(attrs.definitionType);
+    businessObject.definitionRef = definition;
+  }
+
+  if (attrs.sentryRef) {
+    businessObject.sentryRef = attrs.sentryRef;
+  }
+
+  if (elementType === 'shape' && !businessObject.di) {
+    businessObject.di = this._cmmnFactory.createDiShape(businessObject, {}, {
+      id: businessObject.id + '_di'
+    });
+  }
+
+  if (attrs.isCollapsed) {
+    businessObject.di.isCollapsed = attrs.isCollapsed;
+  }
+
+  if (attrs.isPlanningTableCollapsed) {
+    businessObject.di.isPlanningTableCollapsed = attrs.isPlanningTableCollapsed;
+  }
+
+  if (attrs.isStandardEventVisible) {
+    businessObject.isStandardEventVisible = attrs.isStandardEventVisible;
+  }
+
+  if (attrs.isBlocking !== undefined) {
+    businessObject.definitionRef.isBlocking = attrs.isBlocking;
+  }
+
+  if (attrs.autoComplete) {
+    businessObject.definitionRef.autoComplete = true;
+  }
+
+  size = this._getDefaultSize(businessObject);
+
+  attrs = assign({
+    businessObject: businessObject,
+    id: businessObject.id
+  }, size, attrs);
+
+  return this.baseCreate(elementType, attrs);
+};
+
+
+ElementFactory.prototype._getDefaultSize = function(semantic) {
+
+  var definition = getDefinition(semantic);
+
+  // CasePlanModel (type of semantic is 'cmmn:Stage')
+  if (isCasePlanModel(semantic)) {
+    return { width: 400, height: 250 };
+  }
+
+  if (is(definition, 'cmmn:PlanFragment')) {
+    if (isCollapsed(semantic)) {
+      return { width: 100, height: 80 };
+    }
+    else {
+      return { width: 350, height: 200 };
+    }
+  }
+
+  if (is(definition, 'cmmn:Milestone')) {
+    return { width: 100, height: 40 };
+  }
+
+  if (is(definition, 'cmmn:EventListener')) {
+    return { width: 36, height: 36 };
+  }
+
+  if (is(semantic, 'cmmn:Criterion')) {
+    return { width: 20, height: 28 };
+  }
+
+  if (is(semantic, 'cmmn:TextAnnotation')) {
+    return { width: 100, height: 30 };
+  }
+
+  if (is(semantic, 'cmmn:CaseFileItem')) {
+    return { width: 36, height: 50 };
+  }
+
+  return { width: 100, height: 80 };
+};
+
+
+ElementFactory.prototype.createPlanItemShape = function(type) {
+  return this.createShape({
+    type: 'cmmn:PlanItem',
+    businessObject: this._cmmnFactory.createItem('cmmn:PlanItem', type)
+  });
+};
+
+
+ElementFactory.prototype.createDiscretionaryItemShape = function(type) {
+  return this.createShape({
+    type: 'cmmn:DiscretionaryItem',
+    businessObject: this._cmmnFactory.createItem('cmmn:DiscretionaryItem', type)
+  });
+};
+
+
+ElementFactory.prototype.createCasePlanModelShape = function() {
+  return this.createShape({
+    type: 'cmmn:Stage',
+    businessObject: this._cmmnFactory.createCasePlanModel()
+  });
+};
+
+
+ElementFactory.prototype.createCriterionShape = function(type) {
+  return this.createShape({
+    type: type,
+    businessObject: this._cmmnFactory.createCriterion(type)
+  });
+};
+
+
+ElementFactory.prototype.createCaseFileItemShape = function() {
+  return this.createShape({
+    type: 'cmmn:CaseFileItem',
+    businessObject: this._cmmnFactory.createCaseFileItem()
+  });
+};

package/lib/features/modeling/Modeling.js

@@ -0,0 +1,185 @@
+'use strict';
+
+var inherits = require('inherits');
+
+var assign = require('min-dash').assign;
+
+var BaseModeling = require('diagram-js/lib/features/modeling/Modeling').default;
+
+var AppendShapeHandler = require('./cmd/AppendShapeHandler');
+var ReconnectConnectionHandler = require('./cmd/ReconnectConnectionHandler');
+var ReplaceShapeHandler = require('./cmd/ReplaceShapeHandler');
+
+var UpdatePropertiesHandler = require('./cmd/UpdatePropertiesHandler');
+var UpdateSemanticParentHandler = require('./cmd/UpdateSemanticParentHandler');
+var UpdateControlsHandler = require('./cmd/UpdateControlsHandler');
+
+var IdClaimHandler = require('./cmd/IdClaimHandler');
+
+/**
+ * CMMN 1.1 modeling features activator
+ *
+ * @param {EventBus} eventBus
+ * @param {ElementFactory} elementFactory
+ * @param {CommandStack} commandStack
+ */
+function Modeling(eventBus, elementFactory, commandStack, cmmnRules, rules) {
+  BaseModeling.call(this, eventBus, elementFactory, commandStack);
+
+  this._cmmnRules = cmmnRules;
+  this._rules = rules;
+}
+
+inherits(Modeling, BaseModeling);
+
+Modeling.$inject = [ 'eventBus', 'elementFactory', 'commandStack', 'cmmnRules', 'rules' ];
+
+module.exports = Modeling;
+
+
+Modeling.prototype.getHandlers = function() {
+  var handlers = BaseModeling.prototype.getHandlers.call(this);
+
+  handlers['shape.append'] = AppendShapeHandler;
+  handlers['shape.replace'] = ReplaceShapeHandler;
+  handlers['connection.reconnectStart'] = ReconnectConnectionHandler;
+  handlers['connection.reconnectEnd'] = ReconnectConnectionHandler;
+
+  handlers['element.updateProperties'] = UpdatePropertiesHandler;
+  handlers['element.updateSemanticParent'] = UpdateSemanticParentHandler;
+
+  handlers['element.updateControls'] = UpdateControlsHandler;
+
+  handlers['id.updateClaim'] = IdClaimHandler;
+
+  return handlers;
+};
+
+
+Modeling.prototype.connect = function(source, target, attrs, hints) {
+
+  var rules = this._rules;
+
+  if (!attrs) {
+    attrs = rules.allowed('connection.create', {
+      source: source,
+      target: target
+    }) || { type: 'cmmn:Association' };
+  }
+
+  if (attrs.reverse) {
+
+    if (hints) {
+      hints = {
+        connectionStart: hints.connectionEnd,
+        connectionEnd: hints.connectionStart
+      };
+    }
+
+    return this.createConnection(target, source, attrs, target.parent, hints);
+  }
+
+  return this.createConnection(source, target, attrs, source.parent, hints);
+};
+
+
+Modeling.prototype.createConnection = function(source, target, targetIndex, connection, parent, hints) {
+
+  // Overwrite existing createConnection() method to provide additional
+  // information in the context. This must be done to enable the replacement
+  // of the target element, if necessary.
+
+  if (typeof targetIndex === 'object') {
+    hints = parent;
+    parent = connection;
+    connection = targetIndex;
+    targetIndex = undefined;
+  }
+
+  var context = {
+    source: source,
+    target: target,
+    parent: parent,
+    parentIndex: targetIndex,
+    canExecute: connection,
+    hints: hints
+  };
+
+  connection = this._create('connection', connection);
+
+  assign(context, {
+    connection: connection
+  });
+
+  this._commandStack.execute('connection.create', context);
+
+  return context.connection;
+};
+
+
+Modeling.prototype.reconnectStart = function(connection, newSource, dockingOrPoints, hints) {
+  var context = {
+    connection: connection,
+    newSource: newSource,
+    dockingOrPoints: dockingOrPoints,
+    hints: hints || {}
+  };
+
+  this._commandStack.execute('connection.reconnectStart', context);
+};
+
+
+Modeling.prototype.reconnectEnd = function(connection, newTarget, dockingOrPoints, hints) {
+  var context = {
+    connection: connection,
+    newTarget: newTarget,
+    dockingOrPoints: dockingOrPoints,
+    hints: hints || {}
+  };
+
+  this._commandStack.execute('connection.reconnectEnd', context);
+};
+
+
+Modeling.prototype.updateProperties = function(element, properties, shape) {
+  this._commandStack.execute('element.updateProperties', {
+    element: element,
+    properties: properties,
+    shape: shape
+  });
+};
+
+
+Modeling.prototype.updateSemanticParent = function(element, newParent, containment, shape) {
+  this._commandStack.execute('element.updateSemanticParent', {
+    element: element,
+    newParent: newParent,
+    containment: containment,
+    shape: shape
+  });
+};
+
+
+Modeling.prototype.updateControls = function(element, values) {
+  this._commandStack.execute('element.updateControls', {
+    element: element,
+    values: values
+  });
+};
+
+
+Modeling.prototype.claimId = function(id, moddleElement) {
+  this._commandStack.execute('id.updateClaim', {
+    id: id,
+    element: moddleElement,
+    claiming: true
+  });
+};
+
+
+Modeling.prototype.unclaimId = function(id, moddleElement) {
+  this._commandStack.execute('id.updateClaim', {
+    id: id,
+    element: moddleElement
+  });
+};

package/lib/features/modeling/behavior/AttachCriterionBehavior.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var inherits = require('inherits');
+
+var CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor').default;
+
+var ModelUtil = require('../../../util/ModelUtil'),
+    is = ModelUtil.is,
+    isCasePlanModel = ModelUtil.isCasePlanModel;
+
+/*
+ * If a criterion is (re-)attached to a case plan model,
+ * then the (visual) parent must be the case plan model itself,
+ * and not the root element.
+ */
+function AttachCriterionBehavior(eventBus) {
+
+  CommandInterceptor.call(this, eventBus);
+
+  this.preExecute([ 'shape.create', 'elements.move' ], function(context) {
+
+    var shape = context.shape,
+        shapes = context.shapes,
+        parent = context.parent || context.newParent,
+        host = context.host || context.newHost;
+
+    if (!parent) {
+      return;
+    }
+
+    if (!host || !isCasePlanModel(host)) {
+      return;
+    }
+
+    if (shapes && shapes.length > 1) {
+      return;
+    }
+
+    shape = shape || shapes[0];
+
+    if (!is(shape, 'cmmn:Criterion')) {
+      return;
+    }
+
+    context.parent = context.parent && host;
+    context.newParent = context.newParent && host;
+
+  }, true);
+
+
+
+}
+
+AttachCriterionBehavior.$inject = [ 'eventBus' ];
+
+inherits(AttachCriterionBehavior, CommandInterceptor);
+
+module.exports = AttachCriterionBehavior;