erp_rules 3.0.0 → 3.0.1

data/app/models/customer_txn_context.rb

@@ -0,0 +1,11 @@
+class CustomerTxnContext < ActiveRecord::Base
+
+  has_one :base_txn_context, :as => :txn_context_record
+
+  def after_create
+    base_txn_context = BaseTxnContext.new
+    base_txn_context.txn_context_record  = self
+    base_txn_context.save
+  end
+
+end

data/app/models/environment_txn_context.rb

@@ -0,0 +1,11 @@
+class EnvironmentTxnContext < ActiveRecord::Base
+
+  has_one :base_txn_context, :as => :txn_context_record
+
+  def after_create
+    base_txn_context = BaseTxnContext.new
+    base_txn_context.txn_context_record  = self
+    base_txn_context.save
+  end
+
+end

data/app/models/search_txn_context.rb

@@ -0,0 +1,11 @@
+class SearchTxnContext < ActiveRecord::Base
+
+  has_one :base_txn_context, :as => :txn_context_record
+
+  def after_create
+    base_txn_context = BaseTxnContext.new
+    base_txn_context.txn_context_record  = self
+    base_txn_context.save
+  end
+
+end

data/lib/erp_rules/engine.rb

@@ -1,5 +1,19 @@
 module ErpRules
+  require "erp_base_erp_svcs"
   class Engine < Rails::Engine
     isolate_namespace ErpRules
+
+    ActiveSupport.on_load :active_record do
+      include ErpRules::Extensions::ActiveRecord::HasRuleContext
+      include ErpRules::Extensions::ActiveRecord::ActsAsBusinessRule
+      include ErpRules::Extensions::ActiveRecord::ActsAsSearchFilter
+    end
+
+    #TODO
+    #this will be removed once rails 3.2 adds the ability to set the order of engine loading
+    engine = self
+    config.to_prepare do
+      ErpBaseErpSvcs.register_compass_ae_engine(engine)
+    end
   end
 end

data/lib/erp_rules/extensions/active_record/acts_as_business_rule.rb

@@ -0,0 +1,30 @@
+module ErpRules
+  module Extensions
+    module ActiveRecord
+      module ActsAsBusinessRule
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def acts_as_business_rule
+            extend ActsAsBusinessRule::SingletonMethods
+            include ActsAsBusinessRule::InstanceMethods
+          end
+        end
+
+        module InstanceMethods
+          def is_match? ctx
+          end
+
+        end
+
+        module SingletonMethods
+          def get_matches! ctx
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/erp_rules/extensions/active_record/acts_as_search_filter.rb

@@ -0,0 +1,28 @@
+module ErpRules
+  module Extensions
+    module ActiveRecord
+      module ActsAsSearchFilter
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def acts_as_search_filter
+            extend ActsAsSearchFilter::SingletonMethods
+            include ActsAsSearchFilter::InstanceMethods
+          end
+        end
+
+        module InstanceMethods
+        end
+
+        module SingletonMethods
+          def get_search_filters ctx
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/erp_rules/extensions/active_record/has_rule_context.rb

@@ -0,0 +1,31 @@
+module ErpRules
+  module Extensions
+    module ActiveRecord
+    #this module will be mixed into models in order
+    #to construct their execution context
+      module HasRuleContext
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def has_rule_context
+            extend HasRuleContext::SingletonMethods
+            include HasRuleContext::InstanceMethods
+          end
+        end
+
+        module InstanceMethods
+
+          def get_context()
+            #self.find_by_internal_identifier(iid)
+            attributes
+          end
+        end
+
+        module SingletonMethods
+        end
+      end
+    end
+  end
+end

data/lib/erp_rules/extensions.rb

@@ -0,0 +1,3 @@
+require 'erp_rules/extensions/active_record/has_rule_context'
+require 'erp_rules/extensions/active_record/acts_as_business_rule'
+require 'erp_rules/extensions/active_record/acts_as_search_filter'

data/lib/erp_rules/rules_engine/context.rb

@@ -1,37 +1,65 @@
+require 'ostruct'
+
 module ErpRules
-	module RulesEngine
-		class Context
-		  attr_accessor :values_hash
+  module RulesEngine
+    ##
+    #OpenStruct is part of ruby stdlib
+    #This class adds methods to allow hash-like
+    #behavior
+    class Context < OpenStruct
+
+      def initialize(hash=nil)
+        if hash
+          hash.each do |k,v|
+            if v.class == Hash
+              result = ErpRules::RulesEngine::Context.new(v)
+              hash[k] = result
+            elsif v.class == Array
+              v.map! do |item|
+                #ostruct requires objects passed to it on the constructr
+                #to support #each
+                if item.is_a? Enumerable
+                  ErpRules::RulesEngine::Context.new(item)
+                else
+                  item
+                end
+              end
+              #end Array case
+            end
+          end
+        end
+        super(hash)
+      end
 
