rules_engine 0.0.1 → 0.0.3

data/rails_generators/templates/app/helpers/re_pipeline_helper.rb

@@ -1,20 +1,5 @@
 module RePipelineHelper
 
-  def javascript_alert_messages
-    unless flash[:error].blank?  
-      flash.delete(:success)
-      flash.delete(:notice)
-      return "$.error_message('" + escape_javascript(flash.delete(:error)) + "');"
-    end
-    unless flash[:success].blank?
-      flash.delete(:notice)
-      return "$.success_message('" + escape_javascript(flash.delete(:success)) + "');"
-    end      
-    unless flash[:notice].blank?
-      return "$.notice_message('" + escape_javascript(flash.delete(:notice)) + "');"
-    end    
-  end  
-
   def re_pipeline_status re_pipeline
     case re_pipeline.changed_status
     when RePipelineBase::CHANGED_STATUS_DRAFT

data/rails_generators/templates/app/models/re_job.rb

@@ -3,120 +3,113 @@ class ReJob < ActiveRecord::Base
   JOB_STATUS_NONE = 0
   JOB_STATUS_RUNNING = 1
   JOB_STATUS_SUCCESS = 2
-  JOB_STATUS_FAILED = 3
-  
-  
+  JOB_STATUS_FAILURE = 3
+    
   has_many :re_job_audits
   
   validates_presence_of :job_status
-  
-  
-  def self.find_jobs_by_pipeline re_pipeline_id, options = {}
+
+  def self.find_jobs options = {}
     sql_count = <<-END_OF_STRING    
         SELECT COUNT(rej.id) AS total
         FROM re_jobs rej 
-        WHERE rej.id IN ( 
-          SELECT rejas.re_job_id
-            FROM re_job_audits rejas 
-            WHERE rejas.audit_code = #{ReJobAudit::AUDIT_PIPELINE_START} 
-            AND rejas.re_pipeline_id = #{re_pipeline_id}
-        )    
+        WHERE rej.job_status != #{ReJob::JOB_STATUS_NONE}
     END_OF_STRING
                                   
     total_entries = find_by_sql(sql_count).first.total
                                   
-    paginate re_pipeline_id, options.reverse_merge(:finder => 'find_jobs_by_pipeline_paginate', :offset => 0, :limit => 20, :total_entries => total_entries)
+    paginate options.reverse_merge(:finder => 'find_jobs_paginate', :page => 0, :per_page => 20, :total_entries => total_entries)
   end
   
-  def self.find_jobs_by_pipeline_paginate re_pipeline_id, options = {:offset=>0, :limit=>100}
+  def self.find_jobs_paginate options = {:offset=>0, :limit=>100}
     sql_select = <<-END_OF_STRING    
         SELECT  rej.id AS job_id, 
                 rej.job_status AS job_status,
-                rej.created_at AS job_date
+                rej.created_at AS job_date                
         FROM re_jobs rej 
-        WHERE rej.id IN ( 
-          SELECT rejas.re_job_id
-            FROM re_job_audits rejas 
-            WHERE rejas.audit_code = #{ReJobAudit::AUDIT_PIPELINE_START} 
-            AND rejas.re_pipeline_id = #{re_pipeline_id}
-        )    
-        ORDER BY job_date DESC    
+        WHERE rej.job_status != #{ReJob::JOB_STATUS_NONE}
+        ORDER BY job_id DESC
     END_OF_STRING
     
     query = add_limit!(sql_select, :offset => options[:offset], :limit=>options[:limit])
       
     ActiveRecord::Base.connection.select_all(query).map do | result |
