rules_engine 0.0.1

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

@@ -0,0 +1,29 @@
+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
+      'draft'
+    when RePipelineBase::CHANGED_STATUS_CHANGED
+      'changed'
+    else #  RePipelineBase::CHANGED_STATUS_CURRENT
+      'current'
+    end
+  end    
+
+end

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

@@ -0,0 +1,123 @@
+class ReJob < ActiveRecord::Base
+  
+  JOB_STATUS_NONE = 0
+  JOB_STATUS_RUNNING = 1
+  JOB_STATUS_SUCCESS = 2
+  JOB_STATUS_FAILED = 3
+  
+  
+  has_many :re_job_audits
+  
+  validates_presence_of :job_status
+  
+  
+  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 ( 
+          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}
+        )    
+    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)
+  end
+  
+  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
+        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    
+    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)
+        result.merge!({
+          'end_date' => job_audit.audit_date,
+          'end_data' => job_audit.audit_data, 
+          'end_success' => job_audit.audit_success
+        })
+      end
+
+      result
+    end
+  end
+
+  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} 
+        )            
+    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)
+  end
+  
+  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                
+        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} 
+        )    
+        ORDER BY job_date 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)
+        result.merge!({
+          'end_date' => job_audit.audit_date,
+          'end_data' => job_audit.audit_data, 
+          'end_success' => job_audit.audit_success
+        })
+      end
+
+      result
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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
+  
+  belongs_to :re_job
+  belongs_to :re_pipeline
+  belongs_to :re_rule
+  
+  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}"} }
+  
+end

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

@@ -0,0 +1,69 @@
+class RePipeline < RePipelineBase
+
+  has_one :activated_re_pipeline, :class_name => "RePipelineActivated", 
+                          :foreign_key => :parent_re_pipeline_id, :dependent => :destroy
+
+  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
+    
+    self.class.transaction do
+      activated_re_pipeline.save! unless self.new_record?
+      save
+    end
+  end
+
+  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  
+
+  def revert! 
+    return if activated_re_pipeline.nil?    
+    self.copy!(activated_re_pipeline)        
+    save
+  end  
+
+  def activated_status
+    if self.activated_re_pipeline.nil?
+      RePipelineBase::ACTIVATED_STATUS_DRAFT
+    else 
+      RePipelineBase::ACTIVATED_STATUS_ACTIVE
+    end  
+  end
+
+  def changed_status
+    if self.activated_re_pipeline.nil?
+      RePipelineBase::CHANGED_STATUS_DRAFT
+    elsif !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

@@ -0,0 +1,26 @@
+class RePipelineActivated < RePipelineBase
+  belongs_to :re_pipeline, :foreign_key => :parent_re_pipeline_id
+  
+  def self.find_by_code(code)
+    return find_by_code_without_caching(code) unless RulesEngine::Cache.perform_caching?
+
+    re_pipeline = RulesEngine::Cache.cache_store.read("activated_pipeline_#{code}")
+    if (re_pipeline.nil?)
+      re_pipeline = find_by_code_without_caching(code)
+
+      RulesEngine::Cache.cache_store.write("activated_pipeline_#{code}", re_pipeline)
+    end    
+
+    re_pipeline
+  end
+
+  def self.find_by_code_without_caching(code)
+    RePipelineActivated.find(:first, :conditions => ["code = ?", code], :include => :re_rules)
+  end
+
+  def self.reset_cache(code)
+    return unless RulesEngine::Cache.perform_caching?
+    RulesEngine::Cache.cache_store.delete("activated_pipeline_#{code}")
+  end
+
+end

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

@@ -0,0 +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
+  
+end

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

@@ -0,0 +1,68 @@
+class RePipelineBase < ActiveRecord::Base
+  set_table_name :re_pipelines  
+  
+  has_many :re_rules, :foreign_key => :re_pipeline_id, :dependent => :destroy, :order => :position
+  
+  ACTIVATED_STATUS_DRAFT  = 0
+  ACTIVATED_STATUS_ACTIVE = 1
+  
+  CHANGED_STATUS_DRAFT      = 0
+  CHANGED_STATUS_CHANGED    = 1
+  CHANGED_STATUS_CURRENT    = 2
+  
+  validates_presence_of   :code
+  validates_presence_of   :title
+  validates_uniqueness_of :code, :scope => :parent_re_pipeline_id, :case_sensitive => false, :message=>"alread taken."
+  
+  named_scope :order_code,  :order => 're_pipelines.code ASC'
+  named_scope :order_title, :order => 're_pipelines.title ASC'
+
+  def code=(new_code)
+    self[:code] = new_code.downcase if new_code && new_record?
+  end
+  
+  def copy! re_pipeline
+    activated_attrs = re_pipeline.attributes
+    ignore_attributes.each{|key| activated_attrs.delete(key)}
+
+    activated_attrs.each do |key, value|
+      self[key] = value
+    end
+    
+    self.re_rules = re_pipeline.re_rules.map { |rule| ReRule.new.copy!(rule) }
+
+    self
+  end
+
+  def equals? re_pipeline
+    activated_attrs = re_pipeline.attributes
+    ignore_attributes.each{|key| activated_attrs.delete(key)}
+
+    activated_attrs.each do |key, value|
+      return false unless self[key] == value
+    end
+    
+    return false if (self.re_rules.length != re_pipeline.re_rules.length)    
+    self.re_rules.each_with_index do |re_rule, index|
+      return false unless re_rule.equals?(re_pipeline.re_rules[index])
+    end
+    
+    true
+  end
+  
+  def verify
+    return 'rules required' if re_rules.empty?
+    
+    re_rules.each do |rule|
+      result = rule.verify
+      return result unless result.blank?
+    end
+    
+    nil
+  end
+
+  protected
+    def ignore_attributes 
+      [self.class.primary_key, self.class.inheritance_column, "type", "parent_re_pipeline_id", "activated_status", "changed_status", "created_at", "updated_at"]
+    end
+end

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

