@jylups/cmmn-js 0.0.0-stage → 0.21.0

package/lib/import/CmmnImporter.js

@@ -0,0 +1,251 @@
+'use strict';
+
+var assign = require('min-dash').assign,
+    map = require('min-dash').map;
+
+var LabelUtil = require('../util/LabelUtil');
+
+var is = require('../util/ModelUtil').is;
+
+var hasExternalLabel = LabelUtil.hasExternalLabel,
+    getExternalLabelBounds = LabelUtil.getExternalLabelBounds,
+    isCollapsed = require('../util/DiUtil').isCollapsed,
+    elementToString = require('./Util').elementToString;
+
+
+function elementData(semantic, attrs) {
+  return assign({
+    id: semantic.id,
+    type: semantic.$type,
+    businessObject: semantic
+  }, attrs);
+}
+
+function collectWaypoints(waypoints) {
+  return map(waypoints, function(p) {
+    return { x: p.x, y: p.y };
+  });
+}
+
+function notYetDrawn(semantic, refSemantic, property) {
+  return new Error(
+    'element ' + elementToString(refSemantic) + ' referenced by ' +
+      elementToString(semantic) + '#' + property + ' not yet drawn');
+}
+
+/**
+ * An importer that adds cmmn elements to the canvas
+ *
+ * @param {EventBus} eventBus
+ * @param {Canvas} canvas
+ * @param {ElementFactory} elementFactory
+ * @param {ElementRegistry} elementRegistry
+ */
+function CmmnImporter(eventBus, canvas, elementFactory, elementRegistry) {
+  this._eventBus = eventBus;
+  this._canvas = canvas;
+
+  this._elementFactory = elementFactory;
+  this._elementRegistry = elementRegistry;
+}
+
+CmmnImporter.$inject = [ 'eventBus', 'canvas', 'elementFactory', 'elementRegistry' ];
+
+module.exports = CmmnImporter;
+
+
+/**
+ * Set the diagram as root element
+ */
+CmmnImporter.prototype.root = function(diagram) {
+  var element = this._elementFactory.createRoot(elementData(diagram));
+
+  this._canvas.setRootElement(element);
+
+  return element;
+};
+
+
+/**
+ * Add cmmn element (semantic) to the canvas onto the
+ * specified parent shape.
+ */
+CmmnImporter.prototype.add = function(semantic, parentElement) {
+
+  var di = semantic.di,
+      element,
+      hidden;
+
+  // SHAPE
+  if (di && is(di, 'cmmndi:CMMNShape') && !this._getElement(semantic)) {
+
+    var collapsed = isCollapsed(semantic);
+
+    hidden = parentElement && (parentElement.hidden || parentElement.collapsed);
+
+    var bounds = semantic.di.bounds;
+
+    element = this._elementFactory.createShape(elementData(semantic, {
+      collapsed: collapsed,
+      hidden: hidden,
+      x: Math.round(bounds.x),
+      y: Math.round(bounds.y),
+      width: Math.round(bounds.width),
+      height: Math.round(bounds.height)
+    }));
+
+    if (is(semantic, 'cmmn:Criterion')) {
+      this._attachCriterion(semantic, element);
+    }
+
+    this._canvas.addShape(element, parentElement);
+  }
+
+  // CONNECTION
+  else if ((di && is(di, 'cmmndi:CMMNEdge')) || is(semantic, 'cmmndi:CMMNEdge')) {
+
+    var source = this._getSource(semantic),
+        target = this._getTarget(semantic);
+
+    hidden = (parentElement && (parentElement.hidden || parentElement.collapsed)) ||
+                 (source && source.hidden) ||
+                 (target && target.hidden) ;
+
+    var waypoint = (semantic.di || {}).waypoint || semantic.waypoint;
+
+    element = this._elementFactory.createConnection(elementData(semantic, {
+      hidden: hidden,
+      source: source,
+      target: target,
+      waypoints: collectWaypoints(waypoint)
+    }));
+
+    this._canvas.addConnection(element, parentElement);
+  } else {
+    throw new Error('unknown di ' + elementToString(di) + ' for element ' + elementToString(semantic));
+  }
+
+  // (optional) LABEL
+  if (hasExternalLabel(semantic)) {
+    this.addLabel(semantic, element);
+  }
+
+  this._eventBus.fire('cmmnElement.added', { element: element });
+
+  return element;
+};
+
+
+/**
+ * Attach the criterion element to the given host
+ *
+ * @param {ModdleElement} criterionSemantic
+ * @param {djs.model.Base} criterionElement
+ */
+CmmnImporter.prototype._attachCriterion = function(criterionSemantic, criterionElement) {
+  var hostSemantic = criterionSemantic.$parent;
+
+  if (!hostSemantic) {
+    throw new Error('missing ' + elementToString(criterionSemantic) + '$parent');
+  }
+
+  var host = this._elementRegistry.get(hostSemantic.id),
+      attachers = host && host.attachers;
+
+  if (!host) {
+    throw notYetDrawn(criterionSemantic, hostSemantic, 'criterion');
+  }
+
+  // wire element.host <> host.attachers
+  criterionElement.host = host;
+
+  if (!attachers) {
+    host.attachers = attachers = [];
+  }
+
+  if (attachers.indexOf(criterionElement) === -1) {
+    attachers.push(criterionElement);
+  }
+};
+
+
+/**
+ * add label for an element
+ */
+CmmnImporter.prototype.addLabel = function(semantic, element) {
+  var bounds = getExternalLabelBounds(semantic, element);
+
+  var label = this._elementFactory.createLabel(elementData(semantic, {
+    id: semantic.id + '_label',
+    labelTarget: element,
+    type: 'label',
+    hidden: element.hidden,
+    x: Math.round(bounds.x),
+    y: Math.round(bounds.y),
+    width: Math.round(bounds.width),
+    height: Math.round(bounds.height)
+  }));
+
+  return this._canvas.addShape(label, element.parent);
+};
+
+CmmnImporter.prototype._getSource = function(semantic) {
+  var cmmnElement = semantic.cmmnElementRef;
+
+  if (cmmnElement) {
+
+    if (is(cmmnElement, 'cmmn:OnPart')) {
+
+      if (cmmnElement.exitCriterionRef) {
+        return this._getEnd(cmmnElement, 'exitCriterionRef');
+      }
+
+      return this._getEnd(cmmnElement, 'sourceRef');
+
+    }
+
+    if (is(cmmnElement, 'cmmn:Association')) {
+      return this._getEnd(cmmnElement, 'sourceRef');
+    }
+
+  }
+
+  if (is(semantic, 'cmmndi:CMMNEdge')) {
+    return this._getEnd(semantic, 'sourceCMMNElementRef');
+  }
+
+};
+
+CmmnImporter.prototype._getTarget = function(semantic) {
+  var cmmnElement = semantic.cmmnElementRef;
+
+  if (cmmnElement) {
+
+    if (is(cmmnElement, 'cmmn:Association')) {
+      return this._getEnd(cmmnElement, 'targetRef');
+    }
+
+  }
+
+  return this._getEnd(semantic, 'targetCMMNElementRef');
+};
+
+CmmnImporter.prototype._getEnd = function(semantic, side) {
+  var refSemantic = semantic[side];
+  var element = refSemantic && this._getElement(refSemantic);
+
+  if (element) {
+    return element;
+  }
+
+  if (refSemantic) {
+    throw notYetDrawn(semantic, refSemantic, side);
+  } else {
+    throw new Error(elementToString(semantic) + '#' + side + 'Ref not specified');
+  }
+
+};
+
+CmmnImporter.prototype._getElement = function(semantic) {
+  return this._elementRegistry.get(semantic.id);
+};

