octoparse-cli 0.1.14

package/node_modules/@octopus/bpmn/lib/activities/EventDefinition.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const Activity = require('./Activity');
+const debug = require('debug');
+
+function EventDefinition() {
+  Activity.apply(this, arguments);
+  this.eventDefinition = this.activity.eventDefinitions[0];
+  this.type = this.eventDefinition.$type;
+  this.attachedTo = this.parentContext.getAttachedToActivity(this.id);
+
+  if (this.attachedTo) {
+    this.isStart = false;
+  }
+  this._debug = debug(`bpmn-engine:${this.type.toLowerCase()}`);
+
+  this.cancelActivity = this.activity.hasOwnProperty('cancelActivity') ? this.activity.cancelActivity : true;
+}
+
+EventDefinition.prototype = Object.create(Activity.prototype);
+
+EventDefinition.prototype.run = function() {
+  this.taken = false;
+  Activity.prototype.run.apply(this, arguments);
+
+  this._debug(`<${this.id}>`, 'run');
+  this.emit('start', this);
+};
+
+EventDefinition.prototype.complete = function(message) {
+  this._debug(`<${this.id}>`, 'completed');
+  this.taken = true;
+  this.emit('end', this, message);
+  if (this.attachedTo && this.cancelActivity) {
+    this._debug(`<${this.id}>`, `discard <${this.attachedTo.id}>`);
+    this.attachedTo.discard();
+  }
+  this.takeAllOutbound();
+};
+
+EventDefinition.prototype.resume = function() {
+  // No op
+};
+
+EventDefinition.prototype.onAttachedStart = function(activity) {
+  this._debug(`<${this.id}>`, `activity <${activity.id}> started`);
+  this.run();
+};
+
+EventDefinition.prototype.onAttachedEnd = function(activity) {
+  this._debug(`<${this.id}>`, `activity <${activity.id}> ended`);
+  this.discard();
+};
+
+EventDefinition.prototype.onAttachedCancel = function(activity) {
+  this._debug(`<${this.id}>`, `activity <${activity.id}> canceled`);
+  this.discard();
+};
+
+EventDefinition.prototype.onAttachedError = function() {
+  // No op
+};
+
+EventDefinition.prototype.onAttachedLeave = function(activity) {
+  if (this.entered && !this.taken) {
+    this._debug(`<${this.id}>`, `activity <${activity.id}> leave`);
+    this.discard();
+  }
+};
+
+EventDefinition.prototype.setupInboundListeners = function() {
+  if (this.attachedTo) {
+    this._onAttachedStart = this.onAttachedStart.bind(this);
+    this._onAttachedEnd = this.onAttachedEnd.bind(this);
+    this._onAttachedCancel = this.onAttachedCancel.bind(this);
+    this._onAttachedError = this.onAttachedError.bind(this);
+    this._onAttachedLeave = this.onAttachedLeave.bind(this);
+
+    this.attachedTo.on('start', this._onAttachedStart);
+    this.attachedTo.on('end', this._onAttachedEnd);
+    this.attachedTo.on('cancel', this._onAttachedCancel);
+    this.attachedTo.on('error', this._onAttachedError);
+    this.attachedTo.on('leave', this._onAttachedLeave);
+  }
+  Activity.prototype.setupInboundListeners.apply(this, arguments);
+};
+
+EventDefinition.prototype.teardownInboundListeners = function() {
+  if (this.attachedTo) {
+    this.attachedTo.removeListener('start', this._onAttachedStart);
+    this.attachedTo.removeListener('end', this._onAttachedEnd);
+    this.attachedTo.removeListener('cancel', this._onAttachedCancel);
+    this.attachedTo.removeListener('error', this._onAttachedError);
+    this.attachedTo.removeListener('leave', this._onAttachedLeave);
+  }
+  Activity.prototype.teardownInboundListeners.apply(this, arguments);
+};
+
+module.exports = EventDefinition;

