octoparse-cli 0.1.14

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

@@ -0,0 +1,202 @@
+'use strict';
+
+const debug = require('debug');
+const EventEmitter = require('events').EventEmitter;
+
+const internals = {};
+
+module.exports = internals.Activity = function(activity, parentContext) {
+  this.parentContext = parentContext;
+  this.id = activity.id;
+  this.type = activity.$type;
+  this.name = activity.name;
+  this._debug = debug(`bpmn-engine:${this.type.toLowerCase()}`);
+  this.activity = activity;
+
+  this.inbound = parentContext.getInboundSequenceFlows(activity.id);
+  this.outbound = parentContext.getOutboundSequenceFlows(activity.id);
+
+  this.io = parentContext.getActivityIO(activity.id);
+
+  this.properties = parentContext.getActivityProperties(activity.id);
+
+  this.multipleInbound = this.inbound.length > 1;
+  this.isStart = this.inbound.length === 0;
+  this.isEnd = this.outbound.length === 0;
+  this.entered = false;
+
+  this._debug(`<${this.id}>`, 'init');
+};
+
+internals.Activity.prototype = Object.create(EventEmitter.prototype);
+
+internals.Activity.prototype.activate = function() {
+  this.setupInboundListeners();
+};
+
+internals.Activity.prototype.deactivate = function() {
+  this.teardownInboundListeners();
+};
+
+internals.Activity.prototype.run = function() {
+  this.canceled = false;
+  this.enter();
+};
+
+internals.Activity.prototype.resume = function(state) {
+  if (state.taken !== undefined) {
+    this.taken = state.taken;
+  }
+  if (state.canceled !== undefined) {
+    this.canceled = state.canceled;
+  }
+  if (!state.entered) return;
+  this._debug(`<${this.id}>`, 'resume');
+  this.run();
+};
+
+internals.Activity.prototype.signal = function() {
+};
+
+internals.Activity.prototype.enter = function(flow) {
+  this._debug(`<${this.id}>`, 'enter');
+  if (this.entered) {
+    throw new Error(`Already entered <${this.id}>`);
+  }
+
+  this.entered = true;
+  this.emit('enter', this, flow);
+};
+
+internals.Activity.prototype.leave = function() {
+  this._debug(`<${this.id}>`, 'leave');
+  if (!this.entered) {
+    throw new Error(`Already left <${this.id}>`);
+  }
+  this.pendingDiscard = false;
+  this.entered = false;
+  setImmediate(() => {
+    this.emit('leave', this);
+  });
+};
+
+internals.Activity.prototype.cancel = function() {
+  this.canceled = true;
+
+  this._debug(`<${this.id}>`, 'cancel');
+  this.emit('cancel', this);
+
+  this.takeAllOutbound();
+};
+
+internals.Activity.prototype.onInbound = function(flow) {
+  if (flow.discarded) {
+    return discardedInbound.apply(this, arguments);
+  }
+  const message = this.getInput();
+  return this.run(message);
+};
+
+internals.Activity.prototype.onLoopedInbound = function() {
+  if (this.entered) this.leave();
+};
+
+internals.Activity.prototype.discard = function(flow, rootFlow) {
+  if (!this.entered) this.enter(flow);
+  return this.discardAllOutbound(rootFlow);
+};
+
+function discardedInbound(flow, rootFlow) {
+  if (!this.multipleInbound) {
+    return this.discard(flow, rootFlow);
+  }
+
+  if (!this.pendingDiscard) {
+    this._debug(`<${this.id}>`, `pending inbound from discarded <${flow.id}>`);
+    this.pendingDiscard = true;
+
+    // Remove one since one inbound flow must have been taken
+    this.pendingLength = this.inbound.length - 1;
+
+    // Emit leave because we are not waiting for discarded flow
+    this.emit('leave', this);
+
+    return;
+  }
+
+
+  this.pendingLength--;
+  this._debug(`<${this.id}>`, `inbound from discarded <${flow.id}> - pending ${this.pendingLength}`);
+  if (this.pendingLength === 0) {
+    this.discard(flow, rootFlow);
+  }
+}
+
+internals.Activity.prototype.takeAllOutbound = function(message) {
+  if (!this.isEnd) {
+    this._debug(`<${this.id}>`, `take all outbound (${this.outbound.length})`);
+    this.outbound.forEach((flow) => flow.take(message));
+  }
+  this.leave();
+};
+
+internals.Activity.prototype.discardAllOutbound = function(rootFlow) {
+  if (!this.isEnd) {
+    this._debug(`<${this.id}>`, `discard all outbound (${this.outbound.length})`);
+    this.outbound.forEach((flow) => {
+      flow.discard(rootFlow);
+    });
+  }
+  this.leave(rootFlow);
+};
+
+internals.Activity.prototype.setupInboundListeners = function() {
+  if (!this.inbound.length) return;
+  if (this._onInbound) return;
+  this._onInbound = this.onInbound.bind(this);
+  this._onLoopedInbound = this.onLoopedInbound.bind(this);
+
+  this.inbound.forEach((flow) => {
+    flow.on('taken', this._onInbound);
+    flow.on('discarded', this._onInbound);
+    flow.on('looped', this._onLoopedInbound);
+  });
+};
+
+internals.Activity.prototype.teardownInboundListeners = function() {
+  if (!this._onInbound) return;
+  this.inbound.forEach((flow) => {
+    flow.removeListener('taken', this._onInbound);
+    flow.removeListener('discarded', this._onInbound);
+    flow.removeListener('looped', this._onLoopedInbound);
+  });
+
+  delete this._onInbound;
+};
+
+internals.Activity.prototype.getOutput = function(message) {
+  if (!this.io) return message;
+  return this.io.getOutput(message);
+};
+
+internals.Activity.prototype.getInput = function(message) {
+  if (!this.io) return message;
+  return this.io.getInput(message);
+};
+
+internals.Activity.prototype.getState = function() {
+  const result = {
+    id: this.id,
+    type: this.type,
+    entered: this.entered
+  };
+
+  if (this.taken !== undefined) {
+    result.taken = this.taken;
+  }
+  if (this.canceled !== undefined) {
+    result.canceled = this.canceled;
+  }
+
+  return result;
+};

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

