rails_workflow 0.3.9 → 0.4.0

data/app/models/rails_workflow/operation.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   # Operation is a key building block for a Rails Workflow.
   # This model is used to save operation meta data, describe relation
   # with operation context etc.
   class Operation < ActiveRecord::Base
     include OperationStatus
-
-    include Operations::DefaultRunner
     include Operations::Dependencies
     include Operations::Assignments
 
     belongs_to :process, class_name: 'RailsWorkflow::Process'
+    alias parent process
     belongs_to :template, class_name: 'RailsWorkflow::OperationTemplate'
     belongs_to :child_process, class_name: 'RailsWorkflow::Process'
     has_one :context, class_name: 'RailsWorkflow::Context', as: :parent
@@ -18,9 +19,10 @@ module RailsWorkflow
     delegate :data, to: :context
     delegate :role, to: :template
     delegate :group, to: :template
+    delegate :start, :complete, :skip, :cancel, to: :runner
 
     scope :with_child_process, -> { where.not(child_process: nil) }
-    scope :incompleted, -> { where(status: user_ready_statuses) }
+    scope :uncompleted, -> { where(status: user_ready_statuses) }
 
     def instruction
       template.instruction
@@ -44,10 +46,44 @@ module RailsWorkflow
       assignment && assignment == user
     end
 
+    def execute
+      true
+    end
+
+    # This method allows you to add requirements for operation to start.
+    # For example some operation can't start because of some process
+    # or overall system conditions.
+    # By default any operation can start :)
+    def can_start?
+      status.in? [Status::NOT_STARTED, Status::IN_PROGRESS]
+    end
+
+    def completed?
+      completed_statuses.include? status
+    end
+
+    def completable?
+      child_process_done?
+    end
+
     def can_be_continued_by?(user, current_operation)
       waiting? &&
         assigned_to?(user) &&
         (current_operation.nil? || current_operation != self)
     end
+
+    private
+
+    def child_process_done?
+      child_process.nil? || child_process.status == Status::DONE
+    end
+
+    def config
+      RailsWorkflow.config
+    end
+
+    def runner
+      @runner ||= config.operation_runner.new(self)
+    end
   end
 end

data/app/models/rails_workflow/operation_template.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   class OperationTemplate < ActiveRecord::Base
     include OperationStatus
     include RailsWorkflow::Uuid
     include OperationTemplates::Dependencies
     include OperationTemplates::Assignments
-    include OperationTemplates::DefaultBuilder
-    include ResetCache
 
     belongs_to :process_template, class_name: 'RailsWorkflow::ProcessTemplate'
     belongs_to :child_process, class_name: 'RailsWorkflow::ProcessTemplate'

data/app/models/rails_workflow/process.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
+  # Process stores service information including links to process template,
+  # all operations, parent operation, context etc.
   class Process < ActiveRecord::Base
     include Status
-    include Processes::DependencyResolver
-    include Processes::DefaultRunner
 
     belongs_to :template, class_name: 'RailsWorkflow::ProcessTemplate'
     has_many :operations, class_name: 'RailsWorkflow::Operation'
     has_one :parent_operation,
-      class_name: 'RailsWorkflow::Operation',
-      foreign_key: :child_process_id
+            class_name: 'RailsWorkflow::Operation',
+            foreign_key: :child_process_id
+
+    alias parent parent_operation
     has_one :context, class_name: 'RailsWorkflow::Context', as: :parent
     has_many :workflow_errors, class_name: 'RailsWorkflow::Error', as: :parent
 
     delegate :data, to: :context
-    scope :by_status, -> (status) { where(status: status) }
+    scope :by_status, ->(status) { where(status: status) }
 
     def manager
       @manager ||= template.manager_class.new(self)
@@ -32,5 +36,30 @@ module RailsWorkflow
     def self.statuses_array
       (NOT_STARTED..ROLLBACK).to_a
     end
+
+    def uncompleted?
+      uncompleted_statuses.include?(status) &&
+        uncompleted_operations.size.zero?
+    end
+
+    # Returns set or operation that not yet completed.
+    # Operation complete in DONE, SKIPPED, CANCELED, etc many other statuses
+    def uncompleted_operations
+      operations.reject(&:completed?)
+    end
+
+    def can_start?
+      [Status::NOT_STARTED, Status::IN_PROGRESS]
+        .include?(status) && !operations.empty?
+    end
+
+    def unresolved_errors
+      workflow_errors.unresolved.where.not(id: id)
+    end
+
+    def complete
+      self.status = Status::DONE
+      save
+    end
   end
 end

