process_engine 0.0.1

data/app/assets/javascripts/process_engine/application.js

@@ -0,0 +1,65 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require jquery
+//= require jquery_ujs
+//= require bootstrap
+//= require_tree .
+
+
+function loadBMPNViewer(bpmnXMLUrl, highlightedNodes, BpmnViewer, $) {
+
+  // create viewer
+  var bpmnViewer = new BpmnViewer({
+    container: '#bpmn_canvas'
+  });
+
+
+  // import function
+  function importXML(xml) {
+
+    // import diagram
+    bpmnViewer.importXML(xml, function(err) {
+
+      if (err) {
+        return console.error('could not import BPMN 2.0 diagram', err);
+      }
+
+      var canvas = bpmnViewer.get('canvas'),
+          overlays = bpmnViewer.get('overlays');
+
+
+      // zoom to fit full viewport
+      canvas.zoom('fit-viewport');
+
+      // attach an overlay to a node
+      // overlays.add('decision', 'note', {
+      //   position: {
+      //     bottom: 0,
+      //     right: 0
+      //   },
+      //   html: '<div class="diagram-note">Mixed up the labels?</div>'
+      // });
+
+      // add marker
+      // canvas.addMarker('decision', 'bpmn-highlight-node');
+      // canvas.addMarker('UserTask_1', 'bpmn-highlight-node');
+      for(var i in highlightedNodes) {
+        canvas.addMarker(highlightedNodes[i], 'bpmn-highlight-node');
+      }
+    });
+  }
+
+
+  // load external diagram file via AJAX and import it
+  $.get(bpmnXMLUrl, importXML, 'text');
+}

data/app/assets/stylesheets/process_engine/application.css

@@ -0,0 +1,39 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require bootstrap
+ *= require_self
+ */
+
+
+ .diagram-note {
+   background-color: rgba(66, 180, 21, 0.7);
+   color: White;
+   border-radius: 5px;
+   font-family: Arial;
+   font-size: 12px;
+   padding: 5px;
+   min-height: 16px;
+   width: 50px;
+   text-align: center;
+ }
+
+ .bpmn-highlight-node:not(.djs-connection) .djs-visual > :nth-child(1) {
+   stroke: rgba(66, 180, 21, 0.7) !important; /* color elements as red */
+   fill: rgba(114, 184, 76, 0.7) !important;
+   stroke-width: 5px;
+ }
+
+ .bjs-powered-by {
+   display: none;
+ }

data/app/controllers/process_engine/application_controller.rb

@@ -0,0 +1,28 @@
+module ProcessEngine
+  class ApplicationController < ActionController::Base
+    layout 'process_engine/layouts/application'
+
+    def update_active_record_complex_type(entity)
+      begin
+        return yield
+      rescue JSON::ParserError
+        check_error_parsing_attribute_type entity, "JSON is invalid"
+      rescue TypeError
+        check_error_parsing_attribute_type entity, "Array is invalid. e.g. {element1,element2} without space"
+      end
+      false
+    end
+
+    private
+
+    def check_error_parsing_attribute_type(entity, message)
+      entity.attribute_names.each do |an|
+        begin
+          entity.send(an)
+        rescue
+          entity.errors.add(an, message)
+        end
+      end
+    end
+  end
+end

data/app/controllers/process_engine/process_definitions_controller.rb

@@ -0,0 +1,63 @@
+class ProcessEngine::ProcessDefinitionsController < ProcessEngine::ApplicationController
+  before_action :set_definition, only: [:bpmn_xml, :show, :edit, :update, :destroy, :start_new_process_instance]
+
+  def index
+    @definitions = ProcessEngine::ProcessDefinition.page(params[:page]).per_page(20)
+  end
+
+  def show
+  end
+
+  def new
+    @definition = ProcessEngine::ProcessDefinition.new
+  end
+
+  def create
+    @definition = ProcessEngine::ProcessDefinition.new
+
+    if update_active_record_complex_type(@definition) do
+        @definition.assign_attributes definition_params
+        @definition.save
+      end
+
+      redirect_to process_definition_path(@definition)
+    else
+      render :new
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if update_active_record_complex_type(@definition) { @definition.update definition_params }
+      redirect_to process_definition_path(@definition)
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @definition.destroy
+    redirect_to process_definitions_path
+  end
+
+  def start_new_process_instance
+    pi = ProcessEngine::ProcessQuery.process_instance_start(@definition.slug, "dummy")
+    redirect_to process_instance_path(pi)
+  end
+
+  def bpmn_xml
+    render text: @definition.bpmn_xml, content_type: 'text/xml'
+  end
+
+  private
+
+  def set_definition
+    @definition = ProcessEngine::ProcessDefinition.find(params[:id])
+  end
+
+  def definition_params
+    params.require(:process_definition).permit(:name, :slug, :description, :bpmn_xml)
+  end
+end

data/app/controllers/process_engine/process_instances_controller.rb