@@ -0,0 +1,308 @@
+'use strict';
+
+const Context = require('../Context');
+const BaseTask = require('./BaseTask');
+
+function BaseProcess(activity, moddleOrParentContext, options) {
+  this.isMainProcess = !isSubProcess(moddleOrParentContext);
+  this.context = new Context(activity.id, (this.isMainProcess ? moddleOrParentContext : moddleOrParentContext.moddleContext), options);
+  this.listener = options.listener;
+  this.pendingActivities = [];
+
+  BaseTask.call(this, activity, (this.isMainProcess ? this.context : moddleOrParentContext), options);
+
+  this._debug(`<${activity.id}>`, 'init', !this.isMainProcess ? 'sub process' : 'main process');
+}
+
+BaseProcess.prototype = Object.create(BaseTask.prototype);
+
+BaseProcess.prototype.execute = function(message) {
+  this._debug(`<${this.id}>`, 'execute');
+  this.isEnded = false;
+
+  this.context.applyMessage(message);
+
+  activateAllChildren.call(this);
+
+  this.pendingActivities = this.context.startActivities.map(c => {
+    return {
+      type: c.type,
+      id: c.id
+    };
+  });
+
+  this.emit('start', this);
+  if (this.isMainProcess) {
+    emitListenerEvent.call(this, 'start', this);
+  }
+
+  if(this.type == 'bpmn:SubProcess'){ 
+    this.waiting = true;
+    this.emit('wait', this); 
+  }else{ 
+    if (this.context.childCount === 0) {
+      return this.completeProcess(this.context.variables);
+    }
+
+    this.context.startActivities.forEach((activity) =>activity.run());
+  }
+};
+
+BaseProcess.prototype.completeProcess = function() {
+  this._debug(`<${this.id}>`, 'complete');
+  deactivateAllChildren.call(this);
+
+  this.variables = this.context.variables;
+  this.isEnded = true;
+
+  this.complete.call(this, this.variables);
+};
+
+BaseProcess.prototype.cancel = function() {
+  deactivateAllChildren.call(this);
+  BaseTask.prototype.cancel.apply(this, arguments);
+};
+
+BaseProcess.prototype.signal = function(childId, input) {
+  this._debug(`<${this.id}>`, `signal <${childId}>`);
+
+  if(this.waiting){
+    this.waiting = false;
+    if (this.context.childCount === 0) {
+      return this.completeProcess(this.context.variables);
+    }
+    this.context.startActivities.forEach((activity) =>
+      activity.run()
+    );
+  } else {
+    const child = this.getChildActivityById(childId);
+    if (child.isStartEvent) {
+      this.context.applyMessage(input);
+      return this.run();
+    }
+
+    if (child.isStart && !this.entered) {
+      this.run();
+    }
+
+    child.signal(input);
+  }
+};
+
+BaseProcess.prototype.getChildActivityById = function(childId) {
+  return this.context.getChildActivityById(childId);
+};
+
+BaseProcess.prototype.onChildEnter = async function(activity) {
+  this._debug(`<${this.id}>`, `enter <${activity.id}> (${activity.type})`);
+
+  this.pendingActivities.push({
+    id: activity.id
+  });
+
+  await emitListenerEvent.call(this, 'enter', activity);
+};
+
+BaseProcess.prototype.onChildStart = function(activity) {
+  emitListenerEvent.call(this, 'start', activity);
+};
+
+BaseProcess.prototype.onChildCancel = function(activity) {
+  emitListenerEvent.call(this, 'cancel', activity);
+};
+
+BaseProcess.prototype.onChildWait = function(activity) {
+  this._debug(`<${this.id}>`, `wait for <${activity.id}> (${activity.type})`);
+  emitListenerEvent.call(this, 'wait', activity);
+};
+
+BaseProcess.prototype.onChildEnd = function(activity, output) {
+  if (output) {
+    if ((activity.io && activity.io.hasOutput) || activity.saveToVariables) {
+      this._debug(`<${this.id}>`, `saving data from <${activity.id}> to variables`);
+      this.context.applyMessage(output);
+    } else {
+      this.context.saveChildOutput(activity.id, output);
+    }
+  }
+
+  emitListenerEvent.call(this, 'end', activity, output);
+
+  if (activity.terminate) {
+    this.completeProcess();
+  }
+};
+
+BaseProcess.prototype.onChildLeave = function(activity) {
+  this.pendingActivities = this.pendingActivities.filter((c) => c.id !== activity.id);
+
+  this._debug(`<${this.id}>`, `left <${activity.id}> (${activity.type}), pending activities ${this.pendingActivities.length}`);
+  emitListenerEvent.call(this, 'leave', activity);
+
+  if (this.pendingActivities.length === 0) {
+    this.completeProcess();
+  }
+};
+
+BaseProcess.prototype.onChildError = function(err, child) {
+  deactivateAllChildren.call(this);
+  this.emit('error', err, child, this);
+};
+
+BaseProcess.prototype.onMessage = function(message, via) {
+  this._debug(`<${this.id}>`, `message sent via <${via.id}> (${via.type})`);
+  this.emit('message', this, message, via);
+};
+
+BaseProcess.prototype.onFlowDiscarded = function(flow) {
+  emitListenerEvent.call(this, 'discarded', flow);
+};
+
+BaseProcess.prototype.onFlowTaken = function(flow) {
+  emitListenerEvent.call(this, 'taken', flow);
+};
+
+BaseProcess.prototype.getState = function() {
+  const state = BaseTask.prototype.getState.call(this);
+  Object.assign(state, this.context.getState());
+  return state;
+};
+
+BaseProcess.prototype.getPendingActivities = function() {
+  return this.context.getPendingActivities();
+};
+
+BaseProcess.prototype.resume = function(state) {
+  this._debug(`<${this.id}>`, 'resume', state.entered ? 'execution' : 'state');
+  this.context.resume(state);
+  this.entered = state.entered;
+
+  if (this.entered) {
+    activateAllChildren.call(this);
+    this.emit('enter', this);
+  }
+
+  const resumeStates = state.children.reduce((result, childState) => {
+    if (childState.entered && childState.pendingJoin) {
+      // Pending joins
+      result.pre.push(childState);
+    } else if (childState.attachedToId) {
+      // Boundary events
+      result.pre.push(childState);
+    } else {
+      result.post.push(childState);
+    }
+
+    return result;
+  }, {
+    pre: [],
+    post: []
+  });
+
+  resumeStates.pre.forEach((childState) => {
+    this.getChildActivityById(childState.id).resume(childState);
+  });
+  resumeStates.post.forEach((childState) => {
+    this.getChildActivityById(childState.id).resume(childState);
+  });
+};
+
+BaseProcess.prototype.deactivate = function() {
+  deactivateAllChildren.call(this);
+  BaseTask.prototype.deactivate.apply(this, arguments);
+};
+
+function isSubProcess(context) {
+  return context instanceof Context;
+}
+
+function activateAllChildren() {
+  const scope = this;
+
+  scope._onChildEnter = scope.onChildEnter.bind(scope);
+  scope._onChildStart = scope.onChildStart.bind(scope);
+  scope._onChildWait = scope.onChildWait.bind(scope);
+  scope._onChildEnd = scope.onChildEnd.bind(scope);
+  scope._onChildCancel = scope.onChildCancel.bind(scope);
+  scope._onChildLeave = scope.onChildLeave.bind(scope);
+  scope._onChildError = scope.onChildError.bind(scope);
+  scope._onMessage = scope.onMessage.bind(scope);
+  scope._onFlowDiscarded = scope.onFlowDiscarded.bind(scope);
+  scope._onFlowTaken = scope.onFlowTaken.bind(scope);
+
+  Object.keys(scope.context.children).forEach((id) => {
+    const activity = scope.context.children[id];
+    setupChildActivity.call(scope, activity);
+    activity.activate();
+  });
+
+  scope.context.messageFlows.forEach((flow) => {
+    flow.on('message', this._onMessage);
+  });
+
+  scope.context.sequenceFlows.forEach((flow) => {
+    setupFlowActivity.call(scope, flow);
+  });
+}
+
+function deactivateAllChildren() {
+  if (!this.entered) return;
+
+  Object.keys(this.context.children).forEach((id) => {
+    const child = this.context.children[id];
+    teardownChildActivity.call(this, child);
+    child.deactivate();
+  });
+
+  this.context.sequenceFlows.forEach((flow) => {
+    teardownFlowActivity.call(this, flow);
+  });
+}
+
+function setupChildActivity(activity) {
+  const self = this;
+  this._debug(`<${self.id}>`, `setup <${activity.id}>`);
+
+  activity.on('enter', this._onChildEnter);
+  activity.on('start', this._onChildStart);
+  activity.on('wait', this._onChildWait);
+  activity.on('cancel', this._onChildCancel);
+  activity.on('end', this._onChildEnd);
+  activity.on('leave', this._onChildLeave);
+
+  if (!this.context.hasAttachedErrorEvent(activity.id)) {
+    activity.on('error', this._onChildError);
+  }
+}
+
+function teardownChildActivity(activity) {
+  this._debug(`<${this.id}>`, `tear down <${activity.id}>`);
+
+  activity.removeListener('enter', this._onChildEnter);
+  activity.removeListener('start', this._onChildStart);
+  activity.removeListener('wait', this._onChildWait);
+  activity.removeListener('cancel', this._onChildCancel);
+  activity.removeListener('end', this._onChildEnd);
+  activity.removeListener('leave', this._onChildLeave);
+  activity.removeListener('error', this._onChildError);
+}
+
+function setupFlowActivity(flow) {
+  flow.on('taken', this._onFlowTaken);
+  flow.on('discarded', this._onFlowDiscarded);
+}
+
+function teardownFlowActivity(flow) {
+  flow.removeListener('taken', this._onFlowTaken);
+  flow.removeListener('discarded', this._onFlowDiscarded);
+  flow.removeListener('message', this._onMessage);
+}
+
+function emitListenerEvent(eventName, activity, parent) {
+  if (!this.listener) return;
+  if (!parent) parent = this;
+  this.listener.emit(`${eventName}-${activity.id}`, activity, parent);
+  this.listener.emit(eventName, activity, parent);
+}
+
+module.exports = BaseProcess;

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

