process_engine 0.0.1

data/app/models/process_engine/parser/extension/transitional_parameter.rb

@@ -0,0 +1,53 @@
+class ProcessEngine::Parser::Extension::TransitionalParameter
+  attr_reader  :element, :name
+
+  def initialize(element)
+    @element = element
+    @name = element["name"]
+  end
+
+  def list
+    l = element.xpath("camunda:list//camunda:value").map(&:content)
+    l.present? ? l : nil
+  end
+
+  def map
+    h = element.xpath("camunda:map//camunda:entry").each_with_object({}) do |item, hash|
+      hash[item["key"]] = item.content
+    end
+
+    h.present? ? h : nil
+  end
+
+  def string
+    element.elements.count == 0 ? element.content : nil
+  end
+
+  def script
+    sct = element.at_xpath("camunda:script")
+    return nil unless sct
+    obj = (Struct.new(:script_format, :script_content)).new
+    obj.script_format = sct["scriptFormat"]
+    obj.script_content = sct.content
+    obj
+  end
+
+  def type
+    %w(list string map script).find {|item| send(item).present? }
+  end
+
+  def value
+    send(type)
+  end
+
+  def to_h
+    {
+      type: type,
+      value: value
+    }
+  end
+
+  def self.factory(element, direction)
+    element.xpath("camunda:#{direction}").map { |el| new(el) }
+  end
+end

data/app/models/process_engine/parser/inclusive_gateway.rb

@@ -0,0 +1,25 @@
+class ProcessEngine::Parser::InclusiveGateway < ProcessEngine::Parser::XmlNode
+  def initialize(element)
+    super(element)
+  end
+
+  def default_flow
+    element["default"]
+  end
+
+  def extension_elements
+    # support [executionListener], [property]
+    custom_extension_elements(:execution_listeners, :properties)
+  end
+
+  def to_h
+    custom_ext = custom_extension_elements_hash(:execution_listeners, :properties)
+
+    super.merge({
+      extension: {
+        common: custom_ext,
+        default_flow: default_flow
+      }
+    })
+  end
+end

data/app/models/process_engine/parser/parallel_gateway.rb

@@ -0,0 +1,19 @@
+class ProcessEngine::Parser::ParallelGateway < ProcessEngine::Parser::XmlNode
+  def initialize(element)
+    super(element)
+  end
+
+  def extension_elements
+    # support [executionListener], [property]
+    custom_extension_elements(:execution_listeners, :properties)
+  end
+
+  def to_h
+    custom_ext = custom_extension_elements_hash(:execution_listeners, :properties)
+    super.merge({
+      extension: {
+        common: custom_ext
+      }
+    })
+  end
+end

data/app/models/process_engine/parser/script_task.rb

@@ -0,0 +1,37 @@
+class ProcessEngine::Parser::ScriptTask < ProcessEngine::Parser::XmlNode
+  def initialize(element)
+    super(element)
+  end
+
+  def script_format
+    element["scriptFormat"]
+  end
+
+  def resource
+    element["camunda:resource"]
+  end
+
+  def script
+    element.at_xpath("bpmn2:script").try(:content)
+  end
+
+  def extension_elements
+    # support [executionListener], [property], inputs_outputs
+    custom_extension_elements(:execution_listeners, :properties, :inputs_outputs)
+  end
+
+  def to_h
+    custom_ext = custom_extension_elements_hash(:execution_listeners, :properties, :inputs_outputs)
+
+    super.merge({
+      extension: {
+        common: custom_ext,
+        script_format: script_format,
+        resource: resource,
+        script: script
+      }
+    })
+  end
+
+
+end

data/app/models/process_engine/parser/sequence_flow.rb

