bpmn-elements 6.0.1 → 7.0.0

package/src/io/Properties.js

@@ -1,19 +1,26 @@
 import getPropertyValue from '../getPropertyValue';
 
+const propertiesSymbol = Symbol.for('properties');
+const consumingSymbol = Symbol.for('consuming');
+
 export default function Properties(activity, propertiesDef, context) {
-  if (!propertiesDef || !propertiesDef.values || !propertiesDef.values.length) return;
+  this.activity = activity;
+  this.broker = activity.broker;
+
+  const props = this[propertiesSymbol] = {
+    properties: [],
+    dataInputObjects: [],
+    dataOutputObjects: [],
+  };
 
-  const {broker, environment} = activity;
-  const formatQ = broker.getQueue('format-run-q');
-  let activityConsumer;
 
-  const {properties, dataInputObjects, dataOutputObjects} = propertiesDef.values.reduce((result, {id, ...def}) => {
+  for (const {id, ...def} of propertiesDef.values) {
     const source = {
       id,
       type: def.type,
-      name: def.name,
+      name: def.behaviour && def.behaviour.name,
     };
-    result.properties.push(source);
+    props.properties.push(source);
 
     const inputDataObjectId = getPropertyValue(def, 'behaviour.dataInput.association.source.dataObject.id');
     const outputDataObjectId = getPropertyValue(def, 'behaviour.dataOutput.association.target.dataObject.id');
@@ -22,141 +29,134 @@ export default function Properties(activity, propertiesDef, context) {
 
     if (inputDataObjectId) {
       const reference = context.getDataObjectById(inputDataObjectId);
-      result.dataInputObjects.push({id, reference});
+      props.dataInputObjects.push({id, reference});
       source.input = {
         reference,
       };
     }
     if (outputDataObjectId) {
       const reference = context.getDataObjectById(outputDataObjectId);
-      result.dataOutputObjects.push({id, reference: reference});
+      props.dataOutputObjects.push({id, reference: reference});
       source.output = {
         reference,
       };
     }
     if (inputDataStoreId) {
       const reference = context.getDataStoreById(inputDataStoreId);
-      result.dataInputObjects.push({id, reference});
+      props.dataInputObjects.push({id, reference});
       source.input = {
         reference,
       };
     }
     if (outputDataStoreId) {
       const reference = context.getDataStoreById(outputDataStoreId);
-      result.dataOutputObjects.push({id, reference});
+      props.dataOutputObjects.push({id, reference});
       source.output = {
         reference,
       };
     }
-    return result;
-  }, {
-    properties: [],
-    dataInputObjects: [],
-    dataOutputObjects: [],
-  });
-
-  const propertiesApi = {
-    type: 'properties',
-    activate,
-    deactivate,
-  };
-
-  return propertiesApi;
-
-  function activate(message) {
-    if (activityConsumer) return;
+  }
+}
 
-    if (message.fields.redelivered && message.content.properties) {
-      onActivityEvent('activity.extension.resume', message);
-    }
+const proto = Properties.prototype;
 
-    activityConsumer = broker.subscribeTmp('event', 'activity.#', onActivityEvent, {noAck: true});
-  }
+proto.activate = function activate(message) {
+  if (this[consumingSymbol]) return;
 
-  function deactivate() {
-    if (activityConsumer) activityConsumer = activityConsumer.cancel();
+  if (message.fields.redelivered && message.content.properties) {
+    this._onActivityEvent('activity.extension.resume', message);
   }
 
-  function onActivityEvent(routingKey, message) {
-    if (routingKey === 'activity.enter') {
-      return formatOnEnter(message);
-    }
+  this[consumingSymbol] = this.broker.subscribeTmp('event', 'activity.#', this._onActivityEvent.bind(this), {noAck: true});
+};
 
-    if (routingKey === 'activity.extension.resume') {
-      return formatOnEnter(message);
-    }
+proto.deactivate = function deactivate() {
+  if (this[consumingSymbol]) this[consumingSymbol] = this[consumingSymbol].cancel();
+};
 
-    if (routingKey === 'activity.execution.completed') {
-      return formatOnComplete(message);
-    }
+proto._onActivityEvent = function onActivityEvent(routingKey, message) {
+  if (routingKey === 'activity.enter') {
+    return this._formatOnEnter(message);
   }
 
-  function formatOnEnter(message) {
-    const startRoutingKey = 'run.enter.bpmn-properties';
+  if (routingKey === 'activity.extension.resume') {
+    return this._formatOnEnter(message);
+  }
 
-    if (!dataInputObjects.length) {
-      return formatQ.queueMessage({routingKey: startRoutingKey}, {
-        properties: getProperties(message),
-      });
-    }
+  if (routingKey === 'activity.execution.completed') {
+    return this._formatOnComplete(message);
+  }
+};
 
-    const endRoutingKey = 'run.enter.bpmn-properties.end';
-    formatQ.queueMessage({routingKey: startRoutingKey}, {
-      endRoutingKey,
-      properties: getProperties(message),
-    });
+proto._formatOnEnter = function formatOnEnter(message) {
+  const startRoutingKey = 'run.enter.bpmn-properties';
 
-    return read(broker, dataInputObjects, (_, responses) => {
-      broker.publish('format', endRoutingKey, {
-        properties: getProperties(message, responses),
-      });
+  const dataInputObjects = this[propertiesSymbol].dataInputObjects;
+  const broker = this.broker;
+  if (!dataInputObjects.length) {
+    return broker.getQueue('format-run-q').queueMessage({routingKey: startRoutingKey}, {
+      properties: this._getProperties(message),
     });
   }
 
-  function formatOnComplete(message) {
-    const startRoutingKey = 'run.end.bpmn-properties';
+  const endRoutingKey = 'run.enter.bpmn-properties.end';
+  broker.getQueue('format-run-q').queueMessage({routingKey: startRoutingKey}, {
+    endRoutingKey,
+    properties: this._getProperties(message),
+  });
 
-    const messageOutput = getPropertyValue(message, 'content.output.properties') || {};
-    const outputProperties = getProperties(message, messageOutput);
+  return read(broker, dataInputObjects, (_, responses) => {
+    broker.publish('format', endRoutingKey, {
+      properties: this._getProperties(message, responses),
+    });
+  });
+};
 
-    if (!dataOutputObjects.length) {
-      return formatQ.queueMessage({routingKey: startRoutingKey}, {
-        properties: outputProperties,
-      });
-    }
+proto._formatOnComplete = function formatOnComplete(message) {
+  const startRoutingKey = 'run.end.bpmn-properties';
+
+  const messageOutput = getPropertyValue(message, 'content.output.properties') || {};
+  const outputProperties = this._getProperties(message, messageOutput);
 
-    const endRoutingKey = 'run.end.bpmn-properties.end';
-    formatQ.queueMessage({routingKey: startRoutingKey}, {
-      endRoutingKey,
+  const dataOutputObjects = this[propertiesSymbol].dataOutputObjects;
+  const broker = this.broker;
+  if (!dataOutputObjects.length) {
+    return broker.getQueue('format-run-q').queueMessage({routingKey: startRoutingKey}, {
       properties: outputProperties,
     });
+  }
+
+  const endRoutingKey = 'run.end.bpmn-properties.end';
+  broker.getQueue('format-run-q').queueMessage({routingKey: startRoutingKey}, {
+    endRoutingKey,
+    properties: outputProperties,
+  });
 
-    return write(broker, dataOutputObjects, outputProperties, (_, responses) => {
-      broker.publish('format', endRoutingKey, {
-        properties: getProperties(message, responses),
-      });
+  return write(broker, dataOutputObjects, outputProperties, (_, responses) => {
+    broker.publish('format', endRoutingKey, {
+      properties: this._getProperties(message, responses),
     });
-  }
+  });
+};
 
-  function getProperties(message, values) {
-    let response = {};
+proto._getProperties = function getProperties(message, values) {
+  let response = {};
 
-    if (message.content.properties) {
-      response = {...message.content.properties};
-    }
+  if (message.content.properties) {
+    response = {...message.content.properties};
+  }
 
-    return properties.reduce((result, {id, type, name, value}) => {
-      if (!(id in result)) {
-        result[id] = {id, type, name};
-      }
+  for (const {id, type, name} of this[propertiesSymbol].properties) {
+    if (!(id in response)) {
+      response[id] = {id, type, name};
+    }
 
-      if (value !== undefined) result[id].value = environment.resolveExpression(value, message);
-      if (!values || !(id in values)) return result;
-      result[id].value = values[id].value;
-      return result;
-    }, response);
+    if (!values || !(id in values)) continue;
+    response[id].value = values[id].value;
   }
-}
+
+  return response;
+};
 
 function read(broker, dataReferences, callback) {
   const responses = {};
@@ -164,8 +164,7 @@ function read(broker, dataReferences, callback) {
 
   const dataReadConsumer = broker.subscribeTmp('data', 'data.read.#', onDataReadResponse, {noAck: true});
 
-  for (let i = 0; i < dataReferences.length; i++) {
-    const {id: propertyId, reference} = dataReferences[i];
+  for (const {id: propertyId, reference} of dataReferences) {
     reference.read(broker, 'data', 'data.read.', {correlationId: propertyId});
   }
 
@@ -184,8 +183,7 @@ function write(broker, dataReferences, properties, callback) {
   let count = 0;
   const dataWriteConsumer = broker.subscribeTmp('data', 'data.write.#', onDataWriteResponse, {noAck: true});
 
-  for (let i = 0; i < dataReferences.length; i++) {
-    const {id: propertyId, reference} = dataReferences[i];
+  for (const {id: propertyId, reference} of dataReferences) {
     const value = propertyId in properties ? properties[propertyId].value : undefined;
     reference.write(broker, 'data', 'data.write.', value, {correlationId: propertyId});
   }