data/app/models/rails_workflow/process_template.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   class ProcessTemplate < ActiveRecord::Base
-    include ProcessTemplates::DefaultBuilder
     include RailsWorkflow::Uuid
-    include ResetCache
-
-    has_many :operations, -> { order(id: :asc) }, class_name: 'OperationTemplate'
+    has_many :operations,
+             -> { order(id: :asc) },
+             class_name: 'OperationTemplate'
 
     def other_processes
       ProcessTemplate.where.not(id: id)
@@ -13,15 +14,17 @@ module RailsWorkflow
     # we try to read process class from template
     # and set default Workflow::Process if blank process_class on template
     def process_class
-      get_class_for :process_class, RailsWorkflow.config.process_class
+      get_class_for :process_class,
+                    RailsWorkflow.config.process_class
     end
 
     def manager_class
-      get_class_for :manager_class, RailsWorkflow.config.manager_class
+      get_class_for(:manager_class,
+                    RailsWorkflow.config.manager_class)
     end
 
     def independent_operations
-      operations.select(&:independent?)
+      operations.independent_only.to_a
     end
 
     # here we calculate template operations that depends on
@@ -29,7 +32,8 @@ module RailsWorkflow
     def dependent_operations(operation)
       operations.select do |top|
         top.dependencies.select do |dp|
-          dp['id'] == operation.template.id && dp['statuses'].include?(operation.status)
+          dp['id'] == operation.template.id &&
+            dp['statuses'].include?(operation.status)
         end.present?
       end
     end

data/app/models/rails_workflow/user_by_group_operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   # Used to describe user operations which assignment
   # is depend on user group.

data/app/models/rails_workflow/user_by_role_operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   # Used to describe user operations which assignment
   # depends on user role.

data/app/models/rails_workflow/user_operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   # Default class to describe User operation.
   # It describes two main differences of user

data/app/serializers/rails_workflow/operation_template_serializer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   class OperationTemplateSerializer < ActiveModel::Serializer
     attributes :uuid, :title, :source, :dependencies, :operation_class,

data/app/serializers/rails_workflow/process_template_serializer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   class ProcessTemplateSerializer < ActiveModel::Serializer
     attributes :uuid, :title, :source,

data/app/services/rails_workflow/default_importer_preprocessor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   class DefaultImporterPreprocessor
     def prepare(json)

data/app/services/rails_workflow/process_importer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   class ProcessImporter
     def initialize(json)

data/app/views/rails_workflow/processes/index.html.slim

@@ -14,19 +14,19 @@ ol.breadcrumb.alert-warning
             span.badge< = @statistic[:all]
           = link_to processes_path(filter: {status: "in_progress"}), class: "btn btn-primary" do
             | In progress
-            span.badge< = @statistic[:statuses][RailsWorkflow::Process::IN_PROGRESS]
+            span.badge< = @statistic[:statuses][RailsWorkflow::Status::IN_PROGRESS]
           = link_to processes_path(filter: {status: "done"}), class: "btn btn-success" do
             | Done
-            span.badge< = @statistic[:statuses][RailsWorkflow::Process::DONE]
+            span.badge< = @statistic[:statuses][RailsWorkflow::Status::DONE]
           = link_to processes_path(filter: {status: "waiting"}), class: "btn btn-info" do
             | Waiting
-            span.badge< = @statistic[:statuses][RailsWorkflow::Process::WAITING]
+            span.badge< = @statistic[:statuses][RailsWorkflow::Status::WAITING]
           = link_to processes_path(filter: {status: "not_started"}), class: "btn btn-warning" do
             | Not Started
-            span.badge< = @statistic[:statuses][RailsWorkflow::Process::NOT_STARTED]
+            span.badge< = @statistic[:statuses][RailsWorkflow::Status::NOT_STARTED]
           = link_to processes_path(filter: {status: "error"}), class: "btn btn-danger" do
             | Error
