icentris-rules 0.9

data/app/models/pyr_rules/action.rb

@@ -0,0 +1,116 @@
+class PyrRules::Action
+  include Mongoid::Document
+
+  @@context_mapping_equivalencies ||= {}   # {:messaging_user => [:user, :tree_user, :contact] }
+
+  field :title, type: String  
+  field :type, type: String								# class name of handler
+  field :context_mapping, type: Hash, default: {}		# Map of actionNeed => ruleContextField {"actor:user"=>"actor:user"}
+  field :template, type: Hash, default: {} 			    # Map of templateName => templateValue { "email" => "hello {name}" }			
+
+  embedded_in :rule, inverse_of: :actions
+
+  before_save :set_default_mappings
+  
+  # An action is ready if all of it's needs are mapped
+  def ready?
+    needs.each do |field, type|
+      return false unless lookup_context_mapping(field,type)
+    end
+    true
+  end
+
+  def needs
+  	n = (type.constantize.configuration[:needs].dup rescue {}) || {}
+    class_lookup_cols = {}
+    n.each do |field,type|
+      if type == :class_lookup
+        klazz = self.lookup_context_mapping(field,:class_lookup)[0] rescue nil
+        class_lookup_cols.merge! PyrRules::Rule.get_columns(klazz.camelcase.constantize) if klazz
+      end
+    end
+    class_lookup_cols.each do |column, col_type|
+      n[column] = col_type
+    end
+    template_names.each do |name|
+      template_fields(name).each do |f|
+        n[f.to_sym] = :string
+      end
+    end
+    n
+  end
+
+  # What templates are defined for this Action's ActionHandler?
+  # This reads from template DSL inside of ActionHandler class
+  # Templates have to be defined through the DSL!!!
+  def template_configuration
+    (type.constantize.configuration[:templates] rescue {}) || {}
+  end
+
+
+  def template_names
+    template_configuration.keys rescue []
+  end
+
+  def template_body(template_name)
+    body = template[template_name.to_s]                      # First try to read from Mongo Document template Hash
+    body ||= template_configuration[template_name.to_sym]    # Not found, use the default configuration from the ActionHandler DSL
+  end
+
+  # Extract the template fields for the provided template
+  #
+  # eg: body = "Hello {name}"    -  the template field is :name
+  #
+  def template_fields(template_name)
+    body = template_body(template_name)
+    body.scan(/\{([^\s]*)\}/).flatten rescue []
+  end
+
+  # returns an array [field,type]
+  def lookup_context_mapping(field, type = "string")
+    context_mapping["#{field}:#{type}"].split(":") rescue nil  	
+  end
+
+  def set_default_mappings(rule_context = rule.context)
+    needs.each do |action_field, type|
+      puts "...Considering mapping for #{action_field}(#{type})"
+      rule_context.keys.each do |rule_field|
+        unless try_rule_mapping(rule_context,rule_field,rule_field,action_field,type)
+          try_rule_mapping(rule_context,rule_field,rule_field.split(".").last.to_sym,action_field,type)
+        end
+      end
+    end
+  end    
+
+  # A mapping equivalency is used to indicate two types can be mapped to each other, even though
+  #   they do not have the same exact name
+  def self.add_mapping_type_equivalency(target_type, equivalent_types)
+    @@context_mapping_equivalencies[target_type] = equivalent_types
+  end
+
+  def self.check_mapping_type?(action_type, rule_type)
+    return true if action_type == rule_type || action_type == "string"
+    equivalencies = @@context_mapping_equivalencies[action_type.to_sym]
+    if equivalencies && equivalencies.index(rule_type.to_sym)
+      return true
+    end
+    false
+  end
+
+
+  private
+    def try_rule_mapping(rule_context,rule_field,rule_field_check,action_field,type)
+      if rule_field_check == action_field
+        rule_type = rule_context[rule_field]
+        if rule_type && rule_type.to_sym == type.to_sym
+          # The name and type matched - make the default entry
+          puts "...Adding default mapping for #{action_field}(#{type} ==> #{rule_field}:#{type}"
+          context_mapping["#{action_field}:#{type}"] = "#{rule_field}:#{type}"
+          return true
+        end
+        return false
+      end
+    end
+
+
+end

data/app/models/pyr_rules/rule.rb