@@ -0,0 +1,42 @@
+class ProcessEngine::ProcessInstancesController < ProcessEngine::ApplicationController
+  before_action :set_process_definition, only: [:index]
+  before_action :set_process_instance, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @process_instances = @definition.process_instances.desc.page(params[:page]).per_page(50)
+  end
+
+  def show
+  end
+
+  def edit
+  end
+
+  def update
+    if @process_instance.update(process_instance_params)
+      redirect_to process_instance_path(@process_instance)
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    definition_id = @process_instance.process_definition_id
+    @process_instance.destroy
+    redirect_to process_definition_process_instances_path(definition_id)
+  end
+
+  private
+
+  def process_instance_params
+    params.require(:process_instance).permit(:status, :state, :creator)
+  end
+
+  def set_process_definition
+    @definition = ProcessEngine::ProcessDefinition.find(params[:process_definition_id])
+  end
+
+  def set_process_instance
+    @process_instance = ProcessEngine::ProcessInstance.find(params[:id])
+  end
+end

data/app/controllers/process_engine/process_tasks_controller.rb

@@ -0,0 +1,23 @@
+class ProcessEngine::ProcessTasksController < ProcessEngine::ApplicationController
+  before_action :set_process_instance, only: [:index]
+  before_action :set_process_task, only: [:finish, :show, :edit, :update, :destroy]
+
+  def index
+    @process_tasks = @process_instance.process_tasks.desc.page(params[:page]).per_page(50)
+  end
+
+  def finish
+    ProcessEngine::ProcessQuery.task_complete(@process_task.id) unless @process_task.finished?
+    redirect_to process_instance_process_tasks_path(@process_task.process_instance_id)
+  end
+
+  private
+
+  def set_process_task
+    @process_task = ProcessEngine::ProcessTask.find(params[:id])
+  end
+
+  def set_process_instance
+    @process_instance = ProcessEngine::ProcessInstance.find(params[:process_instance_id])
+  end
+end

data/app/helpers/process_engine/application_helper.rb

@@ -0,0 +1,4 @@
+module ProcessEngine
+  module ApplicationHelper
+  end
+end

data/app/models/process_engine/consumer/consumer_task.rb

@@ -0,0 +1,15 @@
+class ProcessEngine::Consumer::ConsumerTask
+
+  attr_reader :process_task, :node, :node_extension
+
+  def initialize(process_task)
+    @process_task = process_task
+    @node = process_task.process_instance.process_definition.schema.node(process_task.state)
+    @node_extension = @node.node_extension
+  end
+
+  def external_ref
+    node_extension.common_properties_kv[:external_ref]
+  end
+
+end

data/app/models/process_engine/error/false_task_state.rb

@@ -0,0 +1,2 @@
+class ProcessEngine::Error::FalseTaskState < StandardError
+end

data/app/models/process_engine/listener/base.rb

@@ -0,0 +1,49 @@
+class ProcessEngine::Listener::Base
+  attr_reader :process_task, :listener
+
+  def initialize(process_task, listener)
+    @process_task = process_task
+    @listener = listener
+  end
+
+  def self.execute(process_task, listeners, event)
+    listeners.select { |ln| ln[:event] == event}.each { |listener| new(process_task, listener).execute }
+  end
+
+  def execute
+    listener_type = listener[:type]
+
+    case listener_type
+    when "class_name"
+      execute_class_name
+    when "delegate_expression"
+      execute_delegate_expression
+    when "expression"
+      execute_expression
+    when "script"
+      execute_script
+    else
+      raise "No such type (#{listener_type}) supported"
+    end
+  end
+
+  private
+
+  def execute_class_name
+    cls = (listener[:value]).constantize # let it raise error purposely, and user need to catch this
+    cls.execute(process_task)
+  end
+
+  def execute_delegate_expression
+    # need to implement
+  end
+
+  def execute_expression
+    # need to implement
+  end
+
+  def execute_script
+    # need to implement
+  end
+
+end

data/app/models/process_engine/node_data_injection.rb

@@ -0,0 +1,22 @@
+class ProcessEngine::NodeDataInjection
+  cattr_accessor :injected_classes
+
+  # source object could be process instance object or process task object
+  def self.node_options_data(process_definition_slug, node_id, source_object)
+    # each class requires `implemented_node_ids`
+    selected_class = (injected_classes || []).find { |icl| icl.implemented_node_ids.map(&:to_s).include?(node_id.to_s) && icl.process_definition_slug == process_definition_slug }
+    return {} unless selected_class.present?
+
+    # return value from here
+    result = selected_class.forward_implementation_method(node_id, source_object)
+    result.instance_of?(Hash) ? result : {}
+  end
+
+  def self.implementation_check
+    (injected_classes || []).each do |icl|
+      methods = %i(process_definition_slug implemented_node_ids forward_implementation_method).each do |method|
+        fail "You need to implement class method `#{method.to_s}` in #{icl}" unless icl.respond_to?(method)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+class ProcessEngine::Parser::ComplexGateway < 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/end_event.rb

