rails_workflow 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac3a84ad941c246c8df3fa39aba0491cd9d50636
-  data.tar.gz: be6312031bb63bd474de3e1ba91fae69d449369a
+  metadata.gz: 893a6a3e14e7217742d45741be44769220f99871
+  data.tar.gz: 31a32021e3f545687726f713ee34b0302e2e29be
 SHA512:
-  metadata.gz: 6d41b114ed5f230764084eee2dae4b42846be1474e322c857438b31de3f4be40cf242a89175131ef2007d819b29567536b2d8c80f9f44f50d7fe528eadf8b029
-  data.tar.gz: 905e89cf1acddec238fcff6af3a0517589c7d9266becbc4b665f23867a17503e89f289da74d75fcfb5f7a9c15c732f26047e256c4deef79e303311c70dd9c6a2
+  metadata.gz: 43979534a048ffaca99fa76e71bbe5f513857ebc2f65d05142433fcb0235bae5a3855164f775e6141339ffd6d41bb3d3471c4ad871067bd1a116b75c14e6764c
+  data.tar.gz: 7ba7700fd44f0feb760c86f36cdf3ef6ce818f5ae9e839121cb003a15fdb5591c0abc8ef872449f33bcd7f00d693ae0245b10566e221ec823487e201d8d888ad

data/app/concerns/rails_workflow/operation_status.rb

@@ -3,62 +3,14 @@ require 'active_support/concern'
 module RailsWorkflow
   module OperationStatus
     extend ActiveSupport::Concern
+    include Status
 
     included do
-      NOT_STARTED = 0
-      IN_PROGRESS = 1
-      DONE = 2
 
-      WAITING = 3
-      ERROR = 4
-
-      #operation was in progress and canceled
-      CANCELED = 5
-
-      #operation was build but not started and not need to start
-      SKIPPED = 6
-
-      #current operation was in progress or complete
-      #when process restart or rollback to some previous operation happened
-      #this operation is moved to rollback so that rollback operation
-      #can be added to template.
-      #rollback operation can be used to cancel all changes
-      #done by current operation before restart happened
-      ROLLBACK = 7
-
-      def incomplete_statuses
-        [NOT_STARTED, IN_PROGRESS,]
-      end
-
-      def completed_statuses
-        [DONE, CANCELED, SKIPPED]
-      end
-
-      #in which user can pickup operation and complete it etc.
       def self.user_ready_statuses
-        [WAITING]
-      end
-
-      def self.ready_to_assign
-        [WAITING]
+        [Status::WAITING]
       end
 
-      def self.all_statuses
-        (NOT_STARTED..ROLLBACK).to_a
-      end
-
-      def get_status_values
-        [
-            [NOT_STARTED, 'Not Started'],
-            [IN_PROGRESS, 'In Progress'],
-            [DONE, 'Done'],
-            [WAITING, 'Waiting'],
-            [ERROR, 'Error'],
-            [CANCELED, 'Canceled'],
-            [SKIPPED, 'Skipped'],
-            [ROLLBACK, 'Rollback']
-        ]
-      end
     end
 
   end

data/app/concerns/rails_workflow/operation_templates/default_builder.rb

@@ -45,6 +45,20 @@ module RailsWorkflow
 
       end
 
+      module ClassMethods
+
+        def build_context dependencies
+          dependencies.first.try(:context).try(:data)
+        end
+
+        def build_context! operation, dependencies
+          RailsWorkflow::Context.new(
+              parent: operation,
+              data: build_context(dependencies) || operation.process.data)
+        end
+
+      end
+
     end
   end
 end

data/app/concerns/rails_workflow/operation_templates/dependencies.rb

@@ -18,17 +18,16 @@ module RailsWorkflow
       included do
         scope :independent_only, -> { where(dependencies: nil) }
 
-        def dependencies=(dependencies)
-          write_attribute(:dependencies, dependencies.to_json.to_s)
+        def resolve_dependency operation
+          true
         end
 
+        # def dependencies=(dependencies)
+        #   write_attribute(:dependencies, dependencies.to_json.to_s)
+        # end
+        #
         def dependencies
-          value = read_attribute(:dependencies)
-          if value.present?
-            JSON.parse(value)
-          else
-            []
-          end
+          read_attribute(:dependencies) || []
         end
 
       end

data/app/concerns/rails_workflow/operations/default_runner.rb

@@ -97,13 +97,16 @@ module RailsWorkflow
               true
         end
 