@@ -0,0 +1,201 @@
+require 'pyr_rules/action'
+
+
+class PyrRules::Rule
+  include Mongoid::Document
+  include Mongoid::Timestamps::Short # For c_at and u_at.
+  include Mongoid::Versioning
+  include PyrRules::ModelEventEmitter
+
+  before_save :set_updated_by
+
+  max_versions 25
+
+  field :name, type: String
+  field :description, type: String
+  field :events, type: Array, default: []
+  field :criteria, type: String
+  field :active, type: Boolean
+  field :updated_by, type: String
+  field :start_date, type: Time
+  field :end_date, type: Time
+
+  # These can programatically be used to populate the events 
+  field :event_inclusion_matcher, type: Regexp
+  field :event_exclusion_matcher, type: Regexp
+
+  embeds_many :actions, inverse_of: :rule #cascade_callbacks: true
+
+  accepts_nested_attributes_for :actions
+
+  validates :name, presence: true
+
+  # validates_each :events do |record, attr, event_list|
+  #   if event_list 
+  #     event_list.each do |e|
+  #       record.errors.add(attr, 'should be a valid event') unless PyrRules::RulesConfig.event e
+  #     end
+  #   end
+  # end
+
+  def ready?
+    return false unless actions
+    ! actions.collect{|a| a.ready?}.index false rescue false
+  end
+
+  def process_rule(event)
+    return unless check_criteria event
+    actions.each do |action|
+      begin
+        action_handler = action.type
+        klass = action_handler if action_handler.is_a? Class
+        #Module.const_get(action_handler) doesn't work for nested classes
+        #We can use String.constantize (ActiveSupport extension for string)
+        #or eval works for sure.
+        klass = action_handler.constantize rescue nil if action_handler.is_a? String  
+        klass.new(event, action).handle if klass
+      rescue Exception => e 
+        puts "\nERROR: Running action #{action.type} for rule #{name}: #{e.message}\n"
+        puts e.backtrace
+      end
+    end
+  end
+
+  
+  # Determine overall Rule-scoped context via intersection all event-scoped contexts
+  def context
+    rc = {}
+    return rc if events == nil || events.size == 0
+    events.each_with_index do |e,i|
+      ec = PyrRules::RulesConfig.event_config(e)[:context] rescue {}
+      if i == 0
+        rc.merge!(ec)  # start with the first event's context
+      else
+        rc.each do |field, metadata|
+          if ec[field] == nil
+            rc.delete field     # this event did not have the field, it cannot be in our interesected context
+          elsif ec[field] != rc[field]
+            rc.delete field     # this event had the field, but it was a different type, it cannot be in our intersected context
+          end
+        end
+      end
+    end
+    HashWithIndifferentAccess.new(rc)
+  end
+
+  def context_field_mapped?(field,type)
+    lookup = "#{field}:#{type}"
+    actions.each do |a|
+      return true if a.context_mapping.values.index lookup rescue false
+    end
+    false
+  end
+
+
+  def set_default_mappings
+      puts "Setting default action mappings"
+      rule_context = context   #  {:actor=>:user, :target=>:object, etc...}
+      actions.each do |a|
+        a.set_default_mappings(rule_context)
+      end
+  end
+
+  def self.rule_context(rule_event, extra_fields = {})
+    PyrRules::RuleContext.new rule_event, extra_fields
+  end
+
+  def check_criteria(rule_event)
+    return false unless events && events.index("#{rule_event[:klazz]}::#{rule_event[:action]}")
+    return true if criteria.blank?
+    result = eval criteria, PyrRules::Rule.rule_context(rule_event).get_binding
+    result
+  end
+
+  # called like : lookup_path("target")
+  #          or : lookup_path("target.user")
+  def lookup_path(path, sub_context = nil)
+    return context if (path.blank? || path == "/") && !sub_context   # Default for retrieving root context path
+    # path = "target.user"    parts[0]="target"  parts[1]="user"
+    parts = path.split(".")
+    if sub_context.nil?
+      if parts.first == "actor"
+        parts.shift
+        path=parts.join(".")
+        klazz = User
+        return lookup_path(path, User) unless path.blank?
+      elsif parts.first == "target"
+        parts.shift
+        path=parts.join(".")
+        cols = nil
+        # We need to get all the possible path values from all the input events
+        events.each do |event|
+          klazz = (event.split("::")[0...-1].join("::")).constantize
+          puts klazz
+          sub_cols = lookup_path(path, klazz)
+          puts sub_cols
+          cols ||= sub_cols
+          # This will perform an intersection across all the event fields 
+          cols.each do |k,v|
+            unless sub_cols[k]==v
+              puts "Removing due to intersection #{k}"
+              cols.delete k
+            end
+          end
+        end
+        puts "Returning"
+        puts cols
+        return cols
+      end
+    end
+    klazz ||= sub_context || self
+
+    cols = {}
+    if parts.length == 0
+      cols = get_columns(klazz)
+    else
+      puts "DBH: What is this use case?  I can't remember why I coded it?"
+      if klazz.respond_to? :reflect_on_all_associations
+        (klazz.reflect_on_all_associations(:has_one) +
+        klazz.reflect_on_all_associations(:belongs_to)).each do |assoc| 
+          if (assoc.name.to_s == parts.first)
+            parts.shift
+            path=parts.join(".")
+            klazz = assoc.klass
+            return lookup_path(path, klazz)
+          end
+        end
+      end
+    end
+    cols
+  end
+
+  def self.get_columns(klazz)
+    cols = {}
+    if klazz.respond_to? :reflect_on_all_associations
+      (klazz.reflect_on_all_associations(:has_one) +
+      klazz.reflect_on_all_associations(:belongs_to)).each do |assoc| 
+        cols[assoc.name] = assoc.name.to_sym
+      end
+    end
+    if klazz.respond_to? :columns   # ActiveRecord
+      klazz.columns.each{|c| cols[c.name] = c.type.to_sym }
+    end
+    if klazz.respond_to? :fields    # Mongoid
+      fields.each{|k,v| cols[v.name] = v.options[:type].name.downcase.to_sym }
+    end
+    cols
+  end
+
+  private
+    def set_updated_by
+      if Thread.current[:user]
+        self.updated_by = Thread.current[:user].try(:username)
+      end
+    end
+end
+
+
+
+
+
+

