workflowable 1.0

data/app/assets/stylesheets/workflowable/workflow.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/workflowable/actions_controller.rb

@@ -0,0 +1,35 @@
+#     Copyright 2014 Netflix, Inc.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+
+
+require_dependency "workflowable/application_controller"
+
+module Workflowable
+  class ActionsController < ApplicationController
+
+    def options
+
+      action = Action.new(action_plugin: params[:action_plugin])
+      @options = action.available_options
+
+      respond_to do |format|
+        format.json { render json: @options  }
+        format.js
+
+      end
+    end
+
+  end
+
+end

data/app/controllers/workflowable/application_controller.rb

@@ -0,0 +1,18 @@
+#     Copyright 2014 Netflix, Inc.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+
+module Workflowable
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/workflowable/workflows_controller.rb

@@ -0,0 +1,137 @@
+#     Copyright 2014 Netflix, Inc.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+
+
+require_dependency "workflowable/application_controller"
+
+module Workflowable
+  class WorkflowsController < ApplicationController
+    before_filter :load_workflow, only: [:show, :edit, :update, :destroy, :stages, :configure_stages]
+    def index
+      @workflows = Workflowable::Workflow.order(:name)
+    end
+
+    def new
+      @workflow = Workflow.new
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @workflow }
+      end
+    end
+
+    # GET /workflows/1/edit
+    def edit
+
+    end
+
+    # POST /workflows
+    # POST /workflows.json
+    def create
+      @workflow = Workflow.new(workflow_params)
+
+
+      respond_to do |format|
+        if @workflow.save
+          format.html {
+            if(@workflow.stages.count > 1)
+              redirect_to configure_stages_workflow_path(@workflow), notice: 'Workflow was successfully created. Please configure transitions.'
+            else
+              redirect_to @workflow, notice: 'Workflow was successfully created.'
+            end
+
+          }
+          format.json { render json: @workflow, status: :created, location: @workflow }
+        else
+          format.html { render action: "new" }
+          format.json { render json: @workflow.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PUT /workflows/1
+    # PUT /workflows/1.json
+    def update
+
+
+      respond_to do |format|
+        if @workflow.update_attributes(workflow_params)
+          format.html { redirect_to @workflow, notice: 'Workflow was successfully updated.' }
+          format.json { head :no_content }
+        else
+          format.html { render action: "edit" }
+          format.json { render json: @workflow.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def show
+
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @workflow }
+      end
+
+    end
+
+    def stages
+
+    end
+
+    def configure_stages
+
+    end
+
+
+    # DELETE /workflows/1
+    # DELETE /workflows/1.json
+    def destroy
+      @workflow.destroy
+
+      respond_to do |format|
+        format.html { redirect_to workflows_url }
+        format.json { head :no_content }
+      end
+    end
+
+    private
+
+
+    def workflow_params
+
+      #params.require(:search).permit(:name, :description, :provider, :query, :tag_list).merge(:options =>all_options)
+
+      params.require(:workflow).permit!
+
+      # params.require(:workflow).permit(:name, :workflow_id,
+      #   :actions_attributes=>[:id, :name, :action_plugin, :_destroy],
+      #   :stages_attributes=>[:id, :name, :_destroy,
+      #     :before_actions_attributes=>[:id, :name, :action_plugin, :_destroy],
+      #     :after_actions_attributes=>[:id, :name, :action_plugin, :_destroy],
+      #     :stage_next_steps_attributes=>[:next_stage_id, :id, :_destroy]
+
+      #   ]
+      # ).tap do |whitelisted|
+      #   whitelisted[:actions_attributes] = params[:workflow].try(:[],:actions_attributes)
+      #   whitelisted[:stages_attributes] = params[:workflow].try(:[], :stages_attributes)
+      # end
+    end
+
+    def load_workflow
+      @workflow = Workflow.find(params[:id])
+    end
+  end
+
+end

data/app/helpers/workflowable/application_helper.rb

@@ -0,0 +1,19 @@
+#     Copyright 2014 Netflix, Inc.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+
+
+module Workflowable
+  module ApplicationHelper
+  end
+end

data/app/helpers/workflowable/workflow_helper.rb

@@ -0,0 +1,19 @@
+#     Copyright 2014 Netflix, Inc.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+
+
+module Workflowable
+  module WorkflowHelper
+  end
+end

data/app/models/workflowable/action.rb

@@ -0,0 +1,113 @@
+#     Copyright 2014 Netflix, Inc.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+
+
+module Workflowable
+  class Action < ActiveRecord::Base
+    has_many :workflow_actions
+    has_many :workflows, :through=>:workflow_actions
+    has_many :stage_actions
+    has_many :stages, :through=>:stage_actions
+    validate :validate_action_plugin
+    validate :name, :uniquness=>true
+
+    before_save :reject_blank_values
+
+
+    serialize :options, Hash
+
+    def reject_blank_values
+      options.each{|k,v| v.reject!{ |k,v| v.blank? }}
+      options.reject!{|k,v| v.blank?}
+    end
+
+    def validate_action_plugin
+      begin
+        if(Workflowable::Actions.constants.include?(action_plugin.to_sym))
+          #if(Workflowable::Actions::Action.subclasses.include?(("Workflowable::Actions::"+action_plugin).constantize))
+          return true
+        end
+      rescue
+      end
+      errors.add :action_plugin, "is invalid"
+    end
+
+    def autocomplete(field_type, value, options={}, workflow=nil, object=nil, current_stage=nil, next_stage=nil, user=nil)
+      ("Workflowable::Actions::"+action_plugin).constantize.autocomplete(field_type, value, options, workflow, object, current_stage, next_stage, user)
+    end
+
+
+    def run(options={}, workflow, object, current_stage, next_stage, user)
+      options ||={}
+      plugin = ("Workflowable::Actions::"+action_plugin).constantize#("Workflowable::Actions::" + self.action_plugin.to_s).constantize
+      plugin.new(self.available_options(options), workflow, object, current_stage, next_stage, user).run
+
+    end
+
+
+    def validate_options(options={}, workflow=nil, object=nil, current_stage=nil, next_stage=nil, user=nil)
+      plugin = ("Workflowable::Actions::"+action_plugin).constantize#("Workflowable::Actions::" + self.action_plugin.to_s).constantize
+      results = plugin.new(self.available_options(options), workflow, object, current_stage, next_stage, user).validate_options
+
+      return results
+    end
+
+
+    def available_options(options={}, workflow=nil, object=nil, current_stage=nil, next_stage=nil, user=nil)
+      options ||={}
+
+      # value_options = options.with_indifferent_access.deep_dup.each{|k1,v1|
+      #   v1.reject!{|k2,v2| k2!= "value" || v2.blank?};
+      #   v1[:user_specified]=true;
+      # }
+      # default_options = options.with_indifferent_access.deep_dup.each{ |k1,v1|
+      #   v1.reject!{|k2,v2| k2!= "default" || v2.blank? }
+      # }
+
+
+
+      value_options = options.with_indifferent_access.each{|k1,v1|
+        v1.reject{|k2,v2| k2 != "value" || v2.blank?};
+        v1[:user_specified]=true;
+      }
+
+
+
+      default_options = options.with_indifferent_access.each{ |k1,v1|
+        v1.reject{|k2,v2| k2 != "default" || v2.blank? }
+      }
+
+      options = self.options.with_indifferent_access.deep_merge(default_options)
+
+      options = value_options.with_indifferent_access.deep_merge(options)
+      if(action_plugin)
+        all_options = ("Workflowable::Actions::"+action_plugin).constantize.options(options, workflow, object, current_stage, next_stage, user)
+      else
+        all_options = {}
+      end
+
+
+    end
+
+    def action_plugin_options
+      ("Workflowable::Actions::"+action_plugin).constantize.options
+    end
+
+
+    def action_plugin_name
+      ("Workflowable::Actions::"+action_plugin).constantize.name
+    end
+
+  end
+end

data/app/models/workflowable/stage.rb

@@ -0,0 +1,104 @@
+#     Copyright 2014 Netflix, Inc.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+
+
+module Workflowable
+    class Stage < ActiveRecord::Base
+        belongs_to :workflow,  :inverse_of=>:stages
+        has_many :stage_next_steps, :foreign_key=>:current_stage_id
+        has_many :next_steps,
+            :through=>:stage_next_steps,
+            :class_name=>"Stage",
+            :source=>:next_stage
+
+
+
+
+
+
+        has_many :before_stage_actions, -> { where(event: 'before').order("position ASC") }, class_name: 'StageAction'
+        has_many :after_stage_actions, -> { where(event: 'after').order("position ASC") }, class_name: 'StageAction'
+
+        has_many :before_actions, :through=>:before_stage_actions, :class_name=>'Action', :source=>:action
+        has_many :after_actions, :through=>:after_stage_actions, :class_name=>'Action', :source=>:action
+
+        validates :name, :presence=>true
+        validates :name, :uniqueness=>{:scope=> :workflow_id}
+
+        #validates :workflow_id, :presence=>true
+        validates_presence_of :workflow_id, :unless => lambda {|stage| stage.workflow.try(:valid?)}
+        validates_associated :workflow
+
+        accepts_nested_attributes_for :before_actions, :allow_destroy => true
+        accepts_nested_attributes_for :after_actions, :allow_destroy => true
+        accepts_nested_attributes_for :stage_next_steps, :allow_destroy => true
+
+
+
+
+
+        def run_before_actions(options={}, object, current_stage, user)
+            options ||= {}
+            self.before_actions.each do |action|
+                action.run(options[action.name], self.workflow, object, current_stage, self, user)
+            end
+        end
+
+        def run_after_actions(options={}, object, next_stage, user)
+            options ||= {}
+            self.after_actions.each do |action|
+                action.run(options[action.name], self.workflow, object, self, next_stage, user)
+            end
+        end
+
+        def validate_after_actions(options={}, object, next_stage, user)
+            options ||= {}
+            after_action_errors = {}
+            after_actions.each do |action|
+                errors = action.validate_options(options[action.name] || {}, self.workflow, object, self, next_stage, user)
+                after_action_errors[action.name] = errors if errors.present?
+            end
+            after_action_errors
+        end
+
+        def validate_before_actions(options={}, object, current_stage, user)
+            options ||= {}
+            before_action_errors = {}
+            before_actions.each do |action|
+                errors = action.validate_options(options[action.name] || {}, self.workflow, object, current_stage, self, user)
+                before_action_errors[action.name] = errors if errors.present?
+            end
+            before_action_errors
+        end
+
+        def run_after_options(options={}, object, next_stage, user)
+            options ||= {}
+            after_action_options = {}
+            after_actions.each do |action|
+                after_action_options[action.name] = action.available_options(options[action.name] || {}, self.workflow, object, self, next_stage, user)
+            end
+            after_action_options
+        end
+
+        def run_before_options(options={}, object, current_stage, user)
+            options ||= {}
+            before_actions_options = {}
+            before_actions.each do |action|
+                before_actions_options [action.name] = action.available_options(options[action.name] || {}, self.workflow, object, current_stage, self, user)
+            end
+            before_actions_options
+        end
+
+    end
+end