cullender 0.0.1

data/app/models/cullender/rule.rb

@@ -0,0 +1,204 @@
+module Cullender
+  class Rule < ActiveRecord::Base
+
+  	before_create :add_event_percolation
+  	before_update :modify_event_percolation
+  	before_destroy :remove_event_percolation
+
+
+	serialize :triggers, Hash
+
+	validates :name, :presence => true, :uniqueness => true, :length => {
+	    :minimum => 4,
+	    :maximum => 20
+	}
+
+# basic operators ["term", "terms", "string", "range", "prefix", "fuzzy"]
+	OPERATORS = {
+		"text_field" => {
+			I18n.t("cullender.operators.term") => "term",
+			I18n.t("cullender.operators.prefix") => "prefix"
+		},
+		"number_field" => {
+			I18n.t("cullender.operators.gt") => "gt",
+			I18n.t("cullender.operators.gte") => "gte",
+			I18n.t("cullender.operators.lt") => "lt",
+			I18n.t("cullender.operators.lte") => "lte",
+			I18n.t("cullender.operators.eq") => "term"
+		},
+		"range_field" => {
+			I18n.t("cullender.operators.gt") => "gt",
+			I18n.t("cullender.operators.gte") => "gte",
+			I18n.t("cullender.operators.lt") => "lt",
+			I18n.t("cullender.operators.lte") => "lte",
+			I18n.t("cullender.operators.eq") => "term"
+		},
+		"date" => {
+			I18n.t("cullender.operators.from") => "from",
+			I18n.t("cullender.operators.to") => "to"
+		},
+		"datetime" => {
+			I18n.t("cullender.operators.from") => "from",
+			I18n.t("cullender.operators.to") => "to"
+		},
+		"select" => {
+			I18n.t("cullender.operators.is") => "term",
+			I18n.t("cullender.operators.is_not") => "term"
+		},
+		"check_box" => {
+			I18n.t("cullender.operators.eq") => "is"
+		}
+	}
+
+	FILTER_MAP = {
+		"term" => "==",
+		"prefix" => "starts with",
+		"gt" => ">",
+		"gte" => ">=",
+		"lt" => "<",
+		"lte" => "<=",
+		"from" => ">=",
+		"to" => "<="
+	}
+
+	FIELD_TYPE_MAP = {
+		'string' => 'text_field',
+		'integer' => 'number_field',
+		'long' => 'number_field',
+		'double' => 'number_field',
+		'float' => 'number_field',
+		'date' => 'date',
+		'boolean' => 'check_box'
+	}
+
+  
+	# This method searches elastic search for events that match this specific
+	def fire(event)
+		event.add_labels(self.labels) unless self.labels.empty?
+		# send any notifications
+	end
+
+	#  converts the current rule to a proc accepting an an elastic search query object
+	def to_query_proc
+		Proc.new do
+			self.to_query
+		end
+	end
+
+	def to_query
+		query = ::Tire::Search::Query.new
+		if triggers.present?
+			
+			# check if there is only one field
+			count = number_of_fields
+			if count > 1
+				# complex operators ["boolean", "filtered", "dis_max", "nested"]
+				convert_to_boolean(query)
+			elsif count == 1
+				query = convert_to_basic_query(query, triggers.first[0], triggers.first[1])
+			else
+
+			end
+		end
+		query
+	end
+
+
+	def convert_to_boolean(query, params = self.triggers)
+		query.boolean do |bool|
+			params.each do |key, values|
+				if key.to_i > 0
+					bool.should do |q|
+						convert_to_boolean(q, values)
+					end
+				else
+					bool.must do |q|
+						convert_to_basic_query(q, key, values)
+					end
+				end
+			end
+		end
+		query
+	end
+
+
+
+	# def to_filter
+	# 	search = ::Tire::Search::Search.new
+	# 	filters_to_or = []
+	# 	search.query.all
+	# 	triggers.each do |key, value|
+	# 		if value.has_key?("o") && value.has_key?("v")
+	# 			search.filter :term, key.to_sym => value["v"]
+	# 		else
+	# 			f = self.to_search(::Tire::Search::Search.new, value).to_hash
+	# 			filters_to_or << f[:filter]
+	# 		end
+	# 	end
+	# 	search.filter :or, filters_to_or unless filters_to_or.empty?
+	# 	search
+	# end
+
+	private
+
+	def add_event_percolation
+		begin
+			# debugger
+			response = Event.index.register_percolator_query(self.name, :query => self.to_query.to_hash)
+			!response.nil?
+		rescue Exception => e
+			false
+		end
+	end
+
+	def modify_event_percolation
+		begin
+			response = Event.index.unregister_percolator_query(self.name)
+			response = Event.index.register_percolator_query(self.name, :query => self.to_query.to_hash)
+			!response.nil?
+		rescue Exception => e
+			false
+		end
+	end
+
+	def remove_event_percolation
+		begin
+			response = Event.index.unregister_percolator_query(self.name, :query => self.to_query.to_hash)
+			!response.nil?
+		rescue Exception => e
+			false
+		end
+	end
+	private
+
+	##
+	# Calculate the number of fields in the triggers hash
+	def number_of_fields(params = self.triggers)
+		if params.present?
+			params.values.inject(0) do |sum, value|
+				if value.is_a?(Hash)
+					# puts value.keys.inspect
+					sum + (value.keys.include?("o") ? 1 : number_of_fields(value) )
+				else
+					sum + 1
+				end
+			end
+		else
+			0
+		end
+	end
+
+	def convert_to_basic_query(query, field_name, params = {})
+		# basic operators ["term", "terms", "string", "range", "prefix", "fuzzy"]
+		if (query.is_a?(Tire::Search::Query))
+			operator = params["o"]
+			value = params["v"]
+			query.send(operator.to_sym, field_name, value)
+		else
+	      raise ArgumentError, "Argument is not a Tire::Search::Search."
+	    end
+	    query
+	end
+
+  end
+end