@@ -0,0 +1,145 @@
+'use strict';
+
+const Activity = require('./Activity');
+const async = require('async');
+const PrematureStopError = require('../PrematureStopError');
+
+function BaseTask() {
+  Activity.apply(this, arguments);
+  this.loop = this.parentContext.getLoopCharacteristics(this.activity.loopCharacteristics);
+}
+
+BaseTask.prototype = Object.create(Activity.prototype);
+
+BaseTask.prototype.run = function(message) {
+  Activity.prototype.run.apply(this, arguments);
+
+  this.inboundMessage = message;
+
+  if (this.loop) {
+    this.loop.completed = false;
+    this.loop.stop = false;
+    return this.runLoop(message, (err, output) => { // eslint-disable-line handle-callback-err
+      this.complete = BaseTask.prototype.complete.bind(this);
+      if (!(err instanceof PrematureStopError)) {
+        this.loop.reset();
+      } else {
+        this._debug(`<${this.id}>`, 'prematurely stopped');
+      }
+
+      this.complete(output);
+    });
+  }
+
+  this._debug(`<${this.id}>`, 'run');
+  this.execute(message);
+};
+
+BaseTask.prototype.execute = function() {
+};
+
+BaseTask.prototype.runLoop = function(message, callback) {
+  return sequentialLoop.call(this, message, callback);
+};
+
+BaseTask.prototype.complete = function(loopCallbackOrOutput, output) {
+  if (typeof loopCallbackOrOutput !== 'function') {
+    output = loopCallbackOrOutput;
+    loopCallbackOrOutput = null;
+  }
+  const ioOutput = this.getOutput(output);
+
+  this.emit('end', this, ioOutput);
+
+  if (this.loop && !this.loop.completed) {
+      return loopCallbackOrOutput(null, ioOutput);
+  }
+
+  this.takeAllOutbound(ioOutput);
+};
+
+BaseTask.prototype.deactivate = function() {
+  Activity.prototype.deactivate.apply(this, arguments);
+  if (this.loop) {
+    this.loop.deactivate();
+  }
+};
+
+BaseTask.prototype.getState = function() {
+  const state = Activity.prototype.getState.apply(this, arguments);
+  if (this.loop) state.loop = this.loop.getState();
+  return state;
+};
+
+BaseTask.prototype.resume = function(state) {
+  if (this.loop) {
+    this.loop.resume(state.loop);
+  }
+
+  Activity.prototype.resume.apply(this, arguments);
+};
+
+function sequentialLoop() {
+  if (this.loop.characteristics.type === 'collection') {
+    sequentialCollectionLoop.apply(this, arguments);
+  } else {
+    sequentialConditionLoop.apply(this, arguments);
+  }
+}
+
+function sequentialConditionLoop(message, callback) {
+  const scope = this;
+  const loopDef = scope.loop;
+  const executionContext = scope.parentContext.getFrozenVariablesAndServices(Object.assign({id: this.id, process: this}, {}));
+
+  const testFn = loopDef.run.bind(loopDef, executionContext, scope.inboundMessage);
+
+  function executeFn(next) {
+    scope._debug(`<${scope.id}>`, `iteration ${loopDef.iteration} in sequential loop`);
+
+    const messageScope = Object.assign({}, message);
+    messageScope.loop = true;
+    messageScope.index = loopDef.iteration;
+
+    scope.complete = BaseTask.prototype.complete.bind(scope, next);
+
+    scope.execute(messageScope);
+  }
+
+  async.doUntil(executeFn, testFn, callback);
+}
+
+function sequentialCollectionLoop(message, callback) {
+  const scope = this;
+
+  const loopDef = scope.loop;
+  const collection = loopDef.getCollection();
+  const executionContext = scope.parentContext.getVariablesAndServices();
+
+  function executeFn(item, next) {
+    scope._debug(`<${scope.id}>`, `iteration ${loopDef.iteration} in sequential collection loop`);
+
+    const messageScope = Object.assign({}, message);
+    messageScope.loop = true;
+    messageScope.index = loopDef.iteration;
+    messageScope.item = item;
+
+    scope.complete = BaseTask.prototype.complete.bind(scope, getLoopCallback(loopDef, executionContext, scope.inboundMessage, next));
+
+    scope.execute(messageScope);
+  }
+
+  async.eachSeries(collection, executeFn, callback);
+}
+
+function getLoopCallback(loopDef, executionContext, inboundMessage, callback) {
+  return (err, result) => {
+    if (err) return callback(err, result);
+
+    loopDef.run(executionContext, inboundMessage, result, (loopErr) => {
+      callback(loopErr, result);
+    });
+  };
+}
+
+module.exports = BaseTask;

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

@@ -0,0 +1,12 @@
+'use strict';
+
+const mapper = require('../mapper');
+
+function BoundaryEvent(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 = BoundaryEvent;

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

@@ -0,0 +1,10 @@
+'use strict';
+
+function Dummy(activity) {
+  this.id = activity.id;
+  this.type = activity.$type;
+  this.activity = activity;
+  this.placeholder = true;
+}
+
+module.exports = Dummy;