petri_flow 0.1.0

data/app/models/wf/case_command/cancel_workitem.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class CancelWorkitem
+    prepend SimpleCommand
+    attr_reader :workitem
+    def initialize(workitem)
+      @workitem = workitem
+    end
+
+    def call
+      raise("The workitem is not in state #{workitem.state}") unless workitem.started?
+      Wf::ApplicationRecord.transaction do
+        workitem.update!(state: :canceled, :canceled_at: Time.zone.now)
+        ReleaseToken.call(workitem)
+        SweepAutomaticTransitions.call(workitem.case)
+      end
+    end
+  end
+end

data/app/models/wf/case_command/clear_manual_assignments.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class ClearManualAssignments
+    prepend SimpleCommand
+    attr_reader :wf_case, :transition
+    def initialize(wf_case, transition)
+      @wf_case = wf_case
+      @transition = transition
+    end
+
+    def call
+      wf_case.case_assignments.where(transition: transition).find_each(&:destroy)
+    end
+  end
+end

data/app/models/wf/case_command/clear_workitem_assignments.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class ClearWorkitemAssignments
+    prepend SimpleCommand
+    attr_reader :workitem, :permanent
+    def initialize(workitem, permanent = true)
+      @workitem = workitem
+      @permanent = permanent
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        ClearManualAssignments.call(workitem.case, workitem.transition) if permanent
+        workitem.workitem_assignments.delete_all
+        workitem.transition.unassignment_callback.constantize.new(workitem.id).perform
+      end
+    end
+  end
+end

data/app/models/wf/case_command/consume_token.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class ConsumeToken
+    prepend SimpleCommand
+    attr_reader :wf_case, :place, :locked_item
+    def initialize(wf_case, place, locked_item = nil)
+      @wf_case  = wf_case
+      @place    = place
+      @locked_item = locked_item
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        if locked_item
+          wf_case.tokens.where(place: place, state: :locked, locked_workitem_id: locked_item.id).update(consumed_at: Time.zone.now, state: :consumed)
+        else
+          wf_case.tokens.where(id: wf_case.tokens.where(place: place, state: :free).first&.id).update(consumed_at: Time.zone.now, state: :consumed)
+        end
+      end
+    end
+  end
+end

data/app/models/wf/case_command/enable_transitions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class EnableTransitions
+    prepend SimpleCommand
+    attr_reader :wf_case
+    def initialize(wf_case)
+      @wf_case = wf_case
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        wf_case.workitems.enabled.each do |workitem|
+          workitem.update!(state: :overridden, overridden_at: Time.zone.now) unless wf_case.can_fire?(workitem.transition)
+        end
+        wf_case.workflow.transitions.each do |transition|
+          next unless wf_case.can_fire?(transition) && !transition.workitems.where(case: wf_case, state: %i[enabled started]).exists?
+
+          trigger_time = Time.zone.now + transition.trigger_limit.minutes if transition.trigger_limit && transition.time?
+          workitem = wf_case.workitems.create!(
+            workflow: wf_case.workflow,
+            transition: transition,
+            state: :enabled,
+            trigger_time: trigger_time
+          )
+          Wf::FireTimedWorkitemJob.set(wait: transition.trigger_limit.minutes).perform_later(workitem.id) if trigger_time
+          SetWorkitemAssignments.call(workitem)
+          workitem.transition.unassignment_callback.constantize.new(workitem.id).perform_now if workitem.workitem_assignments.count == 0
+        end
+      end
+    end
+  end
+end

data/app/models/wf/case_command/end_workitem_action.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class EndWorkitemAction
+    prepend SimpleCommand
+    attr_reader :workitem, :action, :user
+    def initialize(workitem, user, action = :start)
+      @workitem = workitem
+      @action   = action
+      @user     = user
+    end
+
+    def call
+      if action == :start
+        StartWorkitem.call(workitem, user)
+      elsif action == :finish
+        FinishWorkitem.call(workitem, user)
+      elsif action == :cancel
+        CancelWorkitem.call(workitem, user)
+      elsif action == :comment
+        raise("Unknown action #{action}")
+      end
+    end
+  end
+end