-
-      job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ? AND audit_code = ? AND re_pipeline_id = ?", result['job_id'], ReJobAudit::AUDIT_PIPELINE_START, re_pipeline_id], :order => "audit_date ASC", :limit => 1).first
-      result.merge!({
-        'start_date' => job_audit.audit_date,
-        'start_data' => job_audit.audit_data, 
-        'start_success' => job_audit.audit_success
-      })
-
-      job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ? AND audit_code = ? AND re_pipeline_id = ?", result['job_id'], ReJobAudit::AUDIT_PIPELINE_END, re_pipeline_id], :order => "audit_date ASC", :limit => 1).first
-      if (job_audit)
+      job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ?", result['job_id']], :order => "audit_date ASC", :limit => 1).first
+      if job_audit
         result.merge!({
-          'end_date' => job_audit.audit_date,
-          'end_data' => job_audit.audit_data, 
-          'end_success' => job_audit.audit_success
+          'start_date' => job_audit.audit_date,
+          'start_data' => job_audit.audit_message, 
         })
+      end  
+      
+      if result['job_status'].to_i != ReJob::JOB_STATUS_RUNNING
+        job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ?", result['job_id']], :order => "audit_date DESC", :limit => 1).first
+        if job_audit
+          result.merge!({
+            'end_date' => job_audit.audit_date,
+            'end_data' => job_audit.audit_message, 
+            })
+        end    
       end
-
+  
       result
     end
   end
-
-  def self.find_jobs options = {}
+  
+  
+  def self.find_jobs_by_pipeline re_pipeline_id, options = {}
     sql_count = <<-END_OF_STRING    
         SELECT COUNT(rej.id) AS total
         FROM re_jobs rej 
-        WHERE rej.id IN ( 
+        WHERE rej.job_status != #{ReJob::JOB_STATUS_NONE}
+        AND rej.id IN ( 
           SELECT rejas.re_job_id
             FROM re_job_audits rejas 
-            WHERE rejas.audit_code = #{ReJobAudit::AUDIT_PIPELINE_START} 
-        )            
+            WHERE rejas.re_pipeline_id = #{re_pipeline_id}
+        )    
     END_OF_STRING
                                   
     total_entries = find_by_sql(sql_count).first.total
                                   
-    paginate options.reverse_merge(:finder => 'find_jobs_paginate', :page => 0, :per_page => 20, :total_entries => total_entries)
+    paginate re_pipeline_id, options.reverse_merge(:finder => 'find_jobs_by_pipeline_paginate', :offset => 0, :limit => 20, :total_entries => total_entries)
   end
   
-  def self.find_jobs_paginate options = {:offset=>0, :limit=>100}
+  def self.find_jobs_by_pipeline_paginate re_pipeline_id, options = {:offset=>0, :limit=>100}
     sql_select = <<-END_OF_STRING    
         SELECT  rej.id AS job_id, 
                 rej.job_status AS job_status,
-                rej.created_at AS job_date                
+                rej.created_at AS job_date
         FROM re_jobs rej 
