rooler 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzY3OGU5OTI0Y2VjY2QxNmNkYjdhMjkwNmIzNjdkN2NiOWVjOTNiMg==
+  data.tar.gz: !binary |-
+    ZTg3YjQ1MjJiMjJhNDkyNTUzZjg2YmNjNzA0NzY5ZGI5NjFlNDFmOQ==
+SHA512:
+  metadata.gz: !binary |-
+    MDQyMjhmM2Y3YzAwZWQ5OGNiYmE3MThiOTk1Njc2OGFlMjEzZDAxMGVhNmJj
+    ZjcwODA2YTc1MDA3Y2YyNjRhYzllNWE5NmE3OWJkNzViMmI2ZTdjZGZjNmM4
+    ZGMyZDgyZTUzNWYyZDllMDM4ODI2ODc4ZjRlZTY1NWUxNjU3ZTY=
+  data.tar.gz: !binary |-
+    YjkzZGUxMWMzOGQ0NGNjYjY3MzAwZGJkNzA0MDVmOTFjNTAzZDc5Y2IwODRi
+    ZDJhYmRjZDg4ZWFmNzJhZDYwMGQ4YzlhOThhMzlkNDM5YzQ2ZWJiMGUyMjg3
+    MWRmNmRlODM3NjM5NGM5MWNmMWRmYjVmOTU0YmYxZTQ1NjZhOTc=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Rooler
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rooler'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/rooler/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require ckeditor/override
+//= require ckeditor/init
+//= require_tree .

data/app/assets/javascripts/rooler/ckeditor/config.js

@@ -0,0 +1,10 @@
+CKEDITOR.config.toolbar_mini =
+    [
+        ['Undo','Redo','-','Find','Replace','-','SelectAll','RemoveFormat'],
+        ['Bold','Italic','Underline','Strike','-','Subscript','Superscript'],
+        ['NumberedList','BulletedList','-','Outdent','Indent'],
+        ['JustifyLeft','JustifyCenter','JustifyRight','JustifyBlock'],
+        ['Link','Unlink'],
+        ['Styles','Format','Font','FontSize'],
+        ['TextColor','BGColor']
+    ];

data/app/assets/javascripts/rooler/templates.js

@@ -0,0 +1,3 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.
+

data/app/assets/stylesheets/rooler/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * 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/app/controllers/rooler/application_controller.rb

@@ -0,0 +1,5 @@
+module Rooler
+  class ApplicationController <  Rooler::BaseController
+
+  end
+end

data/app/controllers/rooler/rules_controller.rb

@@ -0,0 +1,74 @@
+require_dependency "rooler/application_controller"
+
+module Rooler
+  class RulesController < ApplicationController
+    include ActionView::Helpers::TextHelper
+    
+    before_action :set_rule, only: [:check, :show, :edit, :update, :destroy]
+    
+    # POST /rules/1
+    def check
+      results = @rule.process
+      if results
+        redirect_to rules_path, notice: "Checked rule. #{pluralize(results.count, 'result')} found"
+      else
+        redirect_to rules_path, alert: 'Failed to check rule'
+      end
+    end
+    
+    # GET /rules
+    def index
+      @rules = Rule.order(:created_at)
+    end
+
+    # GET /rules/1
+    def show
+    end
+
+    # GET /rules/new
+    def new
+      @rule = Rule.new
+    end
+
+    # GET /rules/1/edit
+    def edit
+    end
+
+    # POST /rules
+    def create
+      @rule = Rule.new(rule_params)
+
+      if @rule.save
+        redirect_to rules_url, notice: 'Rule was successfully created.'
+      else
+        render action: 'new'
+      end
+    end
+
+    # PATCH/PUT /rules/1
+    def update
+      if @rule.update(rule_params)
+        redirect_to rules_url, notice: 'Rule was successfully updated.'
+      else
+        render action: 'edit'
+      end
+    end
+
+    # DELETE /rules/1
+    def destroy
+      @rule.destroy
+      redirect_to rules_url, notice: 'Rule was successfully destroyed.'
+    end
+
+    private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_rule
+      @rule = Rule.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def rule_params
+      params.require(:rule).permit(:name, :klass_name, :klass_finder_method, :template_id, :check_frequency, :method_params)
+    end
+  end
+end