-		  def initialize
-			self.values_hash = {}
-		  end
+      def [](key)
+        send(key)
+      end
 
-		  def [](key)
-			self.values_hash[key]
-		  end
+      ##
+      #This will set a method on the struct
+      #using array syntax.
+      #Trying to set the argument in eval led to an error,
+      #hence the 'send' call following it.
+      def []=(key, *args)
+        arg = args[0]
+        eval("#{key} = nil", binding)
 
-		  def []=(key, *args)
-			self.values_hash[key] = args[0]
-		  end
+        if arg.class == Hash
+          send("#{key}=", ErpRules::RulesEngine::Context.new(arg))
+        else
+          send("#{key}=", arg)
+        end
+      end
 
-		  def method_missing(name, *args)
-			setter = nil
-			if(name.to_s.include?('='))
-			  name = name.to_s.split('=')[0]
-			  setter = true
-			  name = name.to_sym
-			end
+      #need this method in order to mimic []= behavior
+      #using the method/attr syntax of OpenStruct
+      def method_missing(mid, *args)
+        if args[0].class == Hash
+          args[0] = ErpRules::RulesEngine::Context.new(args[0])
+        end
+        super(mid, *args)
+      end
 
-			if setter
-			  self.values_hash[name] = args[0]
-			  return self
-			elsif self.values_hash.has_key?(name)
-			  return self.values_hash[name]
-			else
-			  super
-			end
-		  end
-		end
-	end
-end
+    end
+  end
+end

data/lib/erp_rules/rules_engine/context_builder.rb

@@ -0,0 +1,70 @@
+module ErpRules
+  module RulesEngine
+    class ContextBuilder
+
+      @facts = nil
+      @execution_context = nil
+
+      def initialize(facts)
+        @facts = facts
+      end
+
+      def build_execution_context(options={})
+        if options[:only].blank?
+          execution_context = {
+            :environment_context => self.environment_context(),
+            :search_context => self.search_context(),
+            :customer_context => self.customer_context()
+          }
+        else
+          execution_context = {}
+          options[:only].each do |context|
+            execution_context[context] = self.send(context)
+          end
+        end
+
+        ErpRules::RulesEngine::Context.new execution_context
+      end
+
+      def persist_context(txn_type, txn_sub_type)
+        unless @execution_context.nil?
+          search_txn = SearchTxn.new
+          search_txn.biz_txn_event = BizTxnEvent.new
+          search_txn.biz_txn_event.biz_txn_type = BizTxnType.find_by_type_and_subtype(txn_type,txn_sub_type)
+          search_txn.biz_txn_event.description = "#{txn_type} , #{txn_sub_type}"
+
+          build_and_save_context(SearchTxnContext, @execution_context[:search].to_json, search_txn.biz_txn_event) unless @execution_context[:search].nil?
+          build_and_save_context(CustomerTxnContext, @execution_context[:customer].to_json, search_txn.biz_txn_event) unless @execution_context[:customer].nil?
+          build_and_save_context(EnvironmentTxnContext, @execution_context[:environment].to_json, search_txn.biz_txn_event) unless @execution_context[:environment].nil?
+        end
+      end
+
+      def search_context()
+        logger.warn "ContextBuilder.search_context() is an abstract method"
+      end
+
+      def customer_context()
+      end
+
+      def environment_context()
+        env_txn_context = {
+          :time       => @facts[:time],
+          :user_agent => @facts[:user_agent],
+          :url        => @facts[:url],
+          :remote_ip  => @facts[:remote_ip]
+        }
+        env_txn_context
+      end
+
+      def build_and_save_context(context_klass, json, biz_txn_event)
+        txn_context = context_klass.new
+        txn_context.base_txn_context = BaseTxnContext.new
+        txn_context.base_txn_context.biz_txn_event = biz_txn_event
+        txn_context.context = json
+        txn_context.save
+      end
+
+    end
+  end
+end
+

data/lib/erp_rules/rules_engine/pricing_engine.rb

@@ -0,0 +1,18 @@
+module ErpRules
+  module RulesEngine
+    class PricingEngine
+
+      def initialize()
+      end
+
+      def price_products(execution_context)
+        execution_context[:product_context][:products].each do |product|
+          pricing_plan = PricingPlan.find_by_internal_identifier('default')
+          product[:price] = pricing_plan.get_price()
+        end
+
+        execution_context
+      end
+    end
+  end
+end