@@ -0,0 +1,23 @@
+class ProcessEngine::Parser::EndEvent < ProcessEngine::Parser::XmlNode
+  def initialize(element)
+    super(element)
+  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
+      }
+    })
+  end
+
+
+end

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

@@ -0,0 +1,25 @@
+class ProcessEngine::Parser::ExclusiveGateway < 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/extension/condition_expression.rb

@@ -0,0 +1,39 @@
+class ProcessEngine::Parser::Extension::ConditionExpression
+  attr_reader  :element
+
+  def initialize(element)
+    @element = element
+  end
+
+  def language
+    element["language"]
+  end
+
+  def condition
+    element.content
+  end
+
+  def type
+    element["xsi:type"]
+  end
+
+  def resource
+    element["camunda:resource"]
+  end
+
+
+  def self.factory(xelement)
+    ce = xelement.at_xpath("bpmn2:conditionExpression")
+    return nil unless ce
+    new(ce)
+  end
+
+  def to_h
+    {
+      language: language,
+      condition: condition,
+      type: type,
+      resource: resource
+    }
+  end
+end

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

@@ -0,0 +1,15 @@
+class ProcessEngine::Parser::Extension::ExecutionListener
+  attr_reader  :element
+
+  include ProcessEngine::Parser::Extension::Listener
+
+  # available option for event: start, end
+
+  def initialize(element)
+    @element = element
+  end
+
+  def self.factory(extension_element)
+    extension_element.xpath("camunda:executionListener").map { |el| new(el) }
+  end
+end

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

@@ -0,0 +1,50 @@
+class ProcessEngine::Parser::Extension::FormField
+  attr_reader  :element
+
+  def initialize(element)
+    @element = element
+  end
+
+  def id
+    element["id"]
+  end
+
+  def label
+    element["label"]
+  end
+
+  def type
+    element["type"]
+  end
+
+  def default_value
+    element["defaultValue"]
+  end
+
+  def properties
+    element.xpath("camunda:properties//camunda:property").each_with_object({}) do |prop, hash|
+      hash[prop["id"]] = prop["value"]
+    end
+  end
+
+  def validation
+    element.xpath("camunda:validation//camunda:constraint").each_with_object({}) do |constraint, hash|
+      hash[constraint["name"]] = constraint["config"]
+    end
+  end
+
+  def to_h
+    {
+      id: id,
+      label: label,
+      type: type,
+      default_value: default_value,
+      properties: properties,
+      validation: validation
+    }
+  end
+
+  def self.factory(extension_element)
+    data = extension_element.xpath("camunda:formData//camunda:formField").map{ |ff| new(ff) }
+  end
+end

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

@@ -0,0 +1,28 @@
+class ProcessEngine::Parser::Extension::InputOutput
+  attr_reader  :element
+
+  def initialize(element)
+    @element = element
+  end
+
+  def input_parameters
+    ProcessEngine::Parser::Extension::TransitionalParameter.factory(element, "inputParameter")
+  end
+
+  def output_parameters
+    ProcessEngine::Parser::Extension::TransitionalParameter.factory(element, "outputParameter")
+  end
+
+  def to_h
+    {
+      input_parameters: input_parameters.map(&:to_h),
+      output_parameters: output_parameters.map(&:to_h)
+    }
+  end
+
+  def self.factory(extension_element)
+    io = extension_element.at_xpath("camunda:inputOutput")
+    return nil unless io
+    new(io)
+  end
+end

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

@@ -0,0 +1,43 @@
+module ProcessEngine::Parser::Extension::Listener
+  def class_name
+    element["class"]
+  end
+
+  def expression
+    element["expression"]
+  end
+
+  def delegate_expression
+    element["delegateExpression"]
+  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 event
+    element["event"]
+  end
+
+  def type
+    %w(class_name expression delegate_expression script).find {|item| send(item).present? }
+  end
+
+  def value
+    send(type)
+  end
+
+  def to_h
+    {
+      type: type,
+      value: value,
+      event: event
+    }
+  end
+
+end

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

@@ -0,0 +1,20 @@
+class ProcessEngine::Parser::Extension::Property
+  attr_reader  :element, :name, :value
+
+  def initialize(element)
+    @element = element
+    @name = element["name"]
+    @value = element["value"]
+  end
+
+  def to_h
+    {
+      name: name,
+      value: value
+    }
+  end
+
+  def self.factory(extension_element)
+    extension_element.xpath("camunda:properties//camunda:property").map { |el| new(el) }
+  end
+end

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

@@ -0,0 +1,15 @@
+class ProcessEngine::Parser::Extension::TaskListener
+  attr_reader  :element
+
+  include ProcessEngine::Parser::Extension::Listener
+
+  # available option for event: create, assignment, complete
+
+  def initialize(element)
+    @element = element
+  end
+
+  def self.factory(extension_element)
+    extension_element.xpath("camunda:taskListener").map { |tl| new(tl) }
+  end
+end