data/app/controllers/rooler/templates_controller.rb

@@ -0,0 +1,80 @@
+require_dependency "rooler/application_controller"
+
+module Rooler
+  class TemplatesController < ApplicationController
+    before_action :set_template, only: [:test, :show, :edit, :update, :destroy]
+
+    def test
+      test_object = @template.test_object
+      deliverable = Delivery.new(deliverable: test_object, template: @template) if test_object
+      delivery = DeliveryMailer.send_mail(deliverable, params[:email]).deliver if deliverable
+      if delivery
+        redirect_to @template, notice: "Test email sent"
+      else
+        notice = test_object ? "Failed. Couldn't deliver email" : "Failed. Searched the rules associated with this template but couldn't find any objects to test with."
+        redirect_to @template, notice: notice
+      end
+    end
+
+    # GET /templates
+    def index
+      @templates = Template.order(:created_at)
+    end
+
+    # GET /templates/1
+    def show
+      test_object = @template.test_object
+      if test_object
+        @liquid_variables = {test_object.class.name.demodulize.downcase.to_s => test_object}
+      else
+        flash.now[:notice] ||= "Variables may be empty. Searched the rules associated with this template but couldn't find any objects to test with."
+      end
+    end
+
+    # GET /templates/new
+    def new
+      @template = Template.new
+    end
+
+    # GET /templates/1/edit
+    def edit
+    end
+
+    # POST /templates
+    def create
+      @template = Template.new(template_params)
+
+      if @template.save
+        redirect_to @template, notice: 'Template was successfully created.'
+      else
+        render action: 'new'
+      end
+    end
+
+    # PATCH/PUT /templates/1
+    def update
+      if @template.update(template_params)
+        redirect_to @template, notice: 'Template was successfully updated.'
+      else
+        render action: 'edit'
+      end
+    end
+
+    # DELETE /templates/1
+    def destroy
+      @template.destroy
+      redirect_to templates_url, notice: 'Template was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_template
+        @template = Template.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def template_params
+        params.require(:template).permit(:name, :to, :cc, :subject, :body)
+      end
+  end
+end

data/app/helpers/rooler/application_helper.rb

@@ -0,0 +1,9 @@
+module Rooler
+  module ApplicationHelper
+    
+    def liquidize(content, arguments)
+      Liquid::Template.parse(content).render(arguments, :filters => [Rooler::LiquidFilters]).html_safe
+    end
+     
+  end
+end

data/app/mailers/rooler/delivery_mailer.rb

@@ -0,0 +1,18 @@
+module Rooler
+  class DeliveryMailer < ActionMailer::Base
+    helper ApplicationHelper
+    include ApplicationHelper
+        
+    def send_mail(delivery, to_email = nil)
+       template = delivery.template
+       deliverable = delivery.deliverable
+       
+       @liquid_variables = {deliverable.class.name.demodulize.downcase.to_s => deliverable}
+       @body = template.body
+       
+       mail to: to_email || liquidize(template.to, @liquid_variables),
+            cc: liquidize(template.cc, @liquid_variables), 
+            subject: liquidize(template.subject, @liquid_variables)
+    end
+  end
+end

data/app/models/rooler/delivery.rb

@@ -0,0 +1,11 @@
+module Rooler
+  class Delivery < ActiveRecord::Base
+    belongs_to :deliverable, polymorphic: true
+    belongs_to :rule
+    has_one :template, through: :rule
+    
+    validates :rule_id, uniqueness: {scope: [:deliverable_type, :deliverable_id], message: "Rule already processed for this object"}
+    
+    scope :undelivered, -> {where(delivered_at: nil)}    
+  end
+end