data/app/models/wf/case_command/finish_workitem.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class FinishWorkitem
+    prepend SimpleCommand
+    attr_reader :workitem
+    def initialize(workitem)
+      @workitem = workitem
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        FireTransitionInternal.call(workitem)
+        SweepAutomaticTransitions.call(workitem.case)
+      end
+    end
+  end
+end

data/app/models/wf/case_command/finished_p.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class FinishedP
+    prepend SimpleCommand
+    attr_reader :wf_case
+    def initialize(wf_case)
+      @wf_case = wf_case
+    end
+
+    def call
+      return true if wf_case.finished?
+
+      end_place = wf_case.workflow.places.end.first
+      end_place_token_num = Wf::ApplicationRecord.uncached { wf_case.tokens.where(place: end_place).count }
+      if end_place_token_num == 0
+        false
+      else
+        free_and_locked_token_num = wf_case.tokens.where(place: end_place).where(state: %i[free locked]).count
+        raise("The workflow net is misconstructed: Some parallel executions have not finished.") if free_and_locked_token_num > 1
+
+        ConsumeToken.call(wf_case, end_place)
+        wf_case.finished!
+        true
+      end
+    end
+  end
+end

data/app/models/wf/case_command/fire_message_transition.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class FireMessageTransition
+    prepend SimpleCommand
+    attr_reader :workitem
+    def initialize(workitem)
+      @workitem = workitem
+    end
+
+    def call
+      raise("Transition #{workitem.transition.name} is not message triggered") unless workitem.transition.message?
+
+      Wf::ApplicationRecord.transaction do
+        FireTransitionInternal.call(workitem)
+        SweepAutomaticTransitions.call(workitem.case)
+      end
+    end
+  end
+end

data/app/models/wf/case_command/fire_transition_internal.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class FireTransitionInternal
+    prepend SimpleCommand
+    attr_reader :workitem
+    def initialize(workitem)
+      @workitem = workitem
+    end
+
+    def call
+      if workitem.enabled?
+        locked_item = nil
+      elsif workitem.started?
+        locked_item = workitem
+      else
+        raise("can not fire the transition if it is not in state enabled or started.")
+      end
+      Wf::ApplicationRecord.transaction do
+        workitem.update!(finished_at: Time.zone.now, state: :finished)
+        # TODO: only in?
+        workitem.transition.arcs.each do |arc|
+          ConsumeToken.call(workitem.case, arc.place, locked_item)
+        end
+        # last arc without guard -> pass
+        has_passed = false
+        workitem.transition.arcs.out.order("guards_count DESC").each do |arc|
+          if workitem.transition.explicit_or_split?
+            if workitem.pass_guard?(arc, has_passed)
+              has_passed = true
+              AddToken.call(workitem.case, arc.place)
+            end
+          else
+            AddToken.call(workitem.case, arc.place)
+          end
+        end
+        workitem.transition.fire_callback.constantize.new(workitem.id).perform_now
+      end
+    end
+  end
+end

data/app/models/wf/case_command/lock_token.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class LockToken
+    prepend SimpleCommand
+    attr_reader :wf_case, :place, :workitem
+    def initialize(wf_case, place, workitem)
+      @wf_case = wf_case
+      @place = place
+      @workitem = workitem
+    end
+
+    def call
+      wf_case.tokens.free.where(place: place).limit(1).update_all(
+        state: :locked,
+        locked_at: Time.zone.now,
+        locked_workitem_id: workitem.id
+      )
+    end
+  end
+end

data/app/models/wf/case_command/new.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class New
+    prepend SimpleCommand
+    attr_reader :workflow, :target
+    def initialize(workflow, target = nil)
+      @workflow = workflow
+      @target = target
+    end
+
+    def call
+      wf_case = workflow.cases.create!(targetable: target, state: :created)
+      wf_case
+    end
+  end
+end

data/app/models/wf/case_command/release_token.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class ReleaseToken
+    prepend SimpleCommand
+    attr_reader :workitem
+    def initialize(workitem)
+      @workitem = workitem
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        Wf::Token.where(locked_workitem_id: workitem.id).locked.each do |token|
+          AddToken.call(token.case, token.place)
+          token.update!(state: :canceled, canceled_at: Time.zone.now)
+        end
+      end
+    end
+  end
+end