-            span.badge< = @statistic[:statuses][RailsWorkflow::Process::ERROR]
+            span.badge< = @statistic[:statuses][RailsWorkflow::Status::ERROR]
 
         table.table.table-striped.table-hover
           thead

data/config/initializers/rails_workflow.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ActionController::Base
   def set_current_operation
     session[:current_operation_id] = @operation.id
@@ -20,14 +22,12 @@ class ActionController::Base
       else
 
         @current_workflow_operation = begin
-
-          if RailsWorkflow::Operation.exists?(id: operation_id, status: RailsWorkflow::Operation::WAITING)
+          if RailsWorkflow::Operation.exists?(id: operation_id, status: RailsWorkflow::Status::WAITING)
             operation = RailsWorkflow::Operation.find(operation_id)
             RailsWorkflow::OperationHelperDecorator.decorate(operation)
           else
             clear_current_operation
           end
-
         end
       end
     end

data/config/routes.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 RailsWorkflow::Engine.routes.draw do
-  resources :operations, only: [:index, :show] do
+  resources :operations, only: %i[index show] do
     collection do
       get :complete
       get :skip
@@ -20,7 +22,7 @@ RailsWorkflow::Engine.routes.draw do
         put :retry
       end
     end
-    resources :operations, except: [:create, :update, :destroy] do
+    resources :operations, except: %i[create update destroy] do
       resources :errors, only: [:retry] do
         member do
           put :retry

data/db/migrate/20150630174700_create_workflow_processes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateWorkflowProcesses < ActiveRecord::Migration
   def change
     create_tables
@@ -8,12 +10,12 @@ class CreateWorkflowProcesses < ActiveRecord::Migration
 
   def create_tables
     [
-      [:workflow_processes, :rails_workflow_processes],
-      [:workflow_operations, :rails_workflow_operations],
-      [:workflow_process_templates, :rails_workflow_process_templates],
-      [:workflow_operation_templates, :rails_workflow_operation_templates],
-      [:workflow_contexts, :rails_workflow_contexts],
-      [:workflow_errors, :rails_workflow_errors]
+      %i[workflow_processes rails_workflow_processes],
+      %i[workflow_operations rails_workflow_operations],
+      %i[workflow_process_templates rails_workflow_process_templates],
+      %i[workflow_operation_templates rails_workflow_operation_templates],
+      %i[workflow_contexts rails_workflow_contexts],
+      %i[workflow_errors rails_workflow_errors]
     ].map do |names|
       rename_table names[0], names[1] if table_exists? names[0]
 
@@ -23,13 +25,13 @@ class CreateWorkflowProcesses < ActiveRecord::Migration
 
   def create_indexes
     [
-      [:rails_workflow_contexts, [:parent_id, :parent_type]],
-      [:rails_workflow_errors, [:parent_id, :parent_type]],
-      [:rails_workflow_operation_templates, :process_template_id],
-      [:rails_workflow_operation_templates, :uuid],
-      [:rails_workflow_process_templates, :uuid],
-      [:rails_workflow_operations, :process_id],
-      [:rails_workflow_operations, :template_id]
+      [:rails_workflow_contexts, %i[parent_id parent_type]],
+      [:rails_workflow_errors, %i[parent_id parent_type]],
+      %i[rails_workflow_operation_templates process_template_id],
+      %i[rails_workflow_operation_templates uuid],
+      %i[rails_workflow_process_templates uuid],
+      %i[rails_workflow_operations process_id],
+      %i[rails_workflow_operations template_id]
     ].each do |idx|
       add_index idx[0], idx[1] unless index_exists? idx[0], idx[1]
     end