package/node_modules/@octopus/bpmn/lib/activities/Flow.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const debug = require('debug');
+const EventEmitter = require('events').EventEmitter;
+
+function Flow(activity, parentContext) {
+  this.id = activity.element.id;
+  this.type = activity.element.$type;
+  this.activity = activity;
+  this.parentContext = parentContext;
+  this.sourceId = activity.id;
+  this.targetId = this.parentContext.getSequenceFlowTargetId(this.id);
+
+  this.taken = false;
+
+  this._debug = debug(`bpmn-engine:${this.type.toLowerCase()}`);
+
+  this._debug(`<${this.id}>`, `init, <${this.sourceId}> -> <${this.targetId}>`);
+}
+
+Flow.prototype = Object.create(EventEmitter.prototype);
+
+Flow.prototype.take = function() {
+  this.taken = true;
+  this.discarded = false;
+  delete this.looped;
+  this._debug(`<${this.id}>`, `taken, target <${this.targetId}>`);
+  asyncEmitEvent.call(this, 'taken');
+  return this.taken;
+};
+
+Flow.prototype.discard = function(rootFlow) {
+  if (rootFlow && rootFlow.sourceId === this.targetId) {
+    this._debug(`<${this.id}>`, `detected loop <${rootFlow.sourceId}>. Stop.`);
+    this.looped = true;
+    this.emit('looped', this, rootFlow);
+    return;
+  }
+
+  this._debug(`<${this.id}>`, `discarded, target <${this.targetId}>`);
+  delete this.looped;
+  this.discarded = true;
+  asyncEmitEvent.call(this, 'discarded', rootFlow || this);
+};
+
+function asyncEmitEvent(eventName, rootFlow) {
+  setImmediate(() => {
+    this.emit(eventName, this, rootFlow);
+  });
+}
+
+module.exports = Flow;

package/node_modules/@octopus/bpmn/lib/activities/Form.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const debug = require('debug')('bpmn-engine:form');
+const expressions = require('../expressions');
+
+function Form(formData, parentContext) {
+  this.formData = formData;
+  this.parentContext = parentContext;
+  this.fields = [];
+}
+
+Form.prototype.init = function(message) {
+  if (this.formData.formKey) {
+    this.key = getFormKey.call(this, message);
+  }
+
+  if (!this.formData.fields) return;
+  this.fields = initFields.call(this, message);
+};
+
+Form.prototype.getFields = function() {
+  return this.fields;
+};
+
+Form.prototype.getState = function() {
+  const state = {};
+  if (this.key) {
+    state.key = this.key;
+  }
+
+  if (this.formData.fields) {
+    state.fields = this.formData.fields.map((field) => {
+      return {
+        id: field.id,
+        label: field.label,
+        type: field.type
+      };
+    });
+  }
+
+  return state;
+};
+
+function getFormKey(message) {
+  if (!expressions.hasExpression(this.formData.formKey)) return this.formData.formKey;
+
+  const contextVariables = this.parentContext.getFrozenVariablesAndServices(message);
+  debug(`resolve formKey "${this.formData.formKey}" value expression`);
+  return expressions(this.formData.formKey, contextVariables);
+}
+
+function initFields(message) {
+  const contextVariables = this.parentContext.getFrozenVariablesAndServices(message);
+
+  return this.formData.fields.map((formField) => {
+    const field = Object.assign({}, formField);
+
+    if (expressions.hasExpression(field.defaultValue)) {
+      debug(`resolve field <${field.id}> default value expression`);
+      field.defaultValue = expressions(field.defaultValue, contextVariables);
+    }
+
+    return field;
+  });
+}
+
+module.exports = Form;

