octoparse-cli 0.1.14

package/node_modules/@octopus/bpmn/lib/context-helper.js

@@ -0,0 +1,198 @@
+'use strict';
+
+const pub = {};
+
+pub.getDefinitionId = function(moddleContext) {
+  return moddleContext.rootHandler.element.id;
+};
+
+pub.getProcesses = function(moddleContext) {
+  return moddleContext.rootHandler.element.rootElements.filter((e) => e.$type === 'bpmn:Process');
+};
+
+pub.getExecutableProcessId = function(moddleContext) {
+  const executable = moddleContext.rootHandler.element.rootElements.find((e) => e.$type === 'bpmn:Process' && e.isExecutable);
+  return executable && executable.id;
+};
+
+pub.getOutboundSequenceFlows = function(moddleContext, activityId) {
+  return moddleContext.references.filter((r) => r.property === 'bpmn:sourceRef' && r.id === activityId);
+};
+
+pub.hasInboundSequenceFlows = function(moddleContext, activityId) {
+  return moddleContext.references.some((r) => r.property === 'bpmn:targetRef' && r.id === activityId);
+};
+
+pub.getInboundSequenceFlows = function(moddleContext, activityId) {
+  return moddleContext.references.filter((r) => r.property === 'bpmn:targetRef' && r.id === activityId);
+};
+
+pub.getSequenceFlowTargetId = function(moddleContext, sequenceFlowId) {
+  const target = moddleContext.references.find((r) => r.property === 'bpmn:targetRef' && r.element.id === sequenceFlowId);
+  return target && target.id;
+};
+
+pub.isDefaultSequenceFlow = function(moddleContext, sequenceFlowId) {
+  return moddleContext.references.some((r) => r.property === 'bpmn:default' && r.id === sequenceFlowId);
+};
+
+pub.getTargetProcess = function(moddleContext, targetId) {
+  const elements = moddleContext.rootHandler.element.rootElements;
+  return elements.find((e) => e.$type === 'bpmn:Process' && e.flowElements.some((f) => f.id === targetId));
+};
+
+pub.getActivityIO = function(moddleContext, activityId) {
+  const activity = moddleContext.elementsById[activityId];
+  if (!activity.extensionElements || !activity.extensionElements.values) return;
+  const element = activity.extensionElements.values.find((v) => v.$type === 'camunda:InputOutput');
+  return element;
+};
+
+pub.getActivityProperties = function(moddleContext, activityId) {
+  const activity = moddleContext.elementsById[activityId];
+  if (!activity) return;
+  if (!activity.extensionElements) return;
+
+  const properties = activity.extensionElements.values.find((e) => e.$type.toLowerCase() === 'camunda:properties');
+  if (!properties || !properties.values) return;
+
+  return properties;
+};
+
+pub.getActivityFormData = function(activity) {
+  let element;
+  if (activity.extensionElements && activity.extensionElements.values) {
+    element = activity.extensionElements.values.find((v) => v.$type === 'camunda:FormData');
+  }
+  if (!element && activity.formKey) {
+    return {formKey: activity.formKey};
+  }
+
+  return element;
+};
+
+pub.getAllOutboundSequenceFlows = function(moddleContext, scopeActivityId) {
+  const scope = moddleContext.elementsById[scopeActivityId];
+  const outbound = moddleContext.references.filter((r) => {
+    if (r.property !== 'bpmn:sourceRef') return false;
+    switch (r.element.$type) {
+      case 'bpmn:MessageFlow':
+      case 'bpmn:SequenceFlow':
+        break;
+      default:
+        return false;
+    }
+
+    const sourceId = r.id;
+    return scope.flowElements.some((e) => e.id === sourceId);
+  });
+
+  return outbound;
+};
+
+pub.getChildOutputNames = function(moddleContext, taskId) {
+  const contextElement = moddleContext.elementsById[taskId];
+  if (!contextElement.dataOutputAssociations) return [];
+
+  return contextElement.dataOutputAssociations.map((association) => {
+    return pub.getDataObjectFromAssociation(moddleContext, association.id);
+  });
+};
+
+pub.getDataObjectFromAssociation = function(moddleContext, associationId) {
+  const association = moddleContext.references.find((r) => r.element.$type === 'bpmn:DataOutputAssociation' && r.element.id === associationId && r.property === 'bpmn:targetRef');
+  if (!association) return null;
+
+  const potentialRef = moddleContext.elementsById[association.id];
+  if (potentialRef.$type === 'bpmn:DataObject') return potentialRef;
+
+  return pub.getDataObjectFromRef(moddleContext, potentialRef.id);
+};
+
+pub.getDataObjectFromRef = function(moddleContext, refId) {
+  const ref = moddleContext.references.find((r) => r.element.$type === 'bpmn:DataObjectReference' && r.element.id === refId && r.property === 'bpmn:dataObjectRef');
+  if (!ref) return null;
+
+  return moddleContext.elementsById[ref.id];
+};
+
+pub.isTerminationElement = function(element) {
+  if (!element) return false;
+  if (!element.eventDefinitions) return false;
+  return element.eventDefinitions.some((e) => e.$type === 'bpmn:TerminateEventDefinition');
+};
+
+pub.getActivities = function(moddleContext, scopeActivityId) {
+  const elements = [];
+  const scope = moddleContext.elementsById[scopeActivityId];
+
+  if (!scope.flowElements) return elements;
+
+  Object.keys(moddleContext.elementsById).forEach((key) => {
+    if (!scope.flowElements.some((e) => e.id === key)) return;
+
+    const element = moddleContext.elementsById[key];
+    switch (element.$type) {
+      case 'bpmn:SequenceFlow':
+      case 'bpmn:Definitions':
+        break;
+      default:
+        elements.push(element);
+    }
+  });
+
+  return elements;
+};
+
+pub.getBoundaryEvents = function(moddleContext, scopeId) {
+  return moddleContext.references.filter((r) => r.property === 'bpmn:attachedToRef' && r.id === scopeId);
+};
+
+pub.getAttachedToActivity = function(moddleContext, eventId) {
+  return moddleContext.references.find((r) => r.property === 'bpmn:attachedToRef' && r.element.id === eventId);
+};
+
+pub.hasAttachedErrorEvent = function(moddleContext, activityId) {
+  const boundaryEvents = pub.getBoundaryEvents(moddleContext, activityId);
+  return boundaryEvents.some((e) => e.element.eventDefinitions.some((d) => d.$type === 'bpmn:ErrorEventDefinition'));
+};
+
+pub.getElementService = function(element) {
+  if (!element) return;
+  if (!element.extensionElements) return;
+
+  const connector = element.extensionElements.values.find((e) => e.$type === 'camunda:Connector');
+  if (connector) {
+    return {
+      connector: connector
+    };
+  }
+
+  const properties = element.extensionElements.values.find((e) => e.$type.toLowerCase() === 'camunda:properties');
+  if (!properties) return;
+  const property = (properties.values || properties.$children).find((c) => c.name === 'service');
+  if (!property) return;
+
+  return {
+    name: property.value
+  };
+};
+
+pub.cloneContext = (context) => {
+  const clonedContext = {
+    rootHandler: {
+      element: JSON.parse(JSON.stringify(context.rootHandler.element))
+    },
+    elementsById: JSON.parse(JSON.stringify(context.elementsById)),
+    references: JSON.parse(JSON.stringify(context.references)),
+    warnings: context.warnings.slice()
+  };
+  return clonedContext;
+};
+
+pub.getActivityErrorEventDefinition = function(activity) {
+  if (!activity || !activity.eventDefinitions) return;
+  return activity.eventDefinitions.find((ed) => ed.$type === 'bpmn:ErrorEventDefinition');
+};
+
+module.exports = pub;