data/lib/erp_rules/rules_engine/ruleby/engine.rb

@@ -0,0 +1,24 @@
+require 'ruleby'
+module ErpRules
+  module RulesEngine
+    module Ruleby
+      #Adapter to invoke the Ruleby engine with a rulebook.
+      #Intended to be used with the RulesFacade class
+      class Engine
+        extend ::Ruleby
+
+        def self.invoke(rule_book, context)
+          engine :engine do |e|
+            rule_book.new(e).rules
+
+            e.assert context
+            e.match
+            e.retract context
+          end
+          context
+        end
+
+      end
+    end
+  end
+end

data/lib/erp_rules/rules_engine/rules_facade.rb

@@ -1,48 +1,48 @@
 module ErpRules
-	module RulesEngine
-	  class RulesFacade
+  module RulesEngine
+    class RulesFacade
 
-		# get the configured rule engine and invoke
-		def invoke(ruleset, context, rules_engine_klass)
-		  t_start= Time.new
-		  #get the directives
-		  directivesMap=context[:directives]
-		  # here we add in any global directives
-		  directivesMap=Hash.new if(directivesMap==nil)
-		  # suppress execution context return
-		  #(we do this for performance reasons since the execution ctx isnt altered
-		  directivesMap[:suppress_execution_context_return]=true
+      # get the configured rule engine and invoke
+      def invoke(ruleset, context, rules_engine_klass)
+        t_start= Time.new
+        #get the directives
+        directivesMap=context[:directives]
+        # here we add in any global directives
+        directivesMap=Hash.new if(directivesMap==nil)
+        # suppress execution context return
+        #(we do this for performance reasons since the execution ctx isnt altered
+        directivesMap[:suppress_execution_context_return]=true
 
-		  # add the directives map to the context
-		  context[:directives]=directivesMap;
-		  ## now we invoke the rule facade
-		  Rails.logger.debug("Invoking RulesFacade")
-		  Rails.logger.debug("Ruleset:#{ruleset}")
-		  Rails.logger.debug("context:#{context}")
-		  #get the name of the rule engine
-		  Rails.logger.debug("RULE CLASS : #{rules_engine_klass}")
+        # add the directives map to the context
+        context[:directives]=directivesMap;
+        ## now we invoke the rule facade
+        Rails.logger.debug("Invoking RulesFacade")
+        Rails.logger.debug("Ruleset:#{ruleset}")
+        Rails.logger.debug("context:#{context}")
+        #get the name of the rule engine
+        Rails.logger.debug("RULE CLASS : #{rules_engine_klass}")
 
-		  #we will use eval instead of Kernel.const_get since the rule engines
-		  # should be namespaced
-		  klass = (rules_engine_klass.is_a?(String)) ? eval(rules_engine_klass) : rules_engine_klass
-		  # create an instance of its singleton
-		  rule_engine = klass
-		  
-		  #invoke the rule engine
-		  result=rule_engine.invoke(ruleset,context)
-		  Rails.logger.debug("\n------------------------------------------------------------------------------------------")
-		  Rails.logger.debug("RULE ENGINE   :#{rule_engine}")
-		  Rails.logger.debug("\n------------------------------------------------------------------------------------------")
-		  Rails.logger.debug("INVOKE RESULTS:"+result.to_yaml)
-		  Rails.logger.debug("\n------------------------------------------------------------------------------------------")
-		
-		  Rails.logger.debug("\n------------------------------------------------------------------------------------------")
-		  t_end=Time.new
-		  Rails.logger.debug("Rule invocation time:#{(t_end.to_f-t_start.to_f)} sec")
-		  Rails.logger.debug("\n------------------------------------------------------------------------------------------")
+        #we will use eval instead of Kernel.const_get since the rule engines
+        # should be namespaced
+        klass = (rules_engine_klass.is_a?(String)) ? eval(rules_engine_klass) : rules_engine_klass
+        # create an instance of its singleton
+        rule_engine = klass
 