@@ -0,0 +1,36 @@
+class ProcessEngine::Parser::SequenceFlow < ProcessEngine::Parser::XmlNode
+  def initialize(element)
+    super(element)
+  end
+
+  def source_ref
+    element["sourceRef"]
+  end
+
+  def target_ref
+    element["targetRef"]
+  end
+
+  def condition_expression
+    ProcessEngine::Parser::Extension::ConditionExpression.factory(element)
+  end
+
+  def extension_elements
+    # support [executionListener], [property]
+    custom_extension_elements(:execution_listeners, :properties)
+  end
+
+  def to_h
+    custom_ext = custom_extension_elements_hash(:execution_listeners, :properties)
+
+    super.merge({
+      extension: {
+        common: custom_ext,
+        condition_expression: condition_expression.to_h
+      },
+      source_ref: source_ref,
+      target_ref: target_ref,
+    })
+  end
+
+end

data/app/models/process_engine/parser/start_event.rb

@@ -0,0 +1,27 @@
+class ProcessEngine::Parser::StartEvent < ProcessEngine::Parser::XmlNode
+  def initialize(element)
+    super(element)
+  end
+
+  def initiator
+    element["camunda:initiator"]
+  end
+
+  def extension_elements
+    # support [executionListener], [formField], [property]
+    custom_extension_elements(:execution_listeners, :form_fields, :properties)
+  end
+
+  def to_h
+    custom_ext = custom_extension_elements_hash(:execution_listeners, :form_fields, :properties)
+
+    super.merge({
+      extension: {
+        common: custom_ext,
+        initiator: initiator
+      }
+    })
+  end
+
+
+end

data/app/models/process_engine/parser/user_task.rb

@@ -0,0 +1,36 @@
+class ProcessEngine::Parser::UserTask < ProcessEngine::Parser::XmlNode
+  def initialize(element)
+    super(element)
+  end
+
+  def extension_elements
+    # support [executionListener], [taskListener], [formField], [property], inputs_outputs
+    custom_extension_elements(:execution_listeners, :task_listeners, :form_fields, :properties, :inputs_outputs)
+  end
+
+  def assignee
+    element["camunda:assignee"]
+  end
+
+  def candidate_users
+    (element["camunda:candidateUsers"].try(:split, ",") || []).map(&:strip).select(&:present?)
+  end
+
+  def candidate_groups
+    (element["camunda:candidateGroups"].try(:split, ",") || []).map(&:strip).select(&:present?)
+  end
+
+  def to_h
+    custom_ext = custom_extension_elements_hash(:execution_listeners, :task_listeners, :form_fields, :properties, :inputs_outputs)
+
+    super.merge({
+      extension: {
+        common: custom_ext,
+        assignee: assignee,
+        candidate_users: candidate_users,
+        candidate_groups: candidate_groups
+      }
+    })
+  end
+
+end

data/app/models/process_engine/parser/xml_node.rb