@@ -0,0 +1,78 @@
+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_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
+
+  default_scope :order => 're_rules.position ASC'
+  
+  def copy! re_rule
+    activated_attrs = re_rule.attributes
+    ignore_attributes.each{|key| activated_attrs.delete(key)}
+
+    activated_attrs.each do |key, value|
+      self[key] = value
+    end
+    
+    self.re_rule_outcomes = re_rule.re_rule_outcomes.map { |rule_outcome| ReRuleOutcome.new.copy!(rule_outcome) }
+    
+    self
+  end
+
+  def equals? re_rule
+    activated_attrs = re_rule.attributes
+    ignore_attributes.each{|key| activated_attrs.delete(key)}
+
+    activated_attrs.each do |key, value|
+      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])
+    end
+    
+    true
+  end
+
+  def verify
+    return self.error unless self.error.blank?
+
+    self.re_rule_outcomes.each do |rule_outcome|
+      result = rule_outcome.verify
+      return result unless result.blank?
+    end
+    
+    nil
+  end
+
+  def re_rule_outcome_next
+    re_rule_outcomes.detect{ |re_rule_outcome| re_rule_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 }
+  end
+
+  def re_rule_outcome_failure
+    re_rule_outcomes.detect{ |re_rule_outcome| re_rule_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 }
+  end
+
+  protected
+    def ignore_attributes 
+      [self.class.primary_key, self.class.inheritance_column, "re_pipeline_id", "created_at", "updated_at"]
+    end
+
+end

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

@@ -0,0 +1,40 @@
+class ReRuleOutcome < ActiveRecord::Base
+  belongs_to :re_rule
+
+  validates_associated  :re_rule
+  validates_presence_of :outcome  
+  def validate    
+    if outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE && pipeline_code.blank?
+      errors.add(:pipeline_code, "pipeline code required")
+    end
+  end
+
+  def copy! re_rule_outcome    
+    self.outcome = re_rule_outcome.outcome
+    self.pipeline_code = re_rule_outcome.pipeline_code
+    self
+  end
+
+  def equals? re_rule_outcome    
+    if outcome != re_rule_outcome.outcome
+      return false
+    end
+      
+    if outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE
+      return false unless pipeline_code == re_rule_outcome.pipeline_code
+      #TODO check the pipeline equals the pipeline code
+    end  
+    
+    return true    
+  end
+
+  def verify
+    if outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE
+      return "pipeline code required" if pipeline_code.blank?
+      return "outcome pipeline missing" unless RePipeline.find(:first, :conditions => ["code = ?", pipeline_code])
+    end
+    
+    return nil
+  end
+  
+end

data/rails_generators/templates/app/rules/blacklist_word.rb

@@ -0,0 +1,89 @@
+class BlacklistWord < RulesEngine::Rule
+
+  BLACKLIST_WORD_VERSION = 1.0  
+  
+  self.options = 
+    {
+      :group => 'Sample Rules',
+      :name => 'Blacklist Words',
+      :description => 'Perform a specifc action if the following words are found',
+      :help_template => '/re_rule_definitions/blacklist_word/help',
+      :new_template => '/re_rule_definitions/blacklist_word/new',
+      :edit_template => '/re_rule_definitions/blacklist_word/edit'
+    } 
+  
+  attr_reader :title
+  attr_reader :words
+  attr_reader :pipeline_action
+  attr_reader :pipeline
+  
+  def attributes=(params)
+    @words = []
+    @title = params['blacklist_word_title']
+    
+    return if params['blacklist_word'].nil?
+    params['blacklist_word'].each do |key, value| 
+      @words << value['word'].downcase unless value['word'].blank? || value['_delete'] == '1'
+    end
+    
+    @pipeline_action = params['blacklist_word_pipeline_action'] || 'continue'
+    @pipeline = params['blacklist_word_pipeline'] || ''    
+  end
+  
+  def valid?
+    self.errors << "At least one word must be defined" if @words.nil? || @words.empty?
+    self.errors << "Title required" if @title.blank?    
+    self.errors << "Pipeline required" if @pipeline_action == 'start_pipeline' && @pipeline.blank?
+    return self.errors.empty?
+  end
+
+  def load(re_rule)
+    return false unless super
+    
+    @title = re_rule.title
+    @words, @pipeline_action, @pipeline = ActiveSupport::JSON.decode(re_rule.data)
+    true
+  end
+
+  def save(re_rule)
+    return false unless super
+    
+    re_rule.title = @title
+    re_rule.summary = "Exclude #{@words.size} #{@words.size == 1 ? 'word' : 'words'}"
+    re_rule.data_version = BLACKLIST_WORD_VERSION
+    re_rule.data = [@words, @pipeline_action, @pipeline].to_json
+    re_rule.error = nil
+    
+    # save rule outcomes    
+    if @pipeline_action == 'next'
+      re_rule.re_rule_outcomes = [ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT)]
+    elsif @pipeline_action == 'stop_success'
+      re_rule.re_rule_outcomes = [ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS)]
+    elsif @pipeline_action == 'stop_failure'
+      re_rule.re_rule_outcomes = [ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE)]
+    else # if @pipeline_action == 'start_pipeline'
+      re_rule.re_rule_outcomes = [ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, 
+                                                    :pipeline_code => @pipeline)]
+    end
+    
+    true
+  end    
+
+  def process(job_id, data)
+    rule_outcome = RulesEngine::RuleOutcome.new
+  
+    if @pipeline_action == 'next'
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_NEXT
+    elsif @pipeline_action == 'stop_success'
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS
+    elsif @pipeline_action == 'stop_failure'
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE
+    else # if @pipeline_action == 'start_pipeline'
+      rule_outcome.outcome = RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE
+      rule_outcome.pipeline_code = @pipeline  
+    end
+    
+    rule_outcome
+  end  
+    
+end