package/node_modules/@octopus/bpmn/lib/events/EndEvent.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const contextHelper = require('../context-helper');
+const Activity = require('../activities/Activity');
+
+const internals = {};
+
+module.exports = internals.Event = function() {
+  Activity.apply(this, arguments);
+  this.isEnd = true;
+  this.taken = false;
+  this.terminate = contextHelper.isTerminationElement(this.activity);
+};
+
+internals.Event.prototype = Object.create(Activity.prototype);
+
+internals.Event.prototype.run = function() {
+  Activity.prototype.run.call(this);
+  this.taken = true;
+  this.emit('end', this);
+  this.leave();
+};

package/node_modules/@octopus/bpmn/lib/events/ErrorEvent.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const EventDefinition = require('../activities/EventDefinition');
+
+const internals = {};
+
+module.exports = internals.ErrorEventDefinition = function() {
+  EventDefinition.apply(this, arguments);
+  this.saveToVariables = false;
+  this.eventDefinition = this.parentContext.getErrorEventDefinition(this.activity);
+};
+
+internals.ErrorEventDefinition.prototype = Object.create(EventDefinition.prototype);
+
+internals.ErrorEventDefinition.prototype.onAttachedError = function(err, sourceActivity) {
+  if (sourceActivity) {
+    this._debug(`<${this.id}> error from <${sourceActivity.id}> caught:`, err.message);
+  }
+
+  const output = getErrorCodeAndMessage.call(this, err);
+
+  EventDefinition.prototype.complete.call(this, output);
+};
+
+function getErrorCodeAndMessage(err) {
+  const result = {};
+
+  if (err.message && this.eventDefinition.errorMessageVariable) {
+    this.saveToVariables = true;
+    result[this.eventDefinition.errorMessageVariable] = err.message;
+  }
+
+  if (err.code && this.eventDefinition.errorCodeVariable) {
+    this.saveToVariables = true;
+    result[this.eventDefinition.errorCodeVariable] = err.code;
+  }
+
+  if (!this.saveToVariables) return;
+
+  return result;
+}