@@ -0,0 +1,125 @@
+class ProcessEngine::Parser::XmlNode
+  TYPES_GATEWAY = %w(exclusiveGateway parallelGateway inclusiveGateway complexGateway)
+  TYPES_EVENT = %w(startEvent endEvent)
+  TYPES_TASK = %w(scriptTask userTask)
+  TYPES_FLOW = %w(sequenceFlow)
+
+  attr_reader :id, :name, :node_type, :element
+
+  def initialize(element)
+    @id = element["id"]
+    @name = element["name"]
+    @node_type = element.name
+    @element = element
+  end
+
+  def incoming_strings
+    element.xpath("bpmn2:incoming").map(&:content)
+  end
+
+  def outgoing_strings
+    element.xpath("bpmn2:outgoing").map(&:content)
+  end
+
+  def extension_elements
+    raise "Not imlpmented"
+  end
+
+  def documentation
+    element.at_xpath("bpmn2:documentation").try(:content)
+  end
+
+  def type_gateway?
+    TYPES_GATEWAY.include?(node_type)
+  end
+
+  def type_event?
+    TYPES_EVENT.include?(node_type)
+  end
+
+  def type_task?
+    TYPES_TASK.include?(node_type)
+  end
+
+  def type_flow?
+    TYPES_FLOW.include?(node_type)
+  end
+
+  def to_h
+    {
+      node_id: id,
+      node_type: node_type,
+      name: name
+    }
+  end
+
+  class << self
+    def factory(element)
+      case element.name
+      when "startEvent"
+        ProcessEngine::Parser::StartEvent.new(element)
+      when "endEvent"
+        ProcessEngine::Parser::EndEvent.new(element)
+      when "userTask"
+        ProcessEngine::Parser::UserTask.new(element)
+      when "scriptTask"
+        ProcessEngine::Parser::ScriptTask.new(element)
+      when "parallelGateway"
+        ProcessEngine::Parser::ParallelGateway.new(element)
+      when "exclusiveGateway"
+        ProcessEngine::Parser::ExclusiveGateway.new(element)
+      when "complexGateway"
+        ProcessEngine::Parser::ComplexGateway.new(element)
+      when "inclusiveGateway"
+        ProcessEngine::Parser::InclusiveGateway.new(element)
+      when "sequenceFlow"
+        ProcessEngine::Parser::SequenceFlow.new(element)
+      else
+        nil
+      end
+    end
+  end
+
+  private
+
+  def custom_extension_elements(*extension_props)
+    ext = element.at_xpath("bpmn2:extensionElements")
+    return nil unless ext
+
+    extension = ProcessEngine::Parser::Extension
+
+    parser = {
+      execution_listeners: ProcessEngine::Parser::Extension::ExecutionListener,
+      task_listeners: ProcessEngine::Parser::Extension::TaskListener,
+      form_fields: ProcessEngine::Parser::Extension::FormField,
+      properties: ProcessEngine::Parser::Extension::Property,
+      inputs_outputs: ProcessEngine::Parser::Extension::InputOutput
+    }
+
+    intersect = extension_props & parser.keys
+    obj = (Struct.new *intersect).new
+    intersect.each do |prop|
+      obj[prop] = parser[prop].factory(ext)
+    end
+
+    obj
+  end
+
+  def custom_extension_elements_hash(*extension_props)
+
+    ee = extension_elements
+    return {} unless ee
+
+    available_hash = {
+      execution_listeners: ee.try(:execution_listeners).try(:map){ |item| item.to_h },
+      task_listeners: ee.try(:task_listeners).try(:map){ |item| item.to_h },
+      form_fields: ee.try(:form_fields).try(:map){ |item| item.to_h },
+      properties: ee.try(:properties).try(:map){ |item| item.to_h },
+      inputs_outputs: ee.try(:inputs_outputs).try(:to_h)
+    }
+
+    intersect = extension_props & available_hash.keys
+    available_hash.slice(*intersect)
+  end
+
+end

data/app/models/process_engine/process_definition.rb

@@ -0,0 +1,50 @@
+module ProcessEngine
+  class ProcessDefinition < ActiveRecord::Base
+    has_many :process_instances, dependent: :destroy
+    validates :name, presence: true
+    validates :slug, presence: true, uniqueness: true
+
+    scope :desc, -> { order('id desc') }
+    scope :asc, -> { order('id asc') }
+
+    before_save :update_json_from_xml
+    before_save :update_starting_node
+    validate :check_xml_format
+
+
+    def schema
+      ProcessEngine::ProcessSchema.new(self)
+    end
+
+    private
+
+    def update_json_from_xml
+      return unless bpmn_xml_changed?
+      doc  = Nokogiri::XML(bpmn_xml)
+      process = doc.at_xpath('//bpmn2:process') rescue nil
+
+      return unless process.present?
+      elements = process.elements.map{ |el| ProcessEngine::Parser::XmlNode.factory(el) }.compact
+
+      graph = elements.each_with_object({nodes: [], transitions: []}) do |el, hash|
+        unless el.type_flow?
+          hash[:nodes] << el.to_h
+        else
+          hash[:transitions] << el.to_h
+        end
+      end
+
+      self.bpmn_json = graph
+    end
+
+    def update_starting_node
+      starter_node = schema.nodes_by_type(ProcessEngine::Schema::Node::NodeType::START_EVENT).first
+      self.starting_node = starter_node.node_id if starter_node
+    end
+
+    def check_xml_format
+      doc = Nokogiri.XML(bpmn_xml)
+      errors.add(:bpmn_xml, 'is invalid') if bpmn_xml.present? && (doc.errors.count > 0 || (doc.at_xpath('//bpmn2:process') rescue nil).nil?)
+    end
+  end
+end

