bizflow 0.0.1

data/lib/bizflow/data_model/handler_blueprint.rb

@@ -0,0 +1,17 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class HandlerBlueprint < Sequel::Model
+
+      many_to_one :action_blueprint
+      one_to_many :handlers
+
+    end
+
+  end
+
+end
+

data/lib/bizflow/data_model/head.rb

@@ -0,0 +1,16 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class Head < Sequel::Model
+
+      many_to_one :action
+      many_to_one :process
+
+    end
+
+  end
+
+end

data/lib/bizflow/data_model/next_action.rb

@@ -0,0 +1,17 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class NextAction < Sequel::Model
+
+      many_to_one :action
+      many_to_one :next, :class => :'Bizflow::DataModel::Action'
+      
+    end
+
+  end
+
+end
+

data/lib/bizflow/data_model/next_action_blueprint.rb

@@ -0,0 +1,17 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class NextActionBlueprint < Sequel::Model
+
+      many_to_one :action_blueprint
+      many_to_one :next_blueprint, :class => :'Bizflow::DataModel::ActionBlueprint'
+      
+    end
+
+  end
+
+end
+

data/lib/bizflow/data_model/process.rb

@@ -0,0 +1,31 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class Process < Sequel::Model
+
+      many_to_one :process_blueprint
+      one_to_many :actions
+      one_to_many :heads
+      one_to_one :start, :class => :'Bizflow::DataModel::Action'
+
+      def human_name
+      	name.humanize
+      end
+
+      def head
+        heads.first
+      end
+
+      def current
+        head.action
+      end
+
+    end
+
+  end
+
+end
+

data/lib/bizflow/data_model/process_blueprint.rb

@@ -0,0 +1,17 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class ProcessBlueprint < Sequel::Model
+
+      one_to_many :processes
+      one_to_many :action_blueprints
+
+    end
+
+  end
+
+end
+

data/lib/bizflow/data_model/task.rb

@@ -0,0 +1,17 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class Task < Sequel::Model
+
+      many_to_one :action
+      many_to_one :task_blueprint
+
+    end
+
+  end
+
+end
+

data/lib/bizflow/data_model/task_blueprint.rb

@@ -0,0 +1,17 @@
+require 'sequel'
+
+module Bizflow
+
+  module DataModel
+
+    class TaskBlueprint < Sequel::Model
+
+      one_to_many :tasks
+      many_to_one :action_blueprint
+
+    end
+
+  end
+
+end
+

data/lib/bizflow/fakes/action.rb

@@ -0,0 +1,23 @@
+require_relative 'task'
+
+module Bizflow
+  module Fakes
+    class Action
+
+      attr_accessor :name, :type, :process, :next_actions, :tasks, :handlers, :action_blueprint
+
+      def initialize(process, action_blueprint, name, type)
+        @process = process
+        @action_blueprint = action_blueprint
+        @name = name
+        @type = type
+        @tasks = []
+      end
+
+      def add_task(hash)
+        tasks << Bizflow::Fakes::Task.new(self, hash[:name], hash[:description])
+      end
+
+    end
+  end
+end

data/lib/bizflow/fakes/action_blueprint.rb

@@ -0,0 +1,24 @@
+require_relative 'task_blueprint'
+
+module Bizflow
+  module Fakes
+    class ActionBlueprint
+
+      attr_accessor :name, :type, :description, :process_blueprint, :task_blueprints, :handler_blueprints
+
+      def initialize(process_blueprint, name, type, description = nil, task_blueprints = [], handler_blueprints)
+        @process_blueprint = process_blueprint
+        @name = name
+        @type = type
+        @description = description
+        @task_blueprints = task_blueprints
+        @handler_blueprints = handler_blueprints
+      end
+
+      def add_task(hash)
+        task_blueprints << Bizflow::Fakes::TaskBlueprint.new(self, hash[:name], hash[:description])
+      end
+
+    end
+  end
+end

data/lib/bizflow/fakes/handler.rb

@@ -0,0 +1,15 @@
+module Bizflow
+  module Fakes
+    class Handler
+
+      attr_accessor :name, :namespace, :action, :finished
+
+      def initialize(action, name, namespace)
+        @action = action
+        @name = name
+        @namespace = namespace
+      end
+
+    end
+  end
+end

data/lib/bizflow/fakes/handler_blueprint.rb

@@ -0,0 +1,18 @@
+require_relative 'task_blueprint'
+
+module Bizflow
+  module Fakes
+    class HandlerBlueprint
+
+      attr_accessor :name, :namespace, :description, :action_blueprint
+
+      def initialize(action_blueprint, name, namespace, description = nil)
+        @action_blueprint = action_blueprint
+        @name = name
+        @namespace = namespace
+        @description = description
+      end
+
+    end
+  end
+end

data/lib/bizflow/fakes/head.rb

@@ -0,0 +1,14 @@
+module Bizflow
+  module Fakes
+    class Head
+
+      attr_accessor :process, :action
+
+      def initialize(process, action = nil)
+        @process = process
+        @actions = [action]
+      end
+
+    end
+  end
+end