data/app/views/cullender/rules/_form.html.erb

@@ -0,0 +1,20 @@
+<%= simple_form_for rule, :html => { :class => "form-horizontal" } do |f| %>
+	<%= f.error_notification %>
+	<div class="form-inputs">
+	<fieldset id="rule">
+		<legend>Rule Description</legend>
+		<%= f.input :name %>
+		<%= f.input :description %>
+		<%= f.association :table, :prompt => "Select Type" %>
+	</fieldset>
+	
+	<fieldset id="triggers" class="filters">
+		<legend>Triggers</legend>
+		<%= render 'trigger_fields', :locals => {properties: Event.properties} %>	
+	</fieldset>
+	
+	<div class="form-actions">
+	<%= f.error :base %>
+	<%= f.button :submit %>
+	</div>
+<% end %>

data/app/views/cullender/rules/_trigger_fields.html.erb

@@ -0,0 +1,19 @@
+<div id="cullender_triggers">
+	<% if params.has_key?("triggers") || params.has_key?("rule") && params["rule"].has_key?("triggers") %>
+		<%= render_property_tree("rule[triggers]", mapping, extract_triggers(params)) do |html, at_end, hierarchy| %>
+			<div class="controls">
+			<%= html %>
+			</div>
+			<div class="controls">
+				<% if at_end < 0 %>
+					<%= cullender_collection_or_select(mapping.keys, hierarchy) %>
+				<% else %>
+					<%= cullender_collection_and_select(mapping.keys, hierarchy) %>
+				<% end -%>
+			</div>
+		<% end %>
+	<% end %>
+	<div class="controls">
+		<%= cullender_collection_or_select(mapping.keys, [], {:base => true}) %>
+	</div>
+</div>

data/app/views/cullender/rules/create.js.erb

@@ -0,0 +1,3 @@
+jQuery(function() {
+	$('#cullender_triggers').replaceWith("<%= escape_javascript(render 'trigger_fields', mapping: resource_class.mapping) %>");
+});

data/app/views/cullender/rules/index.html.erb

@@ -0,0 +1,25 @@
+<h1>Listing rules</h1>
+
+<table>
+  <thead>
+    <tr>
+      <th>Name</th>
+      <th>Enabled</th>
+      <th></th>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% @rules.each do |rule| %>
+    <tr>
+      <td><%= link_to rule.name, rule %></td>
+      <td><%= link_to 'Edit', rule %></td>
+      <td><%= link_to 'Destroy', rule, method: :delete, data: { confirm: 'Are you sure?' } %></td>
+    </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<br />
+
+<%= link_to 'New Rule', new_rule_path %>

data/app/views/cullender/rules/new.html.erb

@@ -0,0 +1 @@
+<%= render 'form', :rule => @rule %>

data/app/views/cullender/rules/show.html.erb

@@ -0,0 +1,3 @@
+<%= render 'form', :rule => @rule %>
+
+<%= link_to 'Back', rules_path %>

data/config/locales/en.yml

@@ -0,0 +1,12 @@
+en:
+  cullender:
+    operators:
+      term: "is"
+      prefix: "starts with"
+      gt: ">"
+      gte: ">="
+      lte: "<="
+      lt: "<"
+      eq: "=="
+      from: "from"
+      to: "to"

data/config/routes.rb

@@ -0,0 +1,4 @@
+# Cullender::Engine.routes.draw do
+# 	resources :rules, :except => :edit
+# 	resources :events, :only => [:show, :update]
+# end

data/lib/cullender.rb