package/node_modules/@octopus/bpmn/lib/activities/InputOutput.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const debug = require('debug');
+const Parameter = require('../parameter');
+
+function InputOutput(activity, parentContext) {
+  this.type = activity.$type;
+  this.parentContext = parentContext;
+  this._debug = debug(`bpmn-engine:io:${this.type.toLowerCase()}`);
+  this.activity = activity;
+  initParameters.call(this);
+  this.hasOutput = this.output && this.output.length;
+}
+
+InputOutput.prototype.getInput = function(message, editableContextVariables) {
+  const result = {};
+
+  if (!this.input) {
+    this._debug('no input parameters, return variables and services');
+    return this.parentContext.getVariablesAndServices(message, !editableContextVariables);
+  }
+
+  this._debug('get input from', message || 'variables');
+
+  const frozenVariablesAndServices = this.parentContext && this.parentContext.getFrozenVariablesAndServices();
+  this.input.forEach((parm) => {
+    result[parm.name] = parm.getInputValue(message, frozenVariablesAndServices);
+  });
+  return result;
+};
+
+InputOutput.prototype.getOutput = function(output) {
+  const result = {};
+  if (!this.output) {
+    return output;
+  }
+
+  const frozenVariablesAndServices = this.parentContext && this.parentContext.getFrozenVariablesAndServices();
+
+  this._debug('get output', output);
+  this.output.forEach((parm) => {
+    result[parm.name] = parm.getOutputValue(output, frozenVariablesAndServices);
+  });
+
+  return result;
+};
+
+function initParameters() {
+  this.input = this.activity.inputParameters && this.activity.inputParameters.map(Parameter);
+  this.output = this.activity.outputParameters && this.activity.outputParameters.map(Parameter);
+}
+
+module.exports = InputOutput;

package/node_modules/@octopus/bpmn/lib/activities/IntermediateCatchEvent.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const mapper = require('../mapper');
+
+function IntermediateCatchEvent(activity) {
+  const ctorArgs = Array.prototype.slice.call(arguments);
+  const Type = mapper(activity.eventDefinitions[0].$type);
+  const event = new (Function.prototype.bind.apply(Type, [null].concat(ctorArgs)))();
+  return event;
+}
+
+module.exports = IntermediateCatchEvent;

package/node_modules/@octopus/bpmn/lib/activities/MessageFlow.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const Flow = require('./Flow');
+
+function MessageFlow() {
+  Flow.apply(this, arguments);
+  this.outboundMessage = true;
+}
+
+MessageFlow.prototype = Object.create(Flow.prototype);
+
+MessageFlow.prototype.take = function(message) {
+  const taken = Flow.prototype.take.apply(this, arguments);
+  this._debug(`<${this.id}>`, 'send message:', message);
+  this.emit('message', message, this);
+  return taken;
+};
+
+module.exports = MessageFlow;