data/lib/bizflow/fakes/process.rb

@@ -0,0 +1,20 @@
+module Bizflow
+  module Fakes
+    class Process
+
+      attr_accessor :name, :description, :actions, :heads, :start
+
+      def initialize(name, description = nil)
+        @name = name
+        @description = description
+        @heads = []
+        @actions = []
+      end
+
+      def update(*args)
+
+      end
+
+    end
+  end
+end

data/lib/bizflow/fakes/process_blueprint.rb

@@ -0,0 +1,14 @@
+module Bizflow
+  module Fakes
+    class Process
+
+      attr_accessor :name, :description
+
+      def initialize(name, description = nil)
+        @name = name
+        @description = description
+      end
+
+    end
+  end
+end

data/lib/bizflow/fakes/task.rb

@@ -0,0 +1,16 @@
+module Bizflow
+  module Fakes
+    class Task
+
+      attr_accessor :name, :description, :action, :assignee_id, :auto_assign
+
+      def initialize(action, name, auto_assign = false, description = nil)
+        @action = action
+        @name = name
+        @description = description
+        @auto_assign = auto_assign
+      end
+
+    end
+  end  
+end

data/lib/bizflow/fakes/task_blueprint.rb

@@ -0,0 +1,19 @@
+require_relative 'task_blueprint'
+
+module Bizflow
+  module Fakes
+    class TaskBlueprint
+
+      attr_accessor :name, :roles, :description, :auto_assign, :action_blueprint
+
+      def initialize(action_blueprint, name, roles, description = nil, auto_assign = nil)
+        @action_blueprint = action_blueprint
+        @name = name
+        @roles = roles
+        @description = description
+        @auto_assign = auto_assign || false
+      end
+
+    end
+  end
+end

data/lib/bizflow/interpreters/domain_interpreter.rb

@@ -0,0 +1,19 @@
+require "bizflow/interpreters/process_interpreter"
+
+
+class Bizflow::DomainInterpreter
+
+  attr_accessor :repo, :process_interpreter
+
+  def initialize(repo)
+    @repo = repo
+  end
+
+  def process(name, &action)
+    process_interpreter = Bizflow::ProcessInterpreter.new(name)
+    process_interpreter.instance_eval(&action)
+    repo.add_process(process_interpreter.process)
+  end
+
+
+end

data/lib/bizflow/interpreters/input_action_interpreter.rb

@@ -0,0 +1,35 @@
+
+require "bizflow/semantic_model/input_action"
+require "bizflow/semantic_model/handler"
+
+class Bizflow::InputActionInterpreter
+
+  attr_accessor :action
+
+  def initialize(name)
+    @action = Bizflow::SemanticModel::InputAction.new(name)
+  end
+
+  def description(description)
+    action.description = description
+  end
+
+  def handler(name, options = {})
+    raise "handler for action already defined" if action.handler
+    action.handler = Bizflow::SemanticModel::Handler.new(name, options)
+  end
+
+  def next_actions(actions_hash)
+    raise "next actions already defined" if !action.next_actions.empty?
+    action.next_actions = actions_hash
+  end
+
+  def question(question)
+    action.question = question
+  end
+
+  def roles(roles_array)
+
+  end
+
+end

data/lib/bizflow/interpreters/process_interpreter.rb

@@ -0,0 +1,37 @@
+require "bizflow/interpreters/task_action_interpreter"
+require "bizflow/interpreters/input_action_interpreter"
+require "bizflow/semantic_model/process"
+
+class Bizflow::ProcessInterpreter
+
+  attr_accessor :process, :task_action_interpreter, :input_action_interpreter
+
+  def initialize(process_name)
+    @process = Bizflow::SemanticModel::Process.new(process_name)
+  end
+
+  def input_action(name, &action)
+    input_action_interpreter = Bizflow::InputActionInterpreter.new(name)
+    input_action_interpreter.instance_eval(&action)
+    process.add_action(input_action_interpreter.action)
+  end
+
+  def task_action(name, &action)
+    task_action_interpreter = Bizflow::TaskActionInterpreter.new(name)
+    task_action_interpreter.instance_eval(&action)
+    process.add_action(task_action_interpreter.action)
+  end
+
+  def handler_action(name, &action)
+
+  end
+
+  def description(description)
+    process.description = description
+  end
+
+  def start(action_name)
+    process.start = action_name
+  end
+
+end

data/lib/bizflow/interpreters/task_action_interpreter.rb

@@ -0,0 +1,29 @@
+
+require "bizflow/semantic_model/task_action"
+require "bizflow/semantic_model/task"
+
+class Bizflow::TaskActionInterpreter
+
+  attr_accessor :action
+
+  def initialize(name)
+    @action = Bizflow::SemanticModel::TaskAction.new(name)
+  end
+
+  def next_action(name)
+    action.next_action = name
+  end
+
+  def description(description)
+    action.description = description
+  end
+
+  def task(name, options)
+    action.add_task(Bizflow::SemanticModel::Task.new(name, options))
+  end
+
+  def input_task(name, options)
+    task(name, options)
+  end
+
+end