data/rails_generators/templates/app/rules/simple.rb

@@ -0,0 +1,44 @@
+class Simple < RulesEngine::Rule
+
+  SIMPLE_VERSION = 1.0  
+  
+  self.options = 
+    {
+      :group => 'Sample Rules',
+      :name => 'Simple Rule',
+      :description => 'Does nothing',
+      :help_template => '/re_rule_definitions/simple/help',
+      :new_template => '/re_rule_definitions/simple/new',
+      :edit_template => '/re_rule_definitions/simple/edit'
+    } 
+  
+  attr_reader :title
+  
+  def attributes=(params)
+    @title = params['simple_title']
+  end
+  
+  def valid?
+    self.errors << "Title required" if @title.blank?
+    return self.errors.empty?
+  end
+
+  def load(re_rule)
+    return false unless super
+
+    @title = re_rule.title
+    true
+  end
+
+  def save(re_rule)
+    return false unless super
+
+    re_rule.title = @title
+    re_rule.summary = "Simple Rule : Does Nothing"
+    re_rule.data_version = SIMPLE_VERSION
+    re_rule.data = ["ignore"].to_json
+    re_rule.error = nil
+    true
+  end    
+    
+end

data/rails_generators/templates/app/rules/template.rb

@@ -0,0 +1,51 @@
+class <%= rule_class %> < RulesEngine::Rule
+
+  <%=rule_name.upcase %>_VERSION = 1.0  
+  
+  self.options = 
+    {
+      :group => 'Sample Rules',
+      :name => '<%=rule_class %> Rule',
+      :description => 'Does nothing',
+      :help_template => '/re_rule_definitions/<%=rule_name %>/help',
+      :new_template => '/re_rule_definitions/<%=rule_name %>/new',
+      :edit_template => '/re_rule_definitions/<%=rule_name %>/edit'
+    } 
+  
+  attr_reader :title
+  
+  def attributes=(params)
+    @title = params['<%=rule_name %>_title']
+  end
+  
+  def valid?
+    self.errors << "Title required" if @title.blank?
+    return self.errors.empty?
+  end
+
+  def load(re_rule)
+    return false unless super
+
+    @title = re_rule.title
+    true
+  end
+
+  def save(re_rule)
+    return false unless super
+
+    re_rule.title = @title
+    re_rule.summary = "<%=rule_class %> Rule : Does Nothing"
+    re_rule.data_version = <%=rule_name.upcase%>_VERSION
+    re_rule.data = ["ignore"].to_json
+    re_rule.error = nil
+    true
+  end    
+
+  ##################################################################
+  # return an RulesEngine::RuleOutcome object to define what to do next
+  # or nil to continue to the next rule
+  def process(job_id, data)
+    nil 
+  end  
+    
+end

data/rails_generators/templates/app/views/layouts/_blockUI.html.erb

@@ -0,0 +1,3 @@
+<!-- thickbox frame and container -->
+<div id="tb_temp_frame"><div id="tb_temp_container"></div></div>
+

data/rails_generators/templates/app/views/re_jobs/_empty.html.erb

@@ -0,0 +1,11 @@
+<% local_hide = local_assigns[:hide] && hide  %>
+
+<div id="job_list_empty" style="<%= local_hide ?  'display:none' : '' %>">
+  <div class="redbox-header"><h4 class="white">No Jobs Created</h4></div>   
+  <div class="redbox no-top">
+    <h4 class="left-5">Jobs are added when run.</h4>
+  </div>    
+  <div class="clear"></div>    
+</div>  
+<div class="clear"></div>  
+