-
-        def complete
+        def complete to_status = nil
           if can_complete?
-            on_complete if respond_to? :on_complete
+
+            if to_status.blank? && respond_to?(:on_complete)
+              on_complete
+            end
+
             update_attributes(
                 {
-                    status: self.class::DONE,
+                    status: to_status || self.class::DONE,
                     completed_at: Time.zone.now
                 })
             manager.operation_complete self
@@ -113,12 +116,22 @@ module RailsWorkflow
               exception, {
                            parent: self,
                            target: self,
-                           method: :complete
-
+                           method: :complete,
+                           args: [to_status]
                        }
           )
         end
 
+        def cancel
+          on_cancel if respond_to? :on_cancel
+          complete self.class::CANCELED
+        end
+
+        def skip
+          on_cancel if respond_to? :on_skip
+          complete self.class::SKIPPED
+        end
+
       end
 
     end

data/app/concerns/rails_workflow/operations/dependencies.rb

@@ -17,18 +17,18 @@ module RailsWorkflow
 
       included do
 
-        def dependencies=(dependencies)
-          write_attribute(:dependencies, dependencies.to_json.to_s)
-        end
-
-        def dependencies
-          value = read_attribute(:dependencies)
-          if value.present?
-            JSON.parse(value)
-          else
-            []
-          end
-        end
+        # def dependencies=(dependencies)
+        #   write_attribute(:dependencies, dependencies.to_json.to_s)
+        # end
+        #
+        # def dependencies
+        #   value = read_attribute(:dependencies)
+        #   if value.present?
+        #     JSON.parse(value)
+        #   else
+        #     []
+        #   end
+        # end
 
       end
     end

data/app/concerns/rails_workflow/processes/default_runner.rb

@@ -29,7 +29,7 @@ module RailsWorkflow
         # Process can be completed if all sync operations is complete.
 
         def can_complete?
-          if processing_statuses.include? status
+          if incomplete_statuses.include? status
             incompleted_operations.size == 0 &&
                 workflow_errors.unresolved.size == 0
           else

data/app/concerns/rails_workflow/processes/dependency_resolver.rb

@@ -17,31 +17,25 @@ module RailsWorkflow
         # dependencies on process and operation level
         #
         def build_dependencies operation
-          # template operations that depends on that given operation and it's status
-          template_operations = template.dependent_operations(operation)
 
           new_operations = []
-          # default implementation is not allowing to have few operations in process
-          # having same operation template. One operation template = one operation in process.
-          # Only error task's restart or process restart allowing to re-create operation few times.
-
-          (template_operations - operations.map(&:template)).each do |operation_template|
-            # this is templates that depends on given operation and
-            # not yet added to process.
 
+          matched_templates(operation).each do |operation_template|
             completed_dependencies = [operation]
-            if operation_template.resolve_dependency! operation
+
+            if operation_template.resolve_dependency operation
               new_operations << operation_template.build_operation!(self, completed_dependencies)
             end
 
           end
 
-          new_operations.compact.each do |new_operation|
-            if processing_statuses.include?(status)
+          new_operations.each do |new_operation|
+            if incomplete_statuses.include?(status)
               self.operations << new_operation
               new_operation.start
             end
           end