data/lib/bizflow/lib/blueprint_builder.rb

@@ -0,0 +1,90 @@
+require 'bizflow/data_model/process_blueprint'
+require 'bizflow/data_model/action_blueprint'
+require 'bizflow/data_model/task_blueprint'
+require 'bizflow/data_model/next_action_blueprint'
+
+module Bizflow
+  module Lib
+    class BlueprintBuilder
+
+      def build(semantic_repo)
+
+        semantic_repo.processes.each do |p|
+
+          # processes
+
+        	process = Bizflow::DataModel::ProcessBlueprint.create(
+        		name: p.name,
+        		description: p.description,
+						start: p.start
+      		)
+
+          p.actions.each do |a|
+
+            # actions
+
+            action = process.add_action_blueprint(
+              name: a.name,
+              type: a.type,
+              description: a.description,
+              question: a.question
+            )
+
+            # tasks
+
+            a.tasks.each do |t|
+              action.add_task_blueprint(
+                name: t.name,
+                roles: t.roles.join(" "),
+                description: t.description
+              )
+            end
+
+          end
+
+          data_actions = process.action_blueprints
+
+          # next_actions
+
+          p.actions.each do |a|
+
+            a.next_actions.each do |k, v|
+
+              ending = nil
+              ending = k.to_s if k != :only_one
+
+              current_action = data_actions.select { |acc| acc.name == a.name }.first
+              next_action = data_actions.select { |acc| acc.name == v }.first
+
+              Bizflow::DataModel::NextActionBlueprint.create(
+                action_blueprint: current_action,
+                next_blueprint: next_action,
+                ending: ending
+              )
+
+            end
+
+          end
+
+        end
+
+      end
+
+      private
+
+      def handle_next_blueprints(action)
+        res = []
+        if action.type == "task"
+          res = Bizflow::DataModel::NextActionBlueprint.new()
+        elsif action.type == "input"
+
+        else
+
+        end
+
+
+      end
+
+    end
+  end
+end

data/lib/bizflow/lib/callback_handler.rb

@@ -0,0 +1,27 @@
+module Bizflow
+  module Lib
+    class CallbackHandler
+
+      attr_accessor :callbacks
+
+      def initialize
+        @callbacks = {}
+      end
+
+      def method_missing(name, *args, &block)
+        raise "Callback #{name} registered more times" if @callbacks[name.to_sym]
+        @callbacks[name.to_sym] = block
+      end
+
+      def callback(name, *args)
+        raise "Callback '#{name}' not registered" unless @callbacks[name.to_sym]
+        @callbacks[name.to_sym].call(args[0])
+      end
+
+      def clear
+        @callbacks.clear()
+      end
+
+    end
+  end
+end

data/lib/bizflow/lib/callbackable.rb

@@ -0,0 +1,25 @@
+require 'bizflow/lib/callback_handler'
+
+module Bizflow
+  module Lib
+    module Callbackable
+
+      private
+
+      def setup_callbacks
+        raise "business method needs a block" unless block_given?
+        callback_handler.clear()
+        yield(callback_handler)
+      end
+
+      def callback(name, *args)
+        @callback_handler.callback(name, args[0])
+      end
+
+      def callback_handler
+        @callback_handler ||= Bizflow::Lib::CallbackHandler.new
+      end
+
+    end
+  end
+end

data/lib/bizflow/lib/process_builder.rb

@@ -0,0 +1,61 @@
+require 'bizflow/business_model/process'
+require 'securerandom'
+
+
+module Bizflow
+  module Lib
+    class ProcessBuilder
+
+      PID_LENGTH = 9
+
+      def build(blueprint_id, creator_id)
+
+        pbp = Bizflow::DataModel::ProcessBlueprint[blueprint_id]
+        raise "no process with id '#{blueprint_id}'" unless pbp
+
+        actions_map = {}
+
+        bp = Bizflow::DataModel::ProcessBlueprint.where(id: blueprint_id).eager(:action_blueprints => [:next_action_blueprints]).all.first
+        process = bp.add_process(
+          name: bp.name,
+          creator_id: creator_id,
+          description: bp.description,
+          pid: (SecureRandom.random_number * 10**PID_LENGTH).to_i)
+
+        bp.action_blueprints.each do |a|
+
+          action = Bizflow::DataModel::Action.create(
+            name: a.name,
+            type: a.type,
+            process: process,
+            description: a.description,
+            question: a.question,
+            action_blueprint_id: a.id)
+          
+          actions_map[a.name] = action.id
+
+          process.update(start_action_id: action.id) if bp.start == a.name
+
+        end
+
+        bp.action_blueprints.each do |abp|
+
+          abp.next_action_blueprints.each do |nbp|
+            acc = Bizflow::DataModel::NextAction.create(
+              action_id: actions_map[nbp.action_blueprint.name],
+              next_id: nbp.next_blueprint ? actions_map[nbp.next_blueprint.name] : nil,
+              ending: nbp.ending
+            )
+
+          end
+
+        end
+
+        process.add_head({})
+
+        Bizflow::BusinessModel::Process.wrap(process)
+      end
+
+    end
+  end
+end