data/app/models/rooler/rule.rb

@@ -0,0 +1,98 @@
+module Rooler
+  class Rule < ActiveRecord::Base
+    
+    # A rule is a map between email templates and objects of a specific class. A rule checks those objects to dermine if the parent email
+    # should be sent. A rule can check a specific object on demand, or check the entire class at a certain frequency.
+    #
+    # The conditions which determine if a rule is met or not is actually defined in the objects class. The rule stores an instance method
+    # name, which it can call on a specific object (on demand), and a class method name to search the class for matching objects
+    
+    belongs_to :template
+    has_many :deliveries
+    scope :ready_to_be_checked, -> {where("last_checked_at IS NULL OR check_frequency IS NULL OR (last_checked_at + check_frequency*'1 second'::interval) < now()")}    
+    serialize :method_params
+    
+    validate :valid_klass_name
+    validate :valid_klass_finder_method
+    
+    # processes this rule. Check entire class using class method. For each positive result add object to delivery queue.
+    def process
+      results = find_undelivered_by_klass.each {|result| add_delivery_to_queue(result)}
+      self.update_column(:last_checked_at, Time.now)
+      return results
+    end
+
+    def clear_non_applicable_deliveries
+      self.deliveries.where(deliverable_id: no_longer_applicable_delivery_ids).destroy_all
+    end
+    
+    private 
+    
+    # sends klass_method to klass. If the saved rule contains any params, send those as well.
+    def find_by_klass
+      if self.method_params
+        klass.send(self.klass_finder_method, self.method_params)
+      else
+        klass.send(self.klass_finder_method)
+      end
+    end
+    
+    def find_by_klass_ids
+      results = find_by_klass
+      if results.respond_to?(:id)
+        results.pluck(:id)
+      elsif results.respond_to?(:map)
+        results.map(&:id)
+      else
+        raise "Cannot determine object ids"
+      end
+    end
+    
+    # Try to exclude any objects already delivered. If the result of the klass method is an active record relation, try to chain on a where clause.
+    # otherwise iterate through as an array and use reject.
+    def find_undelivered_by_klass
+      results = find_by_klass
+      if results.respond_to?(:where)
+        results.where.not(id: already_delivered_ids)
+      elsif results.respond_to?(:reject)
+        results.reject {|o| already_delivered_ids.include?(o.id)}
+      else
+        raise "cannot determine which objects where already delivered"
+      end
+    end
+    
+    def already_delivered_ids
+      self.deliveries.pluck(:deliverable_id)  #just getting the deliverable id lets the finder class and the result class be different
+    end
+    
+    def no_longer_applicable_delivery_ids
+      already_delivered_ids - find_by_klass_ids
+    end
+        
+    # create record in deliveries table for found objects (unless one already exists)
+    def add_delivery_to_queue(object)
+      if deliveries.create(deliverable: object)
+        return object
+      else
+        return nil
+      end
+    end
+
+    def klass
+      @klass ||= self.klass_name.try(:constantize) rescue nil
+    end
+    
+    def valid_klass_name
+      unless klass
+        errors.add(:klass_name, "Couldn't constantize class name")
+      end
+    end
+    
+    def valid_klass_finder_method
+      unless klass.respond_to? self.klass_finder_method
+        errors.add(:klass_finder_method, "Class finder method doesn't exist")
+      end
+    end
+        
+  end
+end

data/app/models/rooler/template.rb

@@ -0,0 +1,16 @@
+module Rooler
+  class Template < ActiveRecord::Base
+    has_many :rules
+    has_many :deliveries, as: :deliverable
+    validates :name, :to, :subject, :body, presence: true
+    
+    def test_object
+      object = nil
+      rules.each do |rule|
+        object = rule.send(:find_by_klass).first
+        break if object
+      end
+      object ||= nil
+    end
+  end
+end