data/app/rules/pyr_rules/action_handler.rb

@@ -0,0 +1,94 @@
+  class PyrRules::ActionHandler
+    #
+    # needs is a map of required fields for each and every type of ActionHandler
+    #
+    @@needs ||= {}
+    @@action_configuration ||= {}
+    
+    @@templates ||= {}
+
+    def self.needs(name, type=:string)
+      @@needs[self] ||= {}
+      @@needs[self][name] = type
+    end
+
+    # def self.needs_map
+    #   @@needs[self]
+    # end
+
+    def self.template(name)
+      @@templates[self] ||= {}
+      @@templates[self][name] = (block_given?) ? yield : ""
+    end
+
+    def self.reload_configuration
+      puts "Reloading ActionHandler configuration"
+      @@action_configuration = {}
+      configuration
+      @@action_configuration.keys
+    end
+
+    # def self.templates
+    #   @@templates[self]
+    # end
+    def self.configuration
+      return @@action_configuration[self] unless @@action_configuration.empty?
+      #if Rails.env.development?
+          Dir["#{Rails.root}/../**/*/app/**/action_handler/*.rb"].each do |p| 
+            puts "require_dependency #{p}" 
+            require_dependency p
+          end
+      #end
+      _add_needs_and_recurse(PyrRules::ActionHandler)
+      @@action_configuration[self]
+    end
+
+    def self.action_listing
+      configuration # force load
+      @@action_configuration.keys
+    end
+
+    def self._add_needs_and_recurse(klazz)
+      klazz.subclasses.each do |c| 
+        @@action_configuration[c] ||= {}
+        @@action_configuration[c][:needs] = @@needs[c]
+        @@action_configuration[c][:templates] = @@templates[c]
+        _add_needs_and_recurse(c)
+      end
+    end
+
+    # Our context methods will be accessible through here
+    def method_missing(meth, *args, &block)
+      mapping_type = @action.needs[meth]
+      if mapping_type
+        rule_field = @action.lookup_context_mapping(meth, mapping_type)[0]
+        value = eval rule_field, @context.get_binding rescue nil
+        return value
+      end
+      super
+    end
+
+
+    attr_accessor :event, :action
+    def initialize(event, action)
+      @event = event
+      @action = action  # Allow use of symbols or strings as keys    target = event_hash[:klazz].constantize.find event_hash[:id].to_i rescue nil
+      @context = PyrRules::Rule.rule_context(@event)
+    end
+
+    def handle
+      puts "\n\n------- #{self.class.name} ------ \n\nHANDLE called for #{@event.inspect}  \n\n---- #{@action.inspect}\n\n"
+    end
+
+    def eval_template(template_name)
+      template_name = template_name.to_s
+      puts "DEBUG: Looking up #{template_name} from #{@action.template}"
+      t = @action.template_body(template_name)
+      interpolated_fields = @action.template_fields(template_name)
+      interpolated_fields.each do |f|
+        t.gsub!("{#{f}}","\#{#{f}}")
+      end
+      puts "DEBUG: Using #{t}"
+      eval '"' + t + '"'
+    end
+  end

data/app/rules/pyr_rules/controller_event_emitter.rb

@@ -0,0 +1,34 @@
+module PyrRules
+	module ControllerEventEmitter
+
+		@@registered_classes = []
+
+		def self.included(base)
+			#base.send :extend, ClassMethods
+			#unless ( File.basename($0) == "rake" && ARGV.include?("db:migrate") )
+			#end
+			base.around_filter :raise_controller_event
+			@@registered_classes << base if !@@registered_classes.index(base)
+		end
+
+		def self.registered_classes
+			@@registered_classes
+		end
+
+		private
+		  def raise_controller_event(extras = {})
+				action = params[:action]
+				payload = build_event_payload("ControllerEvent", self.class.name, action, extras)
+				ActiveSupport::Notifications.instrument("PyrRules_#{self.class.name}_#{action}", payload ) do 
+					yield
+				end
+		  end
+
+			def build_event_payload(event_type, class_name, action, extras={})
+					payload = { type: event_type, klazz: self.class.name, action: action, data: params, 
+								user: Thread.current[:user] }.merge(extras)
+			end
+
+
+	end
+end

data/app/rules/pyr_rules/email_action_handler.rb

@@ -0,0 +1,6 @@
+  class PyrRules::EmailActionHandler < PyrRules::ActionHandler
+    def handle
+      super
+      puts "This is in Pyr-Rules. It echos template -------  #{@action.template}"
+    end
+  end