data/app/models/process_engine/process_instance.rb

@@ -0,0 +1,72 @@
+module ProcessEngine
+  class ProcessInstance < ActiveRecord::Base
+    enum status: { movable: 0, waiting: 1, finished: 2 } # check if required to check for branching
+
+    belongs_to :process_definition
+    has_many :process_tasks, dependent: :destroy
+
+    scope :desc, -> { order('id desc') }
+    scope :asc, -> { order('id asc') }
+
+    def move_to_next_state(pdn_slug_state, options = {})
+      move_to_next_cur_state(pdn_slug_state, [], options)
+    end
+
+    def start
+      update_attributes!(states: [process_definition.starting_node])
+      begin_process_instance
+      self
+    end
+
+    def process_tasks_by_state_name(state_name)
+      process_tasks.by_state(state_name).desc
+    end
+
+    def last_process_task_by_state_name(state_name)
+      process_tasks_by_state_name(state_name).first
+    end
+
+    private
+
+    def begin_process_instance
+      ProcessEngine::ProcessTask.spawn_new_task(self, states.first, { assignee: creator })
+    end
+
+    def move_to_next_cur_state(cur_state, previous_states = [], options = {})
+      current_node = process_definition.schema.node(cur_state)
+      schedulable_nodes = current_node.next_schedulable_nodes(options)
+
+      if schedulable_nodes.count == 0
+        update!(status: :finished, states: [cur_state]) # finish life cycle
+      else
+        schedulable_nodes.each do |sn|
+          execute_single_next_movable_nodes(cur_state, previous_states, sn)
+        end
+      end
+    end
+
+    def execute_single_next_movable_nodes(cur_state, previous_states, node)
+      new_state = node.node_id
+
+      injected_data = ProcessEngine::NodeDataInjection.node_options_data(process_definition.slug, new_state, self)
+
+      # check if node can be computed (e.g. script task, or branching node)
+      if ProcessEngine::Schema::Node::COMPUTED_NODE_TYPES.include?(node.node_type)
+        move_to_next_cur_state(new_state, previous_states + [cur_state], injected_data)
+
+      elsif node.node_type == ProcessEngine::Schema::Node::NodeType::COMPLEX_GATEWAY
+
+        unless states.include?(new_state)
+          update!(states: (states | [new_state]) - ([cur_state] | previous_states))
+        else
+          # one state has already been reached, and we just need to move forward
+          move_to_next_cur_state(new_state, previous_states + [cur_state], injected_data)
+        end
+      else
+        # this node requires action from user
+        ProcessEngine::ProcessTask.spawn_new_task(self, new_state, injected_data)
+        update!(states: (states | [new_state]) - ([cur_state] | previous_states))
+      end
+    end
+  end
+end

data/app/models/process_engine/process_query.rb