+
         rescue => exception
           RailsWorkflow::Error.create_from(
               exception, {
@@ -54,11 +48,12 @@ module RailsWorkflow
 
         end
 
-        # # This method returns operations that can be build.
-        # def solved_dependencies operation
-        #   # operation_dependencies(operation).select{|dop| dop.}
-        #   operation_dependencies(operation)
-        # end
+        private
+
+        def matched_templates operation
+          template.dependent_operations(operation) - operations.map(&:template)
+        end
+
 
 
 

data/app/concerns/rails_workflow/status.rb

@@ -0,0 +1,63 @@
+require 'active_support/concern'
+
+module RailsWorkflow
+  module Status
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def all_statuses
+        (NOT_STARTED..ROLLBACK).to_a
+      end
+
+      def get_status_code status
+        case status
+          when "in_progress"
+            IN_PROGRESS
+          when "done"
+            DONE
+          when "not_started"
+            NOT_STARTED
+          when "waiting"
+            WAITING
+          when "error"
+            ERROR
+        end
+      end
+
+    end
+
+    included do
+
+      NOT_STARTED = 0
+      IN_PROGRESS = 1
+      DONE = 2
+      WAITING = 3
+      ERROR = 4
+      CANCELED = 5
+      SKIPPED = 6
+      ROLLBACK = 7
+
+      def incomplete_statuses
+        [NOT_STARTED, IN_PROGRESS, WAITING]
+      end
+
+      def completed_statuses
+        [DONE, CANCELED, SKIPPED, ROLLBACK]
+      end
+
+      def get_status_values
+        [
+            [NOT_STARTED, 'Not Started'],
+            [IN_PROGRESS, 'In Progress'],
+            [DONE, 'Done'],
+            [WAITING, 'Waiting'],
+            [ERROR, 'Error'],
+            [CANCELED, 'Canceled'],
+            [SKIPPED, 'Skipped'],
+            [ROLLBACK, 'Rollback']
+        ]
+      end
+    end
+
+  end
+end

data/app/concerns/rails_workflow/user/assignment.rb

@@ -6,22 +6,28 @@ module RailsWorkflow
       included do
         has_many :operations, class: RailsWorkflow::Operation, as: :assignment
 
+      end
+
+      module ClassMethods
 
-        def self.role_text role
+        def role_text role
           if role.present?
-            get_role_values.rassoc(role.to_s).try(:first)
+            get_rassoc get_role_values, role
           end
         end
 
-        def self.group_text group
+        def group_text group
           if group.present?
-            get_group_values.rassoc(group.to_sym).try(:first)
+            get_rassoc get_group_values, group
           end
         end
 
-
+        def get_rassoc values, value
+          (values.rassoc(value.to_s) || values.rassoc(value.to_sym)).try(:[], 0)
+        end
 
       end
+
     end
   end
 end

data/app/controllers/rails_workflow/errors_controller.rb

@@ -21,7 +21,7 @@ module RailsWorkflow
 
     protected
     def permitted_params
-      parms = params.permit(:process_id, :operation_id, :id)
+      params.permit(:process_id, :operation_id, :id)
     end
   end
 

data/app/controllers/rails_workflow/operation_templates_controller.rb

@@ -1,39 +1,46 @@
-require 'rails_workflow/application_controller'
 module RailsWorkflow
-  class OperationTemplatesController < ::InheritedResources::Base
+  class OperationTemplatesController < ::ActionController::Base
     layout 'rails_workflow/application'
-
-
-    defaults collection_name: 'operations', resource_class: OperationTemplate
-    belongs_to :process_template
+    before_action :set_operation_template, only: [:show, :edit, :update, :destroy]
+    before_action :set_process_template
+    respond_to :html
 
     before_filter do
       @config_section_active = true
     end
 
+    def index
+      @operation_templates = OperationTemplateDecorator.
+          decorate_collection(operation_templates_collection)
+    end
+
+
     def new
-      @operation_template = OperationTemplate.new(permitted_params[:operation_template]).decorate
-      @operation_template.process_template = parent
-      new!
+      @operation_template = OperationTemplate.new(permitted_params).decorate
+      @operation_template.process_template = @process_template
     end
 
+
     def create
-      create!{ process_template_operation_templates_url }
+      @operation_template = OperationTemplate.create(permitted_params)
+      redirect_to process_template_operation_templates_url
     end
 
     def update
-      @operation_template = RailsWorkflow::OperationTemplate.find(params[:id])
-      update! { process_template_operation_templates_url }
+      @operation_template.update(permitted_params)
+      redirect_to process_template_operation_templates_url
     end
 
     def destroy
-      destroy! { process_template_operation_templates_url}
+      @operation_template.destroy
+      redirect_to process_template_operation_templates_url
     end
 
 
     protected
     def permitted_params
-      parms = params.permit(
+      parameters =
+          params.permit(
           operation_template: [
               :kind,
               :type,
@@ -42,6 +49,7 @@ module RailsWorkflow
               :child_process_id,
               :operation_class,
               :role,
+              :partial_name,
               :async,
               :is_background,
               :group,
@@ -50,37 +58,40 @@ module RailsWorkflow
                   statuses: []
               ]
           ])
-      prepare_dependencies parms
-      parms
+
+      if parameters[:operation_template].present?
+          parameters[:operation_template][:dependencies] =
+              prepare_dependencies parameters[:operation_template]
+      end
+
+
+      parameters[:operation_template]
     end
 
-    def prepare_dependencies parms
-      if parms[:operation_template].try(:[], :dependencies).present?
-        dependencies = parms[:operation_template][:dependencies].values.map(&:to_h).each do |dep|
-          dep['id'] = dep['id'].to_i
-          dep['statuses'] = (dep['statuses'] ||
-                              RailsWorkflow::OperationTemplate.all_statuses
-                            ).map(&:to_i)
-        end
+    def prepare_dependencies parameters
+      parameters[:dependencies] &&
+          parse_dependencies(parameters[:dependencies].to_hash)
+    end
 
-        parms[:operation_template][:dependencies] = dependencies
+    def parse_dependencies hash
+      hash.values.each do |dep|
+        dep['id'] = dep['id'].to_i
+        dep['statuses'] = dep['statuses'].map(&:to_i) || RailsWorkflow::OperationTemplate.all_statuses
       end
     end
 
-    def operations_collection
-      get_collection_ivar || begin
-        # collection_scope = Workflow::OperationTemplate.select("")
-        collection_scope = end_of_association_chain
-        set_collection_ivar collection_scope.order(id: :asc)
+    def operation_templates_collection
+
+      @operation_templates = @process_template.try(:operations) || OperationTemplate.
+          order(id: :asc)
 
-      end
     end
 
-    def collection
-      OperationTemplateDecorator.decorate_collection(operations_collection)
+    def set_process_template
+      @process_template = ProcessTemplate.find(params[:process_template_id]).decorate
     end
 
-    def resource
+    def set_operation_template
       @operation_template ||= OperationTemplate::find(params[:id]).decorate
     end
   end

data/app/controllers/rails_workflow/operations_controller.rb

@@ -1,11 +1,12 @@
-require_dependency "rails_workflow/application_controller"
-
 module RailsWorkflow
-  class OperationsController < ::InheritedResources::Base
+  class OperationsController < ::ActionController::Base
     layout 'rails_workflow/application'
+    respond_to :html
+
+    before_action :set_operation, only: [:show, :edit, :pickup, :update, :destroy]
 
     before_filter do
-      if parent.present?
+      if @process.present?
         @processes_section_active = true
       else
         @operations_section_active = true
@@ -14,26 +15,32 @@ module RailsWorkflow
       @current_operation = current_operation
     end
 
-
-    defaults collection_name: 'operations', resource_class: Operation
-    belongs_to :process, optional: true
-
     def create
-      create!{ process_operation_url }
+      @operation = Operation.create(permitted_params)
+      redirect_to process_operation_url
     end
 
+    def index
+      @operations = OperationDecorator.decorate_collection(
+          parent.try(:operations) || Operation.waiting.order(created_at: :desc)
+      )
+
+      respond_with @operations
+    end
 
     def update
-      @operation = RailsWorkflow::Operation.find(params[:id])
-      update! { process_operation_url }
+      @operation.update(permitted_params)
+      redirect_to process_operation_url
     end
 
     def pickup
-      @operation = RailsWorkflow::Operation.find(params[:id])
-
       if @operation.assign(current_user)
+
         set_current_operation
-        redirect_to main_app.send(@operation.data[:url_path], *@operation.data[:url_params])
+        redirect_to main_app.send(
+                        @operation.data[:url_path],
+                        *@operation.data[:url_params]
+                    )
       else
         redirect_to operations_path
       end
@@ -46,37 +53,36 @@ module RailsWorkflow
         operation.complete
         clear_current_operation
 
-        # redirect_to root_path #where to redirect on operation complete??
+        redirect_to main_app.root_path
       end
     end
 
     def destroy
-      destroy! { process_operation_url}
+      @operation.destroy
+      redirect_to process_operation_url
     end
 
 
     protected
     def permitted_params
-      params.permit(operation: [:title, :source, :operation_class, :async, :is_background, dependencies: [:id, statuses: []]])
+      params.permit(
+          operation: [
+              :title,
+              :source,
+              :operation_class,
+              :async,
+              :is_background,
+              dependencies: [:id, statuses: []]
+          ]
+      )[:operation]
     end
 
-    def operations_collection
-      get_collection_ivar ||
-          set_collection_ivar(
-              end_of_association_chain.waiting.order(created_at: :desc)
-          )
-    end
 
-    def collection
-      if parent.present?
-        OperationDecorator.decorate_collection(super)
-      else
-        scope = operations_collection
-        OperationDecorator.decorate_collection(scope)
-      end
+    def parent
+      @parent ||= params[:process_id] && Process.find(params[:process_id])
     end
 
-    def resource
+    def set_operation
       @operation ||= Operation::find(params[:id]).decorate
     end