package/node_modules/@octopus/bpmn/lib/events/MessageEvent.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const EventDefinition = require('../activities/EventDefinition');
+
+const internals = {};
+
+module.exports = internals.MessageEvent = function() {
+  EventDefinition.apply(this, arguments);
+};
+
+internals.MessageEvent.prototype = Object.create(EventDefinition.prototype);
+
+internals.MessageEvent.prototype.signal = function(message) {
+  this.message = message;
+  this.taken = true;
+
+  this._debug(`<${this.id}>`, 'signaled');
+  this.complete(message);
+};

package/node_modules/@octopus/bpmn/lib/events/StartEvent.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const Activity = require('../activities/Activity');
+
+const internals = {};
+
+module.exports = internals.StartEvent = function(activity, parent) {
+  Activity.call(this, activity, parent);
+  this.isStart = true;
+  this.isStartEvent = true;
+  this.form = this.parentContext.getActivityForm(activity);
+  this.saveToVariables = !!this.form;
+};
+
+internals.StartEvent.prototype = Object.create(Activity.prototype);
+
+internals.StartEvent.prototype.run = function() {
+  this.enter();
+  this.emit('start', this);
+
+  if (this.form) {
+    this.form.init();
+    this.waiting = true;
+    return this.emit('wait', this);
+  }
+
+  this.emit('end', this);
+  this.takeAllOutbound();
+};
+
+internals.StartEvent.prototype.signal = function(input) {
+  if (!this.waiting) {
+    return this.emit('error', Error(`<${this.id}> is not waiting`), this);
+  }
+
+  this.waiting = false;
+
+  this._debug(`<${this.id}>`, 'signaled', input);
+  this.complete(input);
+};
+
+internals.StartEvent.prototype.complete = function(output) {
+  const ioOutput = this.getOutput(output);
+  this.emit('end', this, ioOutput);
+  this.takeAllOutbound(ioOutput);
+};
+
+internals.StartEvent.prototype.getState = function() {
+  const state = Activity.prototype.getState.call(this);
+  if (this.waiting) state.waiting = this.waiting;
+  if (this.form) {
+    state.form = this.form.getState();
+  }
+  return state;
+};