@@ -0,0 +1,52 @@
+class ProcessEngine::ProcessQuery
+  class << self
+
+    # available options: :finisher, :verified_state, :data
+    def task_complete(task_id, options = {})
+      task = ProcessEngine::ProcessTask.find(task_id)
+      raise ProcessEngine::Error::FalseTaskState if options[:verified_state] && (task.state != options[:verified_state])
+
+      task.complete(options)
+    end
+
+    def task_get_all(options = {})
+      taks = ProcessEngine::ProcessTask.all
+
+      taks = taks.by_assignee(options[:assignee]) if options[:assignee]
+
+      taks = taks.by_candidate_user(options[:candidate_user]) if options[:candidate_user]
+      taks = taks.by_all_candidate_users(options[:all_candidate_users]) if options[:all_candidate_users]
+      taks = taks.by_any_candidate_users(options[:any_candidate_users]) if options[:any_candidate_users]
+
+      taks = taks.by_candidate_group(options[:candidate_group]) if options[:candidate_group]
+      taks = taks.by_all_candidate_groups(options[:all_candidate_groups]) if options[:all_candidate_groups]
+      taks = taks.by_any_candidate_groups(options[:any_candidate_groups]) if options[:any_candidate_groups]
+
+      taks = taks.by_user(options[:user]) if options[:user]
+      # e.g. options[:user_or_groups] = ["assignee123", ['cg1']]
+      taks = taks.by_user_or_groups(*options[:user_or_groups]) if options[:user_or_groups]
+
+      taks = taks.by_status(options[:status]) if options[:status]
+      taks
+    end
+
+    def task_accessible?(task_id, user, groups = [])
+      options = {
+        user_or_groups: [user, groups]
+      }
+
+      task_get_all(options).where(id: task_id).count > 0
+    end
+
+    def process_instance_start(process_defintion_slug, creator)
+      pd = ProcessEngine::ProcessDefinition.find_by(slug: process_defintion_slug)
+      pi = pd.process_instances.create(creator: creator)
+      pi.start
+    end
+
+    def process_definition_get_all()
+      ProcessEngine::ProcessDefinition.all
+    end
+
+  end
+end

data/app/models/process_engine/process_schema.rb

@@ -0,0 +1,30 @@
+class ProcessEngine::ProcessSchema
+  attr_reader :nodes
+
+  def initialize(process_definition)
+    nodes_hash = process_definition.bpmn_json.fetch("nodes", [])
+    @transitions_hash = process_definition.bpmn_json.fetch("transitions", [])
+    initialize_graph(nodes_hash, @transitions_hash)
+  end
+
+  def node(node_id)
+    nodes.find { |n| n.node_id == node_id }
+  end
+
+  def nodes_by_type(node_type)
+    nodes.select{ |node| node.node_type == node_type }
+  end
+
+  private
+
+  def initialize_graph(nodes_hash, transitions_hash)
+    @nodes = nodes_hash.map{ |node| ProcessEngine::Schema::Node.new(ActiveSupport::HashWithIndifferentAccess.new(node)) }
+    transitions_hash.each do |tn|
+      source = node(tn["source_ref"]) || (fail "Can't find node #{tn["source_ref"]} in source_ref")
+      target = node(tn["target_ref"]) || (fail "Can't find node #{tn["target_ref"]} in target_ref")
+      source.transitions << ProcessEngine::Schema::Transition.new(ActiveSupport::HashWithIndifferentAccess.new(tn), source, target)
+    end
+  end
+
+
+end

data/app/models/process_engine/process_task.rb