package/lib/import/CmmnTreeWalker.js

@@ -0,0 +1,410 @@
+'use strict';
+
+var forEach = require('min-dash').forEach,
+    filter = require('min-dash').filter;
+
+var Refs = require('object-refs');
+
+var elementToString = require('./Util').elementToString;
+var is = require('../util/ModelUtil').is;
+
+var Collections = require('diagram-js/lib/util/Collections');
+
+var diRefs = new Refs({ name: 'cmmnElement', enumerable: true }, { name: 'di' });
+
+
+function CmmnTreeWalker(handler) {
+
+  // list of elements to handle deferred to ensure
+  // prerequisites are drawn
+  var deferred = [];
+
+  // list of CMMNEdges which cmmnElementRef is equals null:
+  // - it is a connection which does not have a representation
+  //   in case plan model
+  // - it is a connection between a human (plan item) task and a
+  //   discretionary item
+  var connections = [];
+
+  var discretionaryConnections = {};
+
+  // list of cases to draw
+  var cases = [];
+
+  var handledDiscretionaryItems = {};
+
+  // list of elements (textAnnotations and caseFileItems)
+  var elementsWithoutParent = [];
+
+  var associations = [];
+
+  // Helpers /////////////////
+
+  function isDiscretionaryItemHandled(item) {
+    return !!handledDiscretionaryItems[item.id];
+  }
+
+  function handledDiscretionaryItem(item) {
+    handledDiscretionaryItems[item.id] = item;
+  }
+
+  /**
+   * Returns the surrounding 'cmmn:Case' element
+   *
+   * @param {ModdleElement} element
+   *
+   * @return {ModdleElement} the surrounding case
+   */
+  function getCase(element) {
+    while (element && !is(element, 'cmmn:Case')) {
+      element = element.$parent;
+    }
+    return element;
+  }
+
+  function visit(element, ctx) {
+    // call handler
+    return handler.element(element, ctx);
+  }
+
+  function visitRoot(element, diagram) {
+    return handler.root(element, diagram);
+  }
+
+  function visitIfDi(element, ctx) {
+    try {
+      handler.addItem(element);
+      return element.di && visit(element, ctx);
+    } catch (e) {
+      logError(e.message, { element: element, error: e });
+
+      console.error('failed to import ' + elementToString(element));
+      console.error(e);
+    }
+  }
+
+  /**
+   * Visit an edge (connection, association or discretionary connection).
+   *
+   * Errors, for example an edge that references an element which is not
+   * drawn, are reported as import warnings so that a single broken edge
+   * does not stop the import of the rest of the diagram.
+   */
+  function visitEdge(edge, ctx) {
+    try {
+      return visit(edge, ctx);
+    } catch (e) {
+      logError(e.message, { element: edge, error: e });
+
+      console.error('failed to import ' + elementToString(edge));
+      console.error(e);
+    }
+  }
+
+  function logError(message, context) {
+    handler.error(message, context);
+  }
+
+
+  function contextual(fn, ctx) {
+    return function(e) {
+      fn(e, ctx);
+    };
+  }
+
+  // DI handling /////////////////
+
+  function registerDi(di) {
+
+    var cmmnElement = di.cmmnElementRef;
+
+    if (cmmnElement && !is(di, 'cmmndi:CMMNEdge')) {
+
+      if (cmmnElement.di) {
+        logError('multiple DI elements defined for ' + elementToString(cmmnElement), { element: cmmnElement });
+      }
+      else {
+
+        var _case = getCase(cmmnElement);
+        if (_case && cases.indexOf(_case) === -1) {
+          // add _case to the list of cases
+          // that should be drawn
+          cases.push(_case);
+        }
+
+        if (is(cmmnElement, 'cmmn:TextAnnotation') || is(cmmnElement, 'cmmn:CaseFileItem')) {
+          elementsWithoutParent.push(cmmnElement);
+        }
+
+        diRefs.bind(cmmnElement, 'di');
+        cmmnElement.di = di;
+      }
+
+    }
+    else if (is(di, 'cmmndi:CMMNEdge')) {
+      var shouldHandle = true;
+
+      if (!isReferencingTarget(di)) {
+        shouldHandle = false;
+        logError('no target referenced in ' + elementToString(di), { element: di });
+      }
+
+      if (!isReferencingSource(di)) {
+        shouldHandle = false;
+        logError('no source referenced in ' + elementToString(di), { element: di });
+      }
+
+      if (shouldHandle) {
+
+        if (is(cmmnElement, 'cmmn:Association')) {
+          associations.push(di);
+        }
+        else if (!cmmnElement) {
+          var source = di.sourceCMMNElementRef;
+          discretionaryConnections[source.id] = discretionaryConnections[source.id] || [];
+          discretionaryConnections[source.id].push(di);
+        }
+        else {
+          connections.push(function(ctx) {
+            handleConnection(di, ctx);
+          });
+        }
+      }
+
+    }
+    else {
+      logError('no cmmnElement referenced in ' + elementToString(di), { element: di });
+    }
+  }
+
+  function isReferencingTarget(edge) {
+    if (is(edge.cmmnElementRef, 'cmmn:Association')) {
+      return !!edge.cmmnElementRef.targetRef;
+    }
+
+    return !!edge.targetCMMNElementRef;
+  }
+
+  function isReferencingSource(edge) {
+    if (is(edge.cmmnElementRef, 'cmmn:OnPart')) {
+      return !!(edge.cmmnElementRef.exitCriterionRef || edge.cmmnElementRef.sourceRef);
+    }
+
+    if (is(edge.cmmnElementRef, 'cmmn:Association')) {
+      return !!edge.cmmnElementRef.sourceRef;
+    }
+
+    return !!edge.sourceCMMNElementRef;
+  }
+
+  function handleConnection(connection, context) {
+    visitEdge(connection, context);
+  }
+
+  function handleDiagram(diagram) {
+    handleDiagramElements(diagram.diagramElements);
+  }
+
+  function handleDiagramElements(diagramElements) {
+    forEach(diagramElements, handleDiagramElement);
+  }
+
+  function handleDiagramElement(diagramElement) {
+    registerDi(diagramElement);
+  }
+
+  // Semantic handling /////////////////
+
+  function handleDefinitions(definitions, diagram) {
+    // make sure we walk the correct cmmnElement
+
+    var cmmndi = definitions.CMMNDI;
+
+    // no di -> nothing to import
+    if (!cmmndi) {
+      return;
+    }
+
+    var diagrams = cmmndi.diagrams;
+
+    if (diagram && diagrams.indexOf(diagram) === -1) {
+      throw new Error('diagram not part of cmmn:Definitions');
+    }
+
+    if (!diagram && diagrams && diagrams.length) {
+      diagram = diagrams[0];
+    }
+
+    // handle only the first diagram and ignore others
+    handleDiagram(diagram);
+
+    var context = visitRoot(diagram, diagram);
+
+    handleCases(cases, context);
+
+    forEach(elementsWithoutParent, contextual(handleElementWithoutParent));
+    forEach(associations, contextual(handleAssociation));
+  }
+
+  function handleCases(cases, context) {
+    forEach(cases, function(_case) {
+      handleCase(_case, context);
+
+      // clear collections for the next iteration
+      deferred = [];
+      connections = [];
+    });
+  }
+
+  function handleCase(_case, context) {
+    var casePlanModel = _case.casePlanModel;
+
+    var casePlanModelContext;
+    if (casePlanModel) {
+      casePlanModelContext = handleCasePlanModel(casePlanModel, context);
+    }
+
+    handleDeferred(deferred);
+
+    forEach(connections, function(d) { d(casePlanModelContext); });
+
+  }
+
+  function handleCasePlanModel(casePlanModel, context) {
+    var newCtx = visitIfDi(casePlanModel, context);
+
+    forEach(casePlanModel.exitCriteria, contextual(handleCriterion, newCtx));
+
+    handlePlanFragment(casePlanModel, newCtx);
+    handleElementsWithoutParent(casePlanModel, newCtx);
+
+    return newCtx;
+  }
+
+  function handleDeferred(deferred) {
+    forEach(deferred, function(d) { d(); });
+  }
+
+  function handlePlanFragment(planFragment, context) {
+    handlePlanItems(planFragment.planItems, context);
+
+    if (is(planFragment, 'cmmn:Stage')) {
+      handleStage(planFragment, context);
+    }
+  }
+
+  function handleStage(stage, context) {
+    handlePlanningTable(stage.planningTable, context);
+  }
+
+  function handlePlanningTable(planningTable, context) {
+    if (planningTable) {
+      forEach(planningTable.tableItems, function(tableItem) {
+        if (is(tableItem, 'cmmn:DiscretionaryItem')) {
+          handleDiscretionaryItem(tableItem, context);
+        }
+        else if (is(tableItem, 'cmmn:PlanningTable')) {
+          handlePlanningTable(tableItem, context);
+        }
+      });
+    }
+  }
+
+  function handleDiscretionaryItem(discretionayItem, context) {
+    if (isDiscretionaryItemHandled(discretionayItem)) {
+      return;
+    }
+
+    handledDiscretionaryItem(discretionayItem);
+    handleItem(discretionayItem, context);
+  }
+
+  function handlePlanItems(planItems, context) {
+    forEach(planItems, contextual(handleItem, context));
+  }
+
+  function handleItem(item, context) {
+    var newCtx = visitIfDi(item, context);
+
+    forEach(item.exitCriteria, contextual(handleCriterion, context));
+    forEach(item.entryCriteria, contextual(handleCriterion, context));
+
+    var definitionRef = item.definitionRef;
+    if (is(definitionRef, 'cmmn:PlanFragment')) {
+      handlePlanFragment(definitionRef, newCtx);
+      handleElementsWithoutParent(item, newCtx);
+    }
+    else if (is(definitionRef, 'cmmn:HumanTask')) {
+      handlePlanningTable(definitionRef.planningTable, context);
+
+      var edges = discretionaryConnections[item.id];
+      forEach(edges, contextual(handleDiscretionaryConnection, context));
+      delete discretionaryConnections[item.id];
+
+    }
+  }
+
+  function handleCriterion(criterion, context) {
+    deferred.unshift(function() {
+      visitIfDi(criterion, context);
+    });
+  }
+
+  function handleElementsWithoutParent(container, context) {
+
+    if (container.di && container.di.bounds) {
+      var elements = getEnclosedElements(elementsWithoutParent, container);
+
+      forEach(elements, function(e) {
+        Collections.remove(elementsWithoutParent, e);
+        handleElementWithoutParent(e, context);
+      });
+    }
+
+  }
+
+  function handleElementWithoutParent(element, context) {
+    if (is(element, 'cmmn:TextAnnotation')) {
+      handleTextAnnotation(element, context);
+    }
+    else if (is(element, 'cmmn:CaseFileItem')) {
+      handleCaseFileItem(element, context);
+    }
+  }
+
+  function handleCaseFileItem(caseFileItem, context) {
+    visitIfDi(caseFileItem, context);
+  }
+
+  function handleTextAnnotation(annotation, context) {
+    visitIfDi(annotation, context);
+  }
+
+  function handleAssociation(association, context) {
+    visitEdge(association, context);
+  }
+
+  function handleDiscretionaryConnection(connection, context) {
+    deferred.push(function() {
+      visitEdge(connection, context);
+    });
+  }
+
+  function getEnclosedElements(elements, container) {
+    var bounds = container.di.bounds;
+    return filter(elements, function(e) {
+      return e.di.bounds.x > bounds.x &&
+             e.di.bounds.x < (bounds.x + bounds.width) &&
+             e.di.bounds.y > bounds.y &&
+             e.di.bounds.y < (bounds.y + bounds.height);
+    });
+  }
+
+  // API /////////////////
+
+  return {
+    handleDefinitions: handleDefinitions
+  };
+}
+
+module.exports = CmmnTreeWalker;