package/node_modules/@octopus/bpmn/lib/activities/MultiInstanceLoopCharacteristics.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const debug = require('debug')('bpmn-engine:bpmn:multiinstanceloopcharacteristics');
+const expressions = require('../expressions');
+const scriptHelper = require('../script-helper');
+const PrematureStopError = require('../PrematureStopError');
+
+function MultiInstanceLoopCharacteristics(activity, parentContext) {
+  this.type = activity.$type;
+
+  this.isSequential = activity.isSequential;
+  this.parentContext = parentContext;
+
+  this.characteristics = getLoopCharacteristics(activity);
+  if (!this.characteristics.type) throw new Error('Cardinality, condition expression, or collection must be defined');
+
+  debug(`${this.characteristics.type} loop type`);
+
+  this.iteration = 0;
+  this.completed = false;
+}
+
+MultiInstanceLoopCharacteristics.prototype.run = function(variables, message, result, callback) {
+  if (this.stop) {
+    this.completed = true;
+    return callback && callback(new PrematureStopError('Stopped'), true);
+  }
+
+  debug('run', variables, message);
+
+  this.iteration++;
+  this.completed = false;
+
+  if (this.characteristics.collection) {
+    const collection = this.getCollection(variables);
+    if ( collection.length <= 1) {
+      this.completed = true;
+      debug('completed collection', this.completed);
+    } else {
+      this.item = collection[0];
+    }
+  }
+
+  if (!this.completed && (this.characteristics.condition || this.characteristics.conditionExpression)) {
+    // let conditionResObj = executeCondition(this.characteristics, variables, message);
+    
+    // if(conditionResObj.then){
+    //   this.completed = conditionResObj;
+    // }else{
+    //   this.completed = conditionResObj
+    // }
+    this.completed = executeCondition(this.characteristics, variables, message);
+    debug('completed condition', this.completed);
+  }
+
+  if (!this.completed) {
+    const cardinality = getCardinality(this.characteristics, variables);
+    if (cardinality !== undefined) {
+      this.completed = this.iteration >= cardinality;
+      debug('cardinality check', this.completed);
+    }
+  }
+
+  if (callback) {
+    callback(null, this.completed);
+  }
+
+  return this.completed;
+};
+
+MultiInstanceLoopCharacteristics.prototype.getCollection = function() {
+  let collection = expressions(this.characteristics.collection, this.parentContext.getVariablesAndServices());
+  if (this.iteration > 0) {
+    collection = collection.slice(this.iteration);
+  }
+  return collection;
+};
+
+MultiInstanceLoopCharacteristics.prototype.deactivate = function() {
+  debug('stopped');
+  this.stop = true;
+};
+
+MultiInstanceLoopCharacteristics.prototype.getState = function() {
+  const state = {
+    isSequential: this.isSequential,
+    iteration: this.iteration,
+    characteristics: {
+      type: this.characteristics.type
+    }
+  };
+  if (this.characteristics.hasOwnProperty('cardinality')) {
+    state.characteristics.cardinality = this.characteristics.cardinality;
+  }
+  return state;
+};
+
+MultiInstanceLoopCharacteristics.prototype.reset = function() {
+  this.iteration = 0;
+};
+
+MultiInstanceLoopCharacteristics.prototype.resume = function(state) {
+  this.iteration = state.iteration + 1;
+  debug(`resume at iteration ${state.iteration}`);
+};
+
+function getLoopCharacteristics(activity) {
+  const characteristics = {};
+
+  if (activity.collection) {
+    characteristics.type = 'collection';
+    characteristics.collection = activity.collection;
+  }
+
+  if (activity.completionCondition && activity.completionCondition.body) {
+    if (expressions.isExpression(activity.completionCondition.body)) {
+      characteristics.conditionExpression = activity.completionCondition.body;
+    } else {
+      characteristics.condition = scriptHelper.parse('characteristics.condition', activity.completionCondition.body);
+    }
+    characteristics.type = characteristics.type || 'condition';
+  }
+
+  if (activity.loopCardinality && activity.loopCardinality.body) {
+    if (expressions.isExpression(activity.loopCardinality.body)) {
+      characteristics.cardinalityExpression = activity.loopCardinality.body;
+    } else {
+      const cardinality = Number(activity.loopCardinality.body);
+      if (!isNaN(cardinality)) {
+        characteristics.cardinality = cardinality;
+      }
+    }
+    if (!characteristics.type && (characteristics.cardinalityExpression || !isNaN(characteristics.cardinality))) {
+      characteristics.type = 'cardinality';
+    }
+  }
+
+  return characteristics;
+}
+
+function executeCondition(characteristics, variables, message) {
+  if (characteristics.condition) {
+    return scriptHelper.execute(characteristics.condition, variables, message);
+  }
+
+  return expressions(characteristics.conditionExpression, variables);
+}
+
+function getCardinality(characteristics, variables) {
+  let cardinality;
+  if (characteristics.cardinality > -1) {
+    cardinality = characteristics.cardinality;
+  } else if (characteristics.cardinalityExpression) {
+    cardinality = Number(expressions(characteristics.cardinalityExpression, variables));
+    if (isNaN(cardinality)) throw new Error(`Cardinality expression ${characteristics.cardinalityExpression} returned not a number`);
+  }
+  return cardinality;
+}
+
+module.exports = MultiInstanceLoopCharacteristics;

package/node_modules/@octopus/bpmn/lib/activities/Properties.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const debug = require('debug');
+const expressions = require('../expressions');
+
+function Properties(activity) {
+  this.type = activity.$type;
+  this._debug = debug(`bpmn-engine:properties:${this.type.toLowerCase()}`);
+  this.activity = activity;
+  initProperties.call(this);
+}
+
+Properties.prototype.getValues = function(context) {
+  const result = {};
+
+  this.propertyValues.forEach((prop) => {
+    this._debug('get property value', prop.name);
+    result[prop.name] = expressions.hasExpression(prop.value) ? expressions(prop.value, context) : prop.value;
+  });
+  return result;
+};
+
+function initProperties() {
+  this.propertyValues = this.activity.values.filter((prop) => prop.name);
+}
+
+module.exports = Properties;