@@ -0,0 +1,70 @@
+module ProcessEngine
+  class ProcessTask < ActiveRecord::Base
+    enum status: { pending: 0, finished: 1 }
+
+    belongs_to :process_definition_node
+    belongs_to :process_instance
+
+    # list of operators http://www.postgresql.org/docs/9.4/static/functions-array.html
+    scope :by_assignee, -> (assignee) { where(assignee: assignee) }
+    scope :by_candidate_user, -> (candidate_user) { where("? = ANY(candidate_users)", candidate_user) }
+    scope :by_all_candidate_users, -> (candidate_users) { where("candidate_users @> ARRAY[?]::varchar[]", candidate_users) }
+    scope :by_any_candidate_users, -> (candidate_users) { where("candidate_users && ARRAY[?]::varchar[]", candidate_users) }
+
+    scope :by_candidate_group, -> (candidate_group) { where("? = ANY(candidate_groups)", candidate_group) }
+    scope :by_all_candidate_groups, -> (candidate_groups) { where("candidate_groups @> ARRAY[?]::varchar[]", candidate_groups) }
+    scope :by_any_candidate_groups, -> (candidate_groups) { where("candidate_groups && ARRAY[?]::varchar[]", candidate_groups) }
+
+    scope :by_user, -> (user) { where("assignee = ? OR ? = ANY(candidate_users)", user, user) }
+    scope :by_user_or_groups, -> (user, groups) { where("assignee = ? OR ? = ANY(candidate_users) OR candidate_groups && ARRAY[?]::varchar[]", user, user, groups) }
+
+    scope :by_status, -> (status) { where(status: status) }
+    scope :by_state, -> (state) { where(state: state) }
+
+    scope :desc, -> { order('id desc') }
+    scope :asc, -> { order('id asc') }
+
+
+    # available options :finisher, :data
+    def complete(options)
+      injected_data = ProcessEngine::NodeDataInjection.node_options_data(process_instance.process_definition.slug, state, self)
+      process_instance.move_to_next_state(state, injected_data)
+
+      opt = { finisher: options[:finisher], status: :finished }
+      opt[:data] = options[:data] if options[:data].present?
+
+      update!(opt)
+
+      # enable service hooks
+      node_ext = process_instance.process_definition.schema.node(state).node_extension
+      ProcessEngine::Listener::Base.execute(process_instance, node_ext.common_execution_listeners, 'end')
+      ProcessEngine::Listener::Base.execute(process_instance, node_ext.common_task_listeners, 'complete')
+    end
+
+    def self.spawn_new_task(pi, state, injected_data)
+      injected_data ||= {}
+      injected_data = ActiveSupport::HashWithIndifferentAccess.new(injected_data)
+
+      node_ext = pi.process_definition.schema.node(state).node_extension
+      assignee = injected_data[:assignee] || node_ext.user_task_assignee
+      candidate_users = Array.wrap(injected_data[:candidate_users] || node_ext.user_task_candidate_users)
+      candidate_groups = Array.wrap(injected_data[:candidate_groups] || node_ext.user_task_candidate_groups)
+
+      create! assignee: assignee,
+              candidate_users: candidate_users,
+              candidate_groups: candidate_groups,
+              state: state,
+              process_instance_id: pi.id
+
+      # enable service hooks for "start" & "create" event of execution_listeners & task_listeners
+      ProcessEngine::Listener::Base.execute(pi, node_ext.common_execution_listeners, 'start')
+      ProcessEngine::Listener::Base.execute(pi, node_ext.common_task_listeners, 'create')
+    end
+
+
+    def consumer_task
+      ProcessEngine::Consumer::ConsumerTask.new(self)
+    end
+
+  end
+end

data/app/models/process_engine/schema/interceptor/exclusive_gateway.rb

@@ -0,0 +1,39 @@
+class ProcessEngine::Schema::Interceptor::ExclusiveGateway
+
+  attr_reader :node, :options
+
+  def initialize(node, options)
+    @node = node
+    @options = options
+  end
+
+  def execute
+    # get the next branch from the options implemented
+    next_node = target_of_next_sequence_flow(options[:exclusive_gateway_choice_value])
+
+    # choose the default flow if not implemented
+    next_node = choose_default_flow unless next_node
+
+    return [] unless next_node # the flow get stuck if no implementation given or no default path
+    [next_node]
+  end
+
+  def self.execute(node, options)
+    new(node, options).execute
+  end
+
+
+  private
+
+  def target_of_next_sequence_flow(value)
+    branching_transition_id = node.node_extension.common_properties_kv[value]
+    return nil unless branching_transition_id.present?
+
+    node.transitions.find { |t| t.id == branching_transition_id }.try(:target)
+  end
+
+  def choose_default_flow
+    df = node.node_extension.gateway_default_flow
+    node.transitions.find { |t| t.id == df }.try(:target)
+  end
+end