@@ -0,0 +1,96 @@
+require "tire"
+require "cullender/core_ext/hash"
+
+module Rails
+  module Generators
+  	module Migration
+		module ClassMethods
+			def next_migration_number(dirname) #:nodoc:
+				"123344556676"
+			end
+		end
+  	end
+  end
+end
+
+
+module Cullender
+
+  module Controllers
+    autoload :ScopedViews, 'cullender/controllers/scoped_views'
+    autoload :FilterLogic, "cullender/controllers/filter_logic"
+  end
+
+
+	# The parent controller all Devise controllers inherits from.
+	# Defaults to ApplicationController. This should be set early
+	# in the initialization process and should be set to a string.
+	mattr_accessor :parent_controller
+	@@parent_controller = "ApplicationController"
+
+	# The router Devise should use to generate routes. Defaults
+	# to :main_app. Should be overriden by engines in order
+	# to provide custom routes.
+	mattr_accessor :router_name
+	@@router_name = nil
+
+	# Define a set of modules that are called when a mapping is added.
+	mattr_reader :helpers
+	@@helpers = Set.new
+	# @@helpers << Cullender::Controllers::Helpers
+
+	# Store scopes mappings.
+	mattr_reader :mappings
+	@@mappings = ActiveSupport::OrderedHash.new
+
+
+	# Scoped views. Since it relies on fallbacks to render default views, it's
+	# turned off by default.
+	mattr_accessor :scoped_views
+	@@scoped_views = false
+
+	# Default way to setup Cullender. Run rails generate cullender:install to create
+	# a fresh initializer with all configuration values.
+	def self.setup
+		yield self
+	end
+
+	# Regenerates url helpers considering Devise.mapping
+	def self.regenerate_helpers!
+		# Devise::Controllers::UrlHelpers.remove_helpers!
+		# Devise::Controllers::UrlHelpers.generate_helpers!
+	end
+
+
+	# Small method that adds a mapping to Devise.
+	def self.add_mapping(resource, options)
+		mapping = Cullender::Mapping.new(resource, options)
+		@@mappings[mapping.name] = mapping
+		@@default_scope ||= mapping.name
+		@@helpers.each { |h| h.define_helpers(mapping) }
+		mapping
+	end
+
+
+	class Getter
+		def initialize name
+			@name = name
+		end
+
+		def get
+			ActiveSupport::Dependencies.constantize(@name)
+		end
+	end
+
+	def self.ref(arg)
+		if defined?(ActiveSupport::Dependencies::ClassCache)
+			ActiveSupport::Dependencies::reference(arg)
+			Getter.new(arg)
+		else
+			ActiveSupport::Dependencies.ref(arg)
+		end
+	end
+end
+
+require 'cullender/mapping'
+require "cullender/engine"

data/lib/cullender/controllers/filter_logic.rb

@@ -0,0 +1,89 @@
+module Cullender
+  module Controllers
+    module FilterLogic
+        def add_or_filter(key, params, field, should_raise = false)
+          if params.present? && params.has_key?(key)
+            if should_raise
+              params[key] = {1 => params[key], 2 => add_operator(field)}
+            else
+              idx = params[key].keys.last.to_i + 1
+              params[key].deep_merge!({idx => add_operator(field)})
+            end
+          else
+            if should_raise
+              params[key] = add_operator(field)
+            else
+              params[key] = add_operator(field)
+            end
+          end
+        end
+
+        def add_and_filter(key, params, field)
+          clean_field(field) unless field.is_a? String
+          if params.present? && params.has_key?(key)
+            params[key].deep_merge!(add_operator(field))
+          else
+            params[key] = add_operator(field)
+          end
+        end
+
+        def clean_field(field)
+
+          field.each do |key, value|
+            if value.is_a?(Hash)
+              clean_field(value)
+            else
+              field.delete(key) if value.blank?
+            end
+          end
+        end
+
+        def remove_and_filter(key, params, field)
+          if params.present? && params.has_key?(key)
+            if field.is_a? String
+              params[key].delete(field)
+            else 
+              params[key].deep_delete(field)
+            end
+          end
+        end
+
+        def add_operator(field)
+          if field.is_a?(Hash)
+            hash = {}
+            field.each do |key, value|
+              if ["o", "v"].include?(key)
+                hash = field
+                break
+              else
+                hash.merge!({key => add_operator(value)}) unless ["o", "v"].include?(key)
+              end
+            end
+          elsif
+            hash = {field => {"o" => nil}} 
+          end
+          hash
+        end
+
+        def apply_filter_actions(name, filter_params, params)
+          # debugger
+          updated = false
+          if params.has_key?("or") && (params["or"].has_key?("commit") || params["or"].has_key?("raise"))
+            nfilter = params.delete("or")
+            should_raise = nfilter.has_key?("raise")
+            add_or_filter(name, filter_params, should_raise ? nfilter["raise_field"] : nfilter["field"],  should_raise) if (nfilter["field"].present? || nfilter["raise_field"].present?)
+            updated = true
+          elsif params.has_key?("and") && params["and"].has_key?("commit")
+            nfilter = params.delete("and")
+            add_and_filter(name, filter_params, nfilter["field"]) if nfilter["field"].present?
+            updated = true
+          elsif params.has_key?("remove")
+            nfilter = params.delete("remove")
+            remove_and_filter(name, filter_params, nfilter)
+            updated = true
+          end
+          updated
+        end
+    end
+  end
+end