-		  result
-		end
-	  end
-	end
+        #invoke the rule engine
+        result=rule_engine.invoke(ruleset,context)
+        Rails.logger.debug("\n------------------------------------------------------------------------------------------")
+        Rails.logger.debug("RULE ENGINE   :#{rule_engine}")
+        Rails.logger.debug("\n------------------------------------------------------------------------------------------")
+        Rails.logger.debug("INVOKE RESULTS:"+result.to_yaml)
+        Rails.logger.debug("\n------------------------------------------------------------------------------------------")
+
+        Rails.logger.debug("\n------------------------------------------------------------------------------------------")
+        t_end=Time.new
+        Rails.logger.debug("Rule invocation time:#{(t_end.to_f-t_start.to_f)} sec")
+        Rails.logger.debug("\n------------------------------------------------------------------------------------------")
+
+        result
+      end
+    end
+  end
 end

data/lib/erp_rules/rules_engine.rb

@@ -1,2 +1,5 @@
 require 'erp_rules/rules_engine/context'
-require 'erp_rules/rules_engine/rules_facade'
+require 'erp_rules/rules_engine/rules_facade'
+require 'erp_rules/rules_engine/context_builder'
+require 'erp_rules/rules_engine/pricing_engine'
+require 'erp_rules/rules_engine/rules_facade'

data/lib/erp_rules/search/search_base.rb

@@ -0,0 +1,64 @@
+module ErpRules
+  module Search
+    class SearchBase
+
+      def search facts
+        return process_search_facts(facts)
+      end
+
+      #This is the vertical search method that will need to be implemented
+      #in the sub-class
+      def do_search ctx
+        raise "do_search needs to be implemented in the subclass"
+      end
+
+      #Perform any processing the facts passed by a search controller
+      def pre_process_facts facts
+        raise "pre_process_facts needs to be implemented in the subclass"
+      end
+
+      #This must return an object (class, hash, whatever) that is used by the
+      #rules engine as a sort of rule book.
+      def generate_rules ctx
+        raise "generate_rules must be implemented in the subclass"
+      end
+
+      def process_search_facts(facts, search_rules_klass, context_builder_klass=ErpRules::RulesEngine::ContextBuilder)
+
+        # breaking out Orange Lake search logic into a subclass
+        # this creates a requirement that this class be extended with a subclass containing pre_process_facts method
+        facts = pre_process_facts(facts)
+
+        # build the execution context for the rules engine
+        search_execution_context = create_search_execution_context(facts,
+                                                                   {:persistant => Constants::SEARCH_TXN_PERSISTANT,
+                                                                    :context_builder_klass => context_builder_klass})
+
+        ruleset = generate_rules ctx
+        #execute the reservation_search rules and get back some search filtering criteria
+        filters = ErpRules::RulesEngine::RulesFacade.new.invoke(ruleset, search_execution_context, search_rules_klass)
+
+        # breaking out Orange Lake search logic into a subclass
+        # this creates a requirement that this class be extended with a subclass containing vertical_search method
+        res_search_results, message = do_search(facts, filters)
+
+        return res_search_results, message
+      end
+
+      def create_search_execution_context(facts, options={})
+        options[:persistant] = false if options[:persistant].nil?
+
+        # Get execution context
+        context_builder   = options[:context_builder_klass].new(facts)
+        execution_context = context_builder.build_execution_context()
+
+        # If persistant, save to database
+        if options[:persistant]
+          context_builder.persist_context(self.class.to_s, facts[:search_params][:search_type])
+        end
+
+        return execution_context
+      end
+    end
+  end
+end

data/lib/erp_rules/version.rb

@@ -1,3 +1,9 @@
 module ErpRules
-  VERSION = "3.0.0"
+  module VERSION #:nodoc:
+    MAJOR = 3
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].compact.join('.')
+  end
 end

data/lib/erp_rules.rb

@@ -1,5 +1,11 @@
+require "erp_rules/version"
+require 'erp_rules/rules_engine/context_builder'
+require 'erp_rules/rules_engine/rules_facade'
+require 'erp_rules/rules_engine/ruleby/engine'
 require 'erp_rules/rules_engine'
+require "erp_rules/extensions"
 require "erp_rules/engine"
+require "erp_base_erp_svcs"
 
 module ErpRules
 end

data/spec/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,9 @@
+// This is a manifest file that'll be compiled into including all the files listed below.
+// Add new JavaScript/Coffee code in separate files in this directory and they'll automatically
+// be included in the compiled file accessible from http://example.com/assets/application.js
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *= require_self
+ *= require_tree . 
+*/

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    "application" %>
+  <%= javascript_include_tag "application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/spec/dummy/config/application.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require
+require "erp_rules"
+require "erp_tech_svcs"
+require "erp_base_erp_svcs"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # Activate observers that should always be running.
+    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable the asset pipeline
+    config.assets.enabled = true
+  end
+end
+

data/spec/dummy/config/boot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)