-        WHERE rej.id IN ( 
+        WHERE rej.job_status != #{ReJob::JOB_STATUS_NONE}
+        AND rej.id IN ( 
           SELECT rejas.re_job_id
-            FROM re_job_audits rejas 
-            WHERE rejas.audit_code = #{ReJobAudit::AUDIT_PIPELINE_START} 
+            FROM re_job_audits rejas
+            WHERE rejas.re_pipeline_id = #{re_pipeline_id}
         )    
-        ORDER BY job_date DESC    
+        ORDER BY job_id DESC
     END_OF_STRING
     
     query = add_limit!(sql_select, :offset => options[:offset], :limit=>options[:limit])
       
     ActiveRecord::Base.connection.select_all(query).map do | result |
-
-      job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ? AND audit_code = ?", result['job_id'], ReJobAudit::AUDIT_PIPELINE_START], :order => "audit_date ASC", :limit => 1).first
-      result.merge!({
-        'start_date' => job_audit.audit_date,
-        'start_data' => job_audit.audit_data, 
-        'start_success' => job_audit.audit_success
-      })
-
-      job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ? AND audit_code = ?", result['job_id'], ReJobAudit::AUDIT_PIPELINE_END], :order => "audit_date DESC", :limit => 1).first
-      if (job_audit)
+      
+      job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ? AND re_pipeline_id = ?", result['job_id'], re_pipeline_id], :order => "audit_date ASC", :limit => 1).first
+      if job_audit
         result.merge!({
-          'end_date' => job_audit.audit_date,
-          'end_data' => job_audit.audit_data, 
-          'end_success' => job_audit.audit_success
+          'start_date' => job_audit.audit_date,
+          'start_data' => job_audit.audit_message, 
         })
-      end
+      end  
 
+      if result['job_status'].to_i != ReJob::JOB_STATUS_RUNNING
+        job_audit = ReJobAudit.find(:all, :conditions => ["re_job_id = ? AND re_pipeline_id = ?", result['job_id'], re_pipeline_id], :order => "audit_date DESC", :limit => 1).first
+        if job_audit
+          result.merge!({
+            'end_date' => job_audit.audit_date,
+            'end_data' => job_audit.audit_message, 
+          })
+        end
+      end  
       result
     end
   end

data/rails_generators/templates/app/models/re_job_audit.rb

@@ -1,11 +1,8 @@
 class ReJobAudit < ActiveRecord::Base
 
-  AUDIT_PIPELINE_START  = 1
-  AUDIT_PIPELINE_END =    2
-  AUDIT_PIPELINE_INFO =   3
-  AUDIT_RULE_START  =     4
-  AUDIT_RULE_END =        5
-  AUDIT_RULE_INFO =       6
+  AUDIT_INFO  =     0
+  AUDIT_SUCCESS =   1
+  AUDIT_FAILURE =   2
   
   belongs_to :re_job
   belongs_to :re_pipeline
@@ -13,7 +10,6 @@ class ReJobAudit < ActiveRecord::Base
   
   validates_presence_of :audit_date
   validates_presence_of :audit_code
-  # validates_presence_of :audit_success
     
   named_scope :by_re_job_id, lambda {|re_job_id| {:conditions => ['re_job_id = ?', re_job_id]} }
   named_scope :order_date, lambda {|order| {:order => "audit_date #{order}"} }

data/rails_generators/templates/app/models/re_pipeline.rb

@@ -5,8 +5,6 @@ class RePipeline < RePipelineBase
 
   has_many :re_job_audits
   
-  # before_save :reset_activated_status, :reset_changed_status
-
   def activate!
     self.activated_re_pipeline ||= RePipelineActivated.new
     activated_re_pipeline.copy! self
@@ -20,7 +18,6 @@ class RePipeline < RePipelineBase
   def deactivate!
    self.activated_re_pipeline.destroy unless activated_re_pipeline.nil?          
    self.activated_re_pipeline = nil
-   self.activated_status = RePipelineBase::ACTIVATED_STATUS_DRAFT
    save
   end  
 
@@ -41,29 +38,10 @@ class RePipeline < RePipelineBase
   def changed_status
     if self.activated_re_pipeline.nil?
       RePipelineBase::CHANGED_STATUS_DRAFT
-    elsif !equals?(self.activated_re_pipeline) 
+    elsif !self.equals?(self.activated_re_pipeline) 
       RePipelineBase::CHANGED_STATUS_CHANGED
     else
       RePipelineBase::CHANGED_STATUS_CURRENT
     end
   end    
-    
-  # private
-  #   def reset_activated_status
-  #     if self.activated_re_pipeline.nil?
-  #       self.activated_status = RePipelineBase::ACTIVATED_STATUS_DRAFT
-  #     else 
-  #       self.activated_status = RePipelineBase::ACTIVATED_STATUS_ACTIVE
-  #     end  
-  #   end
-  # 
-  #   def reset_changed_status
-  #     if self.activated_re_pipeline.nil?
-  #       self.changed_status = RePipelineBase::CHANGED_STATUS_DRAFT
-  #     elsif !equals?(self.activated_re_pipeline) 
-  #       self.changed_status = RePipelineBase::CHANGED_STATUS_CHANGED
-  #     else
-  #       self.changed_status = RePipelineBase::CHANGED_STATUS_CURRENT
-  #     end
-  #   end    
 end

data/rails_generators/templates/app/models/re_pipeline_activated.rb

@@ -4,6 +4,7 @@ class RePipelineActivated < RePipelineBase
   def self.find_by_code(code)
     return find_by_code_without_caching(code) unless RulesEngine::Cache.perform_caching?
 
+    code.gsub!(/[^a-zA-Z0-9]+/i, '_')
     re_pipeline = RulesEngine::Cache.cache_store.read("activated_pipeline_#{code}")
     if (re_pipeline.nil?)
       re_pipeline = find_by_code_without_caching(code)
@@ -20,6 +21,8 @@ class RePipelineActivated < RePipelineBase
 
   def self.reset_cache(code)
     return unless RulesEngine::Cache.perform_caching?
+
+    code.gsub!(/[^a-zA-Z0-9]+/i, '_')
     RulesEngine::Cache.cache_store.delete("activated_pipeline_#{code}")
   end
 

data/rails_generators/templates/app/models/re_pipeline_activated_observer.rb

@@ -1,11 +1,11 @@
 class RePipelineActivatedObserver < ActiveRecord::Observer
 
-  def after_update(record)        
-    RePipelineActivated.reset_cache(record.code)
-  end
-
   def after_create(record)    
     RePipelineActivated.reset_cache(record.code)
   end
   
+  def after_update(record)        
+    RePipelineActivated.reset_cache(record.code)
+  end
+
 end

data/rails_generators/templates/app/models/re_pipeline_base.rb

@@ -18,7 +18,7 @@ class RePipelineBase < ActiveRecord::Base
   named_scope :order_title, :order => 're_pipelines.title ASC'
 
   def code=(new_code)
-    self[:code] = new_code.downcase if new_code && new_record?
+    self[:code] = new_code.downcase.gsub(/[^a-zA-Z0-9]+/i, '_') if new_code && new_record?
   end
   
   def copy! re_pipeline
@@ -50,12 +50,12 @@ class RePipelineBase < ActiveRecord::Base
     true
   end
   
-  def verify
+  def pipeline_error
     return 'rules required' if re_rules.empty?
     
-    re_rules.each do |rule|
-      result = rule.verify
-      return result unless result.blank?
+    re_rules.each do |re_rule|
+      error = re_rule.rule_error
+      return error unless error.blank?
     end
     
     nil

data/rails_generators/templates/app/models/re_rule.rb

@@ -2,18 +2,26 @@ class ReRule < ActiveRecord::Base
   belongs_to :re_pipeline
   acts_as_list :scope => :re_pipeline
 
-  has_many  :re_rule_outcomes, :dependent => :destroy, :order => "outcome ASC"
+  has_many  :re_rule_expected_outcomes, :dependent => :destroy, :order => "outcome ASC"
   has_many  :re_job_audits
     
   validates_associated  :re_pipeline
-  validates_presence_of :title
-  validates_presence_of :rule_class
-  validates_presence_of :summary
-  validates_presence_of :data_version
-  validates_presence_of :data
+  validates_presence_of :rule_class_name
 
   default_scope :order => 're_rules.position ASC'
   
+  before_save :before_save_rule
+  after_create :after_create_rule
+  before_destroy :before_destroy_rule
+
+  def validate
+    if self.rule.nil?
+      errors.add("rule_class", "not found") 
+    elsif !self.rule.valid?
+      errors.add(self.rule_class_name, "not valid") 
+    end
+  end
+    
   def copy! re_rule
     activated_attrs = re_rule.attributes
     ignore_attributes.each{|key| activated_attrs.delete(key)}
@@ -22,7 +30,7 @@ class ReRule < ActiveRecord::Base
       self[key] = value
     end
     
-    self.re_rule_outcomes = re_rule.re_rule_outcomes.map { |rule_outcome| ReRuleOutcome.new.copy!(rule_outcome) }
+    self.re_rule_expected_outcomes = re_rule.re_rule_expected_outcomes.map { |rule_expected_outcome| ReRuleExpectedOutcome.new.copy!(rule_expected_outcome) }
     
     self
   end
@@ -35,39 +43,78 @@ class ReRule < ActiveRecord::Base
       return false unless self[key] == value
     end
     
-    return false unless self.re_rule_outcomes.length == re_rule.re_rule_outcomes.length
-    self.re_rule_outcomes.each_with_index do |rule_outcome, index|
-      return false unless rule_outcome.equals?(re_rule.re_rule_outcomes[index])
+    return false unless self.re_rule_expected_outcomes.length == re_rule.re_rule_expected_outcomes.length
+    self.re_rule_expected_outcomes.each_with_index do |rule_expected_outcome, index|
+      return false unless rule_expected_outcome.equals?(re_rule.re_rule_expected_outcomes[index])
     end
     
     true
   end
 
-  def verify
-    return self.error unless self.error.blank?
+  def rule
+    return @rule unless @rule.nil?
+    rule_class = RulesEngine::Discovery.rule_class(self.rule_class_name)
+    return nil if rule_class.nil?
+    @rule = rule_class.new
+    @rule.data = self.data
+    @rule
+  end
+  
+  def rule_attributes=params
+    raise 'rule class not found' if rule.nil?
+    rule.attributes = params
+  end
+
+  def before_save_rule
+    raise 'rule class not found' if rule.nil?
+    self.title = rule.title
+    self.summary = rule.summary
+    self.data = rule.data
+    
+    self.re_rule_expected_outcomes = (rule.expected_outcomes).map { |expected_outcome| ReRuleExpectedOutcome.new(expected_outcome) }
+  end
+
+  def after_create_rule
+    # raise 'rule class not found' if rule.nil?
+    rule.after_add_to_pipeline(self.re_pipeline_id, self.id)
+  end
+
+  def before_destroy_rule
+    # raise 'rule class not found' if rule.nil?
+    rule.before_remove_from_pipeline(self.re_pipeline_id, self.id)
+  end
 
-    self.re_rule_outcomes.each do |rule_outcome|
-      result = rule_outcome.verify
-      return result unless result.blank?
+  def rule_error
+    return "#{title} class #{rule_class_name} invalid" if rule.nil?
+    return "#{title} invalid" unless rule.valid?
+
+    re_rule_expected_outcomes.each do |re_rule_expected_outcome|
+      next if re_rule_expected_outcome.pipeline_code.blank?      
+
+      re_pipeline_activated = RePipelineActivated.find_by_code(re_rule_expected_outcome.pipeline_code)
+      return "#{re_rule_expected_outcome.pipeline_code} not activated" if re_pipeline_activated.nil?
+      
+      pipeline_error = re_pipeline_activated.pipeline_error
+      return "#{re_rule_expected_outcome.pipeline_code} invalid" unless re_pipeline_activated.pipeline_error.blank?
     end
     
     nil
   end
-
-  def re_rule_outcome_next
-    re_rule_outcomes.detect{ |re_rule_outcome| re_rule_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_NEXT }
+  
+  def re_rule_expected_outcome_next
+    re_rule_expected_outcomes.detect{ |re_rule_expected_outcome| re_rule_expected_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_NEXT }
   end
   
-  def re_rule_outcome_success
-    re_rule_outcomes.detect{ |re_rule_outcome| re_rule_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS }
+  def re_rule_expected_outcome_success
+    re_rule_expected_outcomes.detect{ |re_rule_expected_outcome| re_rule_expected_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS }
   end
 
-  def re_rule_outcome_failure
-    re_rule_outcomes.detect{ |re_rule_outcome| re_rule_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE }
+  def re_rule_expected_outcome_failure
+    re_rule_expected_outcomes.detect{ |re_rule_expected_outcome| re_rule_expected_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE }
   end
 
-  def re_rule_outcomes_start_pipeline
-    re_rule_outcomes.select{ |re_rule_outcome| re_rule_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE }
+  def re_rule_expected_outcomes_start_pipeline
+    re_rule_expected_outcomes.select{ |re_rule_expected_outcome| re_rule_expected_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE }
   end
 
   protected