@@ -38,93 +40,93 @@ class CreateWorkflowProcesses < ActiveRecord::Migration
   def create_columns
     {
       rails_workflow_contexts: [
-        [:integer,  :parent_id],
-        [:string,   :parent_type],
-        [:text,     :body],
-        [:datetime, :created_at],
-        [:datetime, :updated_at]
+        %i[integer parent_id],
+        %i[string parent_type],
+        %i[text body],
+        %i[datetime created_at],
+        %i[datetime updated_at]
       ],
 
       rails_workflow_errors: [
-        [:string,   :message],
-        [:text, :stack_trace],
-        [:integer,  :parent_id],
-        [:string,   :parent_type],
-        [:datetime, :created_at],
-        [:datetime, :updated_at],
-        [:boolean,  :resolved]
+        %i[string message],
+        %i[text stack_trace],
+        %i[integer parent_id],
+        %i[string parent_type],
+        %i[datetime created_at],
+        %i[datetime updated_at],
+        %i[boolean resolved]
       ],
 
       rails_workflow_operation_templates: [
-        [:string,   :title],
-        [:string, :version],
+        %i[string title],
+        %i[string version],
         # [:uuid,     :uuid],
-        [:string, :uuid],
-        [:string,   :tag],
-        [:text,     :source],
-        [:text,     :dependencies],
-        [:string,   :operation_class],
-        [:integer,  :process_template_id],
-        [:datetime, :created_at],
-        [:datetime, :updated_at],
-        [:boolean,  :async],
-        [:integer,  :child_process_id],
-        [:integer,  :assignment_id],
-        [:string,   :assignment_type],
-        [:string,   :kind],
-        [:string,   :role],
-        [:string,   :group],
-        [:text,     :instruction],
-        [:boolean,  :is_background],
-        [:string,   :type],
-        [:string,   :partial_name]
+        %i[string uuid],
+        %i[string tag],
+        %i[text source],
+        %i[text dependencies],
+        %i[string operation_class],
+        %i[integer process_template_id],
+        %i[datetime created_at],
+        %i[datetime updated_at],
+        %i[boolean async],
+        %i[integer child_process_id],
+        %i[integer assignment_id],
+        %i[string assignment_type],
+        %i[string kind],
+        %i[string role],
+        %i[string group],
+        %i[text instruction],
+        %i[boolean is_background],
+        %i[string type],
+        %i[string partial_name]
       ],
 
       rails_workflow_operations: [
-        [:integer,  :status],
-        [:boolean,  :async],
-        [:string,   :version],
-        [:string,   :tag],
-        [:string,   :title],
-        [:datetime, :created_at],
-        [:datetime, :updated_at],
-        [:integer,  :process_id],
-        [:integer,  :template_id],
-        [:text,     :dependencies],
-        [:integer,  :child_process_id],
-        [:integer,  :assignment_id],
-        [:string,   :assignment_type],
-        [:datetime, :assigned_at],
-        [:string,   :type],
-        [:boolean,  :is_active],
-        [:datetime, :completed_at],
-        [:boolean,  :is_background]
+        %i[integer status],
+        %i[boolean async],
+        %i[string version],
+        %i[string tag],
+        %i[string title],
+        %i[datetime created_at],
+        %i[datetime updated_at],
+        %i[integer process_id],
+        %i[integer template_id],
+        %i[text dependencies],
+        %i[integer child_process_id],
+        %i[integer assignment_id],
+        %i[string assignment_type],
+        %i[datetime assigned_at],
+        %i[string type],
+        %i[boolean is_active],
+        %i[datetime completed_at],
+        %i[boolean is_background]
       ],
 
       rails_workflow_process_templates: [
-        [:string,   :title],
-        [:text,     :source],
-        [:string,   :uuid],
-        [:string,   :version],
-        [:string,   :tag],
-        [:string,   :manager_class],
-        [:string,   :process_class],
-        [:datetime, :created_at],
-        [:datetime, :updated_at],
-        [:string,   :type],
-        [:string,   :partial_name]
+        %i[string title],
+        %i[text source],
+        %i[string uuid],
+        %i[string version],
+        %i[string tag],
+        %i[string manager_class],
+        %i[string process_class],
+        %i[datetime created_at],
+        %i[datetime updated_at],
+        %i[string type],
+        %i[string partial_name]
       ],
 
       rails_workflow_processes: [
-        [:integer,  :status],
-        [:string,   :version],
-        [:string,   :tag],
-        [:boolean,  :async],
-        [:string,   :title],
-        [:datetime, :created_at],
-        [:datetime, :updated_at],
-        [:integer,  :template_id],
-        [:string,   :type]
+        %i[integer status],
+        %i[string version],
+        %i[string tag],
+        %i[boolean async],
+        %i[string title],
+        %i[datetime created_at],
+        %i[datetime updated_at],
+        %i[integer template_id],
+        %i[string type]
       ]
     }.each do |table, columns|
       columns.map do |column|