data/app/models/wf/case_command/remove_manual_assignment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class RemoveManualAssignment
+    prepend SimpleCommand
+    attr_reader :wf_case, :transition, :party
+    def initialize(wf_case, transition, party)
+      @wf_case = wf_case
+      @transition = transition
+      @party = party
+    end
+
+    def call
+      wf_case.case_assignments.where(transition: transition, party: party).find_each(&:destroy)
+    end
+  end
+end

data/app/models/wf/case_command/remove_workitem_assignment.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class RemoveWorkitemAssignment
+    prepend SimpleCommand
+    attr_reader :workitem, :party, :permanent
+    def initialize(workitem, party, permanent = true)
+      @workitem = workitem
+      @party    = party
+      @permanent = permanent
+    end
+
+    def call
+      return if party.nil?
+
+      Wf::ApplicationRecord.transaction do
+        RemoveManualAssignment.call(workitem.case, workitem.transition, party) if permanent
+        workitem.workitem_assignments.where(party: party).first&.destroy
+
+        workitem.transition.unassignment_callback.constantize.new(workitem.id).perform_now if workitem.workitem_assignments.count == 0
+      end
+    end
+  end
+end

data/app/models/wf/case_command/resume.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class Resume
+    prepend SimpleCommand
+    attr_reader :wf_case
+    def initialize(wf_case)
+      @wf_case = wf_case
+    end
+
+    def call
+      raise("Only suspended or canceled cases can be resumed") unless wf_case.suspended? || wf_case.canceled?
+
+      wf_case.active!
+    end
+  end
+end