package/node_modules/@octopus/bpmn/lib/activities/SequenceFlow.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const expressions = require('../expressions');
+const Flow = require('./Flow');
+const scriptHelper = require('../script-helper');
+
+function SequenceFlow(activity) {
+  this.condition = getCondition.call(this, activity.element);
+  Flow.apply(this, arguments);
+  this.isDefault = this.parentContext.isDefaultSequenceFlow(this.id);
+}
+
+SequenceFlow.prototype = Object.create(Flow.prototype);
+
+SequenceFlow.prototype.executeCondition = function(context) {
+  const result = this.condition.execute(context);
+  this._debug(`<${this.id}>`, `condition result evaluated to ${result}`, context);
+  return result;
+};
+
+SequenceFlow.prototype.evaluateCondition = function(input) {
+  if (this.condition) {
+    const executionContext = this.parentContext.getFrozenVariablesAndServices(Object.assign({id: this.id, flow: this , $attrs: this.activity.element.$attrs}, input || {}));
+    let res = this.executeCondition(executionContext);
+    // console.log("evaluateCondition " + res);
+    return res;
+  }
+  return true;
+};
+
+function getCondition(element) {
+  if (!element.conditionExpression) return null;
+
+  if (!element.conditionExpression.hasOwnProperty('language')) {
+    return new ExpressionCondition(element.conditionExpression.body);
+  }
+
+  if (!scriptHelper.isJavascript(element.conditionExpression.language)) throw Error(`Script format ${element.conditionExpression.language} is unsupported (<${element.id}>)`);
+
+  return new ScriptCondition(scriptHelper.parse(`${element.id}.condition`, element.conditionExpression.body));
+}
+
+function ScriptCondition(script) {
+  this.execute = (executionContext) => {
+    return scriptHelper.execute(script, executionContext);
+  };
+}
+
+function ExpressionCondition(expression) {
+  this.execute = (executionContext) => {
+    let res = expressions(expression, executionContext);
+    return res;
+  };
+}
+
+module.exports = SequenceFlow;

package/node_modules/@octopus/bpmn/lib/activities/ServiceConnector.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const debug = require('debug')('bpmn-engine:service');
+const Parameter = require('../parameter');
+
+function ServiceConnector(connector, parentContext) {
+  this.type = connector.$type || 'string';
+  this.name = connector.connectorId || connector.name;
+  debug(`<${this.name}>`, 'type', this.type);
+  this.connector = connector;
+  this.parentContext = parentContext;
+
+  if (this.connector.inputOutput) {
+    initParameters.call(this, connector);
+  }
+}
+
+ServiceConnector.prototype.execute = function(executeOnBehalfOf, message, callback) {
+  const scope = this;
+  const executeArgs = this.getInputArguments(message);
+
+  function serviceCallback() {
+    const resultArgs = Array.prototype.slice.call(arguments, 0);
+    const err = resultArgs[0];
+
+    const output = scope.getOutput(resultArgs.slice(1));
+
+    debug(`<${scope.name}>`, 'completed');
+
+    return callback.apply(null, [err, output]);
+  }
+
+  executeArgs.push(serviceCallback);
+
+  debug(`<${this.name}>`, 'execute with', executeArgs);
+
+  const serviceFn = scope.parentContext.getServiceByName(this.name);
+
+  return serviceFn.apply(null, executeArgs);
+};
+
+ServiceConnector.prototype.getInputArguments = function(variables) {
+  if (this.input) {
+    return this.input.map((parm) => parm.getInputValue(variables));
+  }
+  return [variables];
+};
+
+ServiceConnector.prototype.getOutput = function(result) {
+  if (!this.output) return result;
+
+  return this.output.reduce((output, parm, idx) => {
+    output[parm.name] = result[idx];
+    return output;
+  }, {});
+};
+
+function initParameters(connector) {
+  if (connector.inputOutput.inputParameters) {
+    this.input = connector.inputOutput.inputParameters.map(formatParameter);
+  }
+  if (connector.inputOutput.outputParameters) {
+    this.output = connector.inputOutput.outputParameters.map(formatParameter);
+  }
+}
+
+function formatParameter(parm) {
+  return Parameter(Object.assign({ positional: true}, parm));
+}
+
+module.exports = ServiceConnector;