package/node_modules/@octopus/bpmn/lib/events/TimerEvent.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const EventDefinition = require('../activities/EventDefinition');
+const expressions = require('../expressions');
+const iso8601duration = require('iso8601-duration');
+
+const internals = {};
+
+module.exports = internals.TimerEvent = function() {
+  EventDefinition.apply(this, arguments);
+  this.duration = this.eventDefinition.timeDuration.body;
+  this._debug(`<${this.id}>`, `timeout ${this.duration}`);
+};
+
+internals.TimerEvent.prototype = Object.create(EventDefinition.prototype);
+
+internals.TimerEvent.prototype.run = function() {
+  delete this.stoppedAt;
+  this.startedAt = new Date();
+
+  this.timeout = this.hasOwnProperty('timeout') ? this.timeout : resolveDuration.call(this, this.duration);
+  this._debug(`<${this.id}>`, `run for duration ${this.timeout}ms`);
+
+  this.timer = setTimeout(() => {
+    this._debug(`<${this.id}>`, 'timed out');
+    delete this.timeout;
+    this.complete();
+  }, this.timeout);
+  this.emit('start', this);
+  EventDefinition.prototype.run.call(this);
+};
+
+internals.TimerEvent.prototype.discard = function() {
+  this._debug(`<${this.id}>`, `cancel timeout ${this.timeout}ms`);
+  clearTimeout(this.timer);
+  delete this.timer;
+  EventDefinition.prototype.discard.call(this);
+};
+
+internals.TimerEvent.prototype.onAttachedEnd = function(activity) {
+  this._debug(`<${this.id}>`, `activity <${activity.id}> ended`);
+  if (this.cancelActivity) this.discard();
+};
+
+internals.TimerEvent.prototype.resume = function(state) {
+  if (state.hasOwnProperty('timeout')) {
+    this._debug(`<${this.id}>`, `resume from ${state.timeout}ms`);
+    this.timeout = state.timeout;
+  }
+};
+
+internals.TimerEvent.prototype.deactivate = function() {
+  EventDefinition.prototype.deactivate.apply(this, arguments);
+  this.stoppedAt = new Date();
+  if (this.timer) {
+    clearTimeout(this.timer);
+  }
+};
+
+internals.TimerEvent.prototype.getState = function() {
+  const state = EventDefinition.prototype.getState.apply(this, arguments);
+  if (!this.entered) return state;
+
+  const stoppedAt = this.stoppedAt || new Date();
+
+  return Object.assign(state, {
+    timeout: this.timeout - (stoppedAt - this.startedAt),
+    attachedToId: this.attachedTo.id
+  });
+};
+
+function resolveDuration(duration) {
+  duration = expressions(duration, this.parentContext.getFrozenVariablesAndServices());
+  return iso8601duration.toSeconds(iso8601duration.parse(duration)) * 1000;
+}

package/node_modules/@octopus/bpmn/lib/expressions.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const getPropertyValue = require('./getPropertyValue');
+
+const isExpressionPattern = /^\${(.+?)}$/;
+const expressionPattern = /\${(.+?)}/;
+
+function resolveExpressions(templatedString, context) {
+  let result = templatedString;
+  while (expressionPattern.test(result)) {
+    const expressionMatch = result.match(expressionPattern);
+    const innerProperty = expressionMatch[1];
+
+    if (innerProperty === 'true') {
+      return true;
+    } else if (innerProperty === 'false') {
+      return false;
+    }
+
+    const contextValue = getPropertyValue(context, innerProperty);
+
+    if (expressionMatch.input === expressionMatch[0]) {
+      return contextValue;
+    }
+
+    result = result.replace(expressionMatch[0], contextValue === undefined ? '' : contextValue);
+  }
+  return result;
+}
+
+resolveExpressions.isExpression = function(text) {
+  if (!text) return false;
+  return isExpressionPattern.test(text);
+};
+
+resolveExpressions.hasExpression = function(text) {
+  if (!text) return false;
+  return expressionPattern.test(text);
+};
+
+module.exports = resolveExpressions;