data/app/models/wf/case_command/set_workitem_assignments.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class SetWorkitemAssignments
+    prepend SimpleCommand
+    attr_reader :workitem
+    def initialize(workitem)
+      @workitem = workitem
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        has_case_ass = false
+        workitem.case.case_assignments.where(transition: workitem.transition).find_each do |case_ass|
+          AddWorkitemAssignment.call(workitem, case_ass.party, false)
+          has_case_ass = true
+        end
+
+        unless has_case_ass
+          callback_values = workitem.transition.assignment_callback.constantize.new(workitem.id).perform
+          if callback_values.present?
+            # TODO: do assignment for callback.
+          else
+            workitem.transition.transition_static_assignments.each do |static_assignment|
+              AddWorkitemAssignment.call(workitem, static_assignment.party, false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/wf/case_command/start_case.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class StartCase
+    prepend SimpleCommand
+    attr_reader :wf_case
+    def initialize(wf_case)
+      @wf_case = wf_case
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        wf_case.active!
+        AddToken.call(wf_case, wf_case.workflow.places.start.first)
+        SweepAutomaticTransitions.call(wf_case)
+      end
+    end
+  end
+end

data/app/models/wf/case_command/start_workitem.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class StartWorkitem
+    prepend SimpleCommand
+    attr_reader :workitem, :user
+    def initialize(workitem, user)
+      @workitem = workitem
+      @user     = user
+    end
+
+    def call
+      raise("The workitem is not in state #{workitem.state}") unless workitem.enabled?
+
+      # TODO: holding timeout
+      Wf::ApplicationRecord.transaction do
+        workitem.update!(state: :started, holding_user: user)
+
+        workitem.transition.arcs.in.each do |arc|
+          LockToken.call(workitem.case, arc.place, workitem)
+        end
+      end
+      workitem
+    end
+  end
+end

data/app/models/wf/case_command/suspend.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class Suspend
+    prepend SimpleCommand
+    attr_reader :wf_case
+    def initialize(wf_case)
+      @wf_case = wf_case
+    end
+
+    def call
+      raise("Only active or suspended cases can be canceled") unless wf_case.active?
+
+      wf_case.suspended!
+    end
+  end
+end

data/app/models/wf/case_command/sweep_automatic_transitions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class SweepAutomaticTransitions
+    prepend SimpleCommand
+    attr_reader :wf_case
+    def initialize(wf_case)
+      @wf_case = wf_case
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        EnableTransitions.call(wf_case)
+        done = false
+        until done
+          done = true
+          finished = FinishedP.call(wf_case).result
+          next if finished
+
+          Wf::ApplicationRecord.uncached do
+            wf_case.workitems.joins(:transition).where(state: :enabled).where(Wf::Transition.table_name => { trigger_type: Wf::Transition.trigger_types[:automatic] }).find_each do |item|
+              FireTransitionInternal.call(item)
+              done = false
+            end
+          end
+          EnableTransitions.call(wf_case)
+        end
+      end
+    end
+  end
+end

data/app/models/wf/case_command/sweep_timed_transitions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class SweepTimedTransitions
+    prepend SimpleCommand
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        Wf::Workitem.enabled.where("trigger_time <= ?", Time.zone.now).find_each do |item|
+          FireTransitionInternal.call(item)
+          SweepAutomaticTransitions.call(item.case)
+        end
+      end
+    end
+  end
+end

data/app/models/wf/case_command/workitem_action.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wf::CaseCommand
+  class WorkitemAction
+    prepend SimpleCommand
+    attr_reader :workitem, :action, :user
+    def initialize(workitem, user, action = :start)
+      @workitem = workitem
+      @action   = action
+      @user     = user
+    end
+
+    def call
+      Wf::ApplicationRecord.transaction do
+        BeginWorkitemAction.call(workitem, user, action)
+        EndWorkitemAction.call(workitem, user, action)
+      end
+    end
+  end
+end

data/app/models/wf/comment.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# == Schema Information
+#
+# Table name: wf_comments
+#
+#  id          :integer          not null, primary key
+#  workitem_id :integer
+#  user_id     :string
+#  body        :text
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+
+# frozen_string_literal: true
+
+module Wf
+  class Comment < ApplicationRecord
+    belongs_to :workitem
+    belongs_to :user, class_name: Wf::Workflow.user_class.to_s
+  end
+end

data/app/models/wf/demo_target.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: wf_demo_targets
+#
+#  id          :integer          not null, primary key
+#  name        :string
+#  description :string
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+
+module Wf
+  class DemoTarget < ApplicationRecord
+    has_many :cases, as: :targetable
+  end
+end

data/app/models/wf/entry.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: wf_entries
+#
+#  id          :integer          not null, primary key
+#  user_id     :string
+#  workitem_id :integer
+#  payload     :json             default("{}")
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+
+module Wf
+  class Entry < ApplicationRecord
+    belongs_to :user, class_name: Wf::Workflow.user_class.to_s
+    belongs_to :workitem
+    has_many :field_values
+
+    after_initialize do
+      self.payload = {} if payload.blank?
+    end
+
+    def json
+      field_values.includes(:field).map { |x| [x.field_id.to_i, { field_id: x.id.to_i, field_name: x.field.name, value: x.value_after_cast }] }.to_h
+    end
+
+    def update_payload!
+      update(payload: json)
+    end
+  end
+end

data/app/models/wf/field.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: wf_fields
+#
+#  id              :integer          not null, primary key
+#  name            :string
+#  form_id         :integer
+#  position        :integer          default("0")
+#  field_type      :integer          default("0")
+#  field_type_name :string
+#  default_value   :string
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#
+
+module Wf
+  class Field < ApplicationRecord
+    belongs_to :form, touch: true
+
+    enum field_type: {
+      string: 0,
+      integer: 1,
+      boolean: 2,
+      date: 3,
+      datetime: 4,
+      decimal: 5,
+      float: 6,
+      json: 7,
+      text: 8,
+
+      "string[]": 20,
+      "integer[]": 21,
+      "date[]": 23,
+      "datetime[]": 24,
+      "decimal[]": 25,
+      "float[]": 26,
+      "json[]": 27,
+      "text[]": 28
+    }
+
+    def type_for_cast
+      type = field_type.to_s.match(/^(\w+)(\[\])?$/)[1]
+      is_array = field_type.to_s.match(/^(\w+)(\[\])?$/)[2] == "[]"
+      if is_array
+        ActiveRecord::Type.lookup(type.to_sym, array: true)
+      else
+        ActiveRecord::Type.lookup(type.to_sym)
+      end
+    end
+  end
+end