package/node_modules/@octopus/bpmn/lib/gateways/ExclusiveGateway.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const Activity = require('../activities/Activity');
+
+function ExclusiveGateway() {
+  Activity.apply(this, arguments);
+}
+
+ExclusiveGateway.prototype = Object.create(Activity.prototype);
+
+ExclusiveGateway.prototype.run = function() {
+  Activity.prototype.run.call(this);
+
+  const input = this.getInput();
+  this.emit('start', this);
+  // 增加一个wait事件 为了可以执行前等待
+  if(this.type === 'bpmn:ExclusiveGateway'){
+    this.waiting = true;
+    this.emit('wait', this); 
+  }else{
+    this.emit('end', this, this.getOutput(input));
+    this.taken = true;
+
+    takeAll.call(this, this.outbound, input);
+  }
+  
+};
+// signal 来继续执行后面的方法
+ExclusiveGateway.prototype.signal = function(childId, input) {
+  this._debug(`<${this.id}>`, `signal <${childId}>`);
+
+  if(this.waiting){
+    this.waiting = false;
+    this.emit('end', this, this.getOutput(input));
+    this.taken = true;
+
+    takeAll.call(this, this.outbound, input);
+  }
+}
+
+async function takeAll(outbound, input) {
+  this._debug(`<${this.id}>`, `take ${outbound.length} sequence flows`);
+
+  const defaultFlow = outbound.find((flow) => flow.isDefault);
+  const conditionalFlows = outbound.filter((flow) => !flow.isDefault);
+
+  let takenFlow;
+  const discardFlows = [];
+
+  for (let i = 0; i < conditionalFlows.length; i++) {
+    const sequenceFlow = conditionalFlows[i];
+    if (!takenFlow) {
+      let conditionRes;
+      let conditionResObj = sequenceFlow.evaluateCondition(input);
+      if(conditionResObj.then){
+        conditionRes = await conditionResObj;
+      }else{
+        conditionRes = conditionResObj;
+      }
+      if(conditionRes){
+        takenFlow = sequenceFlow;
+      }else{
+        discardFlows.push(sequenceFlow);
+      }
+    } else {
+      discardFlows.push(sequenceFlow);
+    }
+  }
+
+  if (!takenFlow && defaultFlow) {
+    this._debug(`<${this.id}> take default flow <${defaultFlow.id}>`);
+    defaultFlow.take();
+    conditionalFlows.forEach((flow) => flow.discard());
+  } else if (takenFlow) {
+    if (defaultFlow) discardFlows.push(defaultFlow);
+    this._debug(`<${this.id}> take conditional flow <${takenFlow.id}>`);
+    takenFlow.take();
+    discardFlows.forEach((flow) => flow.discard());
+  } else {
+    return this.emit('error', new Error(`No conditional flow was taken from <${this.id}>`), this);
+  }
+
+  this.leave();
+}
+
+module.exports = ExclusiveGateway;

package/node_modules/@octopus/bpmn/lib/gateways/InclusiveGateway.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const Activity = require('../activities/Activity');
+
+function InclusiveGateway() {
+  Activity.apply(this, arguments);
+}
+
+InclusiveGateway.prototype = Object.create(Activity.prototype);
+
+InclusiveGateway.prototype.run = function() {
+  Activity.prototype.run.call(this);
+
+  this._debug(`<${this.id}>`, 'run');
+  this.emit('start', this);
+  takeAll.call(this, this.outbound, this.parentContext.variables);
+};
+
+function takeAll(outbound) {
+  this._debug(`<${this.id}>`, `take ${outbound.length} sequence flows`);
+  const input = this.getInput();
+
+  const defaultFlow = outbound.find((flow) => flow.isDefault);
+  const conditionalFlows = outbound.filter((flow) => !flow.isDefault);
+
+  const takenFlows = [];
+  const discardFlows = [];
+
+  for (let i = 0; i < conditionalFlows.length; i++) {
+    const sequenceFlow = conditionalFlows[i];
+    if (sequenceFlow.evaluateCondition(input)) {
+      takenFlows.push(sequenceFlow);
+    } else {
+      discardFlows.push(sequenceFlow);
+    }
+  }
+
+  if (!takenFlows.length && defaultFlow) {
+    this._debug(`<${this.id}> take default flow <${defaultFlow.id}>`);
+    defaultFlow.take();
+    conditionalFlows.forEach((flow) => flow.discard());
+  } else if (takenFlows.length) {
+    if (defaultFlow) discardFlows.push(defaultFlow);
+    takenFlows.forEach((flow) => {
+      this._debug(`<${this.id}> take conditional flow <${flow.id}>`);
+      flow.take();
+    });
+    discardFlows.forEach((flow) => flow.discard());
+  } else {
+    return this.emit('error', new Error(`No conditional flow was taken from <${this.id}>`), this);
+  }
+
+  this.leave();
+}
+
+module.exports = InclusiveGateway;