maily_herald 0.0.1 → 0.8.0

data/Rakefile

@@ -12,6 +12,8 @@ rescue LoadError
   RDoc::Task = Rake::RDocTask
 end
 
+require 'thor'
+
 RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = 'MailyHerald'
@@ -20,4 +22,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
 Bundler::GemHelper.install_tasks

data/app/controllers/maily_herald/tokens_controller.rb

@@ -0,0 +1,11 @@
+module MailyHerald
+  class TokensController < MailyHerald::ApplicationController
+    def get
+      @subscription = MailyHerald::Subscription.find_by_token(params[:token])
+      @subscription.try(:deactivate!)
+
+      redirect_to MailyHerald.token_redirect.try(:call, self, @subscription) || "/", 
+        notice: @subscription ? t('maily_herald.subscription.deactivated') : t('maily_herald.subscription.undefined_token')
+    end
+  end
+end

data/app/helpers/maily_herald/tokens_helper.rb

@@ -0,0 +1,17 @@
+module MailyHerald
+  # This helper helps overwriting Maily TokensController and/or views in main app
+  module TokensHelper
+    extend ActiveSupport::Concern
+
+    # Cover *_url and *_path generated methods
+    def method_missing(method, *args, &block)
+      method.to_s.end_with?("_url", "_path") ? main_app.send(method, *args, &block) : (raise NoMethodError)
+    rescue NoMethodError
+      super
+    end
+
+    included do
+      delegate :url_for, to: :main_app
+    end
+  end
+end

data/app/mailers/maily_herald/mailer.rb

@@ -0,0 +1,91 @@
+module MailyHerald
+  class Mailer < ActionMailer::Base
+    attr_reader :entity
+
+    def generic entity, mailing
+      destination = mailing.destination(entity)
+      subject = mailing.render_subject(entity)
+      content = mailing.render_template(entity)
+
+      opts = {
+        to: destination, 
+        subject: subject
+      }
+      opts[:from] = mailing.from if mailing.from.present?
+
+      mail(opts) do |format|
+        format.text { render text: content }
+      end
+    end
+
+    class << self
+      #TODO make it instance method so we get access to instance attributes
+      def deliver_mail(mail) #:nodoc:
+        mailing = mail.maily_herald_data[:mailing]
+        entity = mail.maily_herald_data[:entity]
+
+
+        if mailing && entity
+          mailing.deliver_with_mailer_to(entity) do
+            ActiveSupport::Notifications.instrument("deliver.action_mailer") do |payload|
+              self.set_payload_for_mail(payload, mail)
+              yield # Let Mail do the delivery actions
+            end
+            mail
+          end
+        else
+          MailyHerald.logger.log_processing(mailing, entity, mail, prefix: "Delivery outside Maily")
+
+          ActiveSupport::Notifications.instrument("deliver.action_mailer") do |payload|
+            self.set_payload_for_mail(payload, mail)
+            yield # Let Mail do the delivery actions
+          end
+        end
+      end
+    end
+
+    def mail(headers = {}, &block)
+      return @_message if @_mail_was_called && headers.blank? && !block
+
+      # Assign instance variables availabe for template
+      @maily_subscription = @_message.maily_herald_data[:subscription]
+      @maily_entity = @_message.maily_herald_data[:entity]
+      @maily_mailing = @_message.maily_herald_data[:mailing]
+
+      super
+    end
+
+    protected
+
+    def process(*args) #:nodoc:
+      class << @_message
+        attr_accessor :maily_herald_data
+
+        def maily_herald_processable?
+          @maily_herald_processable ||= maily_herald_data[:mailing].processable?(maily_herald_data[:entity])
+        end
+
+        def maily_herald_conditions_met?
+          @maily_herald_conditions_met ||= maily_herald_data[:mailing].conditions_met?(maily_herald_data[:entity])
+        end
+      end
+
+      mailing = args[0].to_s == "generic" ? args[2] : MailyHerald.dispatch(args[0])
+      entity = args[1]
+
+      @_message.maily_herald_data = {
+        mailing: mailing,
+        entity: entity,
+        subscription: mailing.subscription_for(entity),
+      }
+
+      lookup_context.skip_default_locale!
+      super
+
+      @_message.to = mailing.destination(entity) unless @_message.to
+      @_message.from = mailing.from unless @_message.from
+
+      @_message
+    end
+  end
+end

data/app/models/maily_herald/dispatch.rb

@@ -0,0 +1,76 @@
+module MailyHerald
+  class Dispatch < ActiveRecord::Base
+    belongs_to  :list,          class_name: "MailyHerald::List"
+
+    validates   :list,          presence: true
+    validates   :state,         presence: true, inclusion: {in: [:enabled, :disabled, :archived]}
+    validate do |dispatch|
+      dispatch.errors.add(:base, "Can't change this dispatch because it is locked.") if dispatch.locked?
+    end
+    before_destroy do |dispatch|
+      if dispatch.locked?
+        dispatch.errors.add(:base, "Can't destroy this dispatch because it is locked.") 
+        false
+      end
+    end
+
+    delegate :subscription_for, to: :list
+
+    scope       :enabled,       lambda { where(state: :enabled) }
+    scope       :disabled,      lambda { where(state: :disabled) }
+    scope       :archived,      lambda { where(state: :archived) }
+    scope       :not_archived,  lambda { where("state != (?)", :archived) }
+
+    scope       :sequence,      lambda { where(type: Sequence) }
+    scope       :one_time_mailing, lambda { where(type: OneTimeMailing) }
+    scope       :periodical_mailing, lambda { where(type: PeriodicalMailing) }
+
+    def state
+      read_attribute(:state).to_sym
+    end
+
+    def enabled?
+      self.state == :enabled
+    end
+    def disabled?
+      self.state == :disabled
+    end
+    def archived?
+      self.state == :archived
+    end
+
+    def enable!
+      update_attribute(:state, "enabled")
+    end
+    def disable!
+      update_attribute(:state, "disabled")
+    end
+    def archive!
+      update_attribute(:state, "archived")
+    end
+
+    def enable
+      write_attribute(:state, "enabled")
+    end
+    def disable
+      write_attribute(:state, "disabled")
+    end
+    def archive
+      write_attribute(:state, "archived")
+    end
+
+    def list= l
+      l = MailyHerald::List.find_by_name(l.to_s) if l.is_a?(String) || l.is_a?(Symbol)
+      super(l)
+    end
+
+    def processable? entity
+      self.enabled? && (self.override_subscription? || self.list.subscribed?(entity)) && self.list.context.scope.exists?(entity)
+    end
+
+    def locked?
+      MailyHerald.dispatch_locked?(self.name)
+    end
+
+  end
+end

data/app/models/maily_herald/list.rb

@@ -0,0 +1,99 @@
+module MailyHerald
+  class List < ActiveRecord::Base
+    include MailyHerald::Autonaming
+
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :name, :title, :context_name
+    end
+
+    has_many :dispatches, class_name: "MailyHerald::Dispatch"
+    has_many :subscriptions, class_name: "MailyHerald::Subscription"
+
+    validate do |list|
+      list.errors.add(:base, "Can't change this list because it is locked.") if list.locked?
+    end
+    before_destroy do |list|
+      if list.locked?
+        list.errors.add(:base, "Can't destroy this list because it is locked.") 
+        false
+      end
+    end
+
+    def context
+      @context ||= MailyHerald.context self.context_name
+    end
+
+    def subscribe! entity
+      s = subscription_for(entity) 
+      s ? s.activate! : s = create_subscription_for(entity, true)
+      s
+    end
+
+    def unsubscribe! entity
+      s = subscription_for(entity) 
+      s ? s.deactivate! : s = create_subscription_for(entity, false)
+      s
+    end
+
+    def subscribed? entity
+      subscription_for(entity).try(:active?)
+    end
+
+    # true if user has inactive subscription or never been subscribed
+    def unsubscribed? entity
+      s = subscription_for(entity)
+      s ? !s.active? : true
+    end
+
+    # true only if user was intentionally unsubscribed
+    def opted_out? entity
+      s = subscription_for(entity)
+      s ? !s.active? : false
+    end
+
+    def subscription_for entity
+      self.subscriptions.for_entity(entity).first
+    end
+
+    def active_subscription_count
+      subscribers.count(:id)
+    end
+
+    # Returns entities within the context's scope with active subscription
+    def subscribers
+      context.scope_with_subscription(self).where("#{Subscription.table_name}.active = (?)", true).where("#{Subscription.table_name}.list_id = (?)", self.id)
+    end
+
+    # Returns entities within the context's scope with inactive subscription
+    def opt_outs
+      context.scope_with_subscription(self).where("#{Subscription.table_name}.active = (?)", false).where("#{Subscription.table_name}.list_id = (?)", self.id)
+    end
+
+    # Returns entities within the context's scope without subscription
+    def potential_subscribers
+      sq = context.scope_with_subscription(self, :outer).where("#{Subscription.table_name}.list_id = (?)", self.id).pluck("#{context.model.table_name}.id")
+      context.scope.where(context.model.arel_table[:id].not_in(sq))
+    end
+
+    def logs
+      #Log.for_mailings(self.dispatches.select("id"))
+      Log.for_mailings(Dispatch.where("sequence_id IN (?) OR list_id = (?)", Sequence.where(list_id: self.id).select("id"), self.id).select("id"))
+    end
+
+    def locked?
+      MailyHerald.list_locked?(self.name)
+    end
+
+    private
+
+    def create_subscription_for entity, active = false
+      s = self.subscriptions.build.tap do |s|
+        s.entity = entity
+        s.active = active
+      end
+      s.save!
+      s
+    end
+
+  end
+end

data/app/models/maily_herald/log.rb

@@ -0,0 +1,67 @@
+module MailyHerald
+  class Log < ActiveRecord::Base
+    AVAILABLE_STATUSES = [:scheduled, :delivered, :skipped, :error]
+
+    belongs_to  :entity,        polymorphic: true
+    belongs_to  :mailing,       class_name: "MailyHerald::Dispatch", foreign_key: :mailing_id
+
+    validates   :entity,        presence: true
+    validates   :mailing,       presence: true
+    validates   :status,        presence: true, inclusion: {in: AVAILABLE_STATUSES}
+
+    validates   :processing_at, presence: true, if: :scheduled?
+
+    scope       :ordered,       lambda { order("processing_at asc") }
+    scope       :for_entity,    lambda {|entity| where(entity_id: entity.id, entity_type: entity.class.base_class) }
+    scope       :for_mailing,   lambda {|mailing| where(mailing_id: mailing.id) }
+    scope       :for_mailings,  lambda {|mailings| where("mailing_id in (?)", mailings) }
+    scope       :delivered,     lambda { where(status: :delivered) }
+    scope       :skipped,       lambda { where(status: :skipped) }
+    scope       :error,         lambda { where(status: :error) }
+    scope       :scheduled,     lambda { where(status: :scheduled) }
+    scope       :processed,     lambda { where(status: [:delivered, :skipped, :error]) }
+
+    serialize   :data,          Hash
+
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :status, :data
+    end
+
+    def self.create_for mailing, entity, attributes = {}
+      log = Log.new
+      log.set_attributes_for mailing, entity, attributes
+      log.save!
+      log
+    end
+
+    def set_attributes_for mailing, entity, attributes = {}
+      self.mailing = mailing
+      self.entity = entity
+      self.entity_email = mailing.destination(entity)
+
+      self.processing_at = attributes[:processing_at] || DateTime.now
+      self.status = attributes[:status]
+      self.data = attributes[:data]
+    end
+
+    def status
+      read_attribute(:status).to_sym
+    end
+
+    def delivered?
+      self.status == :delivered
+    end
+
+    def skipped?
+      self.status == :skipped
+    end
+
+    def error?
+      self.status == :error
+    end
+
+    def scheduled?
+      self.status == :scheduled
+    end
+  end
+end

data/app/models/maily_herald/mailing.rb

@@ -1,12 +1,144 @@
 module MailyHerald
-  class Mailing < ActiveRecord::Base
-		attr_accessible :name, :context, :sequence, :conditions, :title, :sender, :delay, :template
+  class Mailing < Dispatch
+    include MailyHerald::TemplateRenderer
+    include MailyHerald::Autonaming
 
-		belongs_to :sequence, :class_name => "MailyHerald::Sequence"
-		has_many :records, :as => :mailing, :class_name => "MailyHerald::MailingRecord"
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :name, :title, :subject, :context_name, :override_subscription,
+                      :sequence, :conditions, :mailer_name, :title, :from, :relative_delay, :template, :start_at, :period
+    end
 
-		def has_conditions?
-			!conditions.empty?
-		end
+    has_many    :logs,          class_name: "MailyHerald::Log"
+    
+    validates   :subject,       presence: true, if: :generic_mailer?
+    validates   :template,      presence: true, if: :generic_mailer?
+    validate    :template_syntax
+    validate    :validate_conditions
+
+    before_validation do
+      write_attribute(:name, self.title.downcase.gsub(/\W/, "_")) if self.title && (!self.name || self.name.empty?)
+    end
+
+    after_initialize do
+      if self.new_record?
+        self.override_subscription = false
+        self.mailer_name = :generic
+      end
+    end
+
+    def periodical?
+      self.class == PeriodicalMailing
+    end
+
+    def one_time?
+      self.class == OneTimeMailing
+    end
+
+    def sequence?
+      self.class == SequenceMailing
+    end
+
+    def mailer_name
+      read_attribute(:mailer_name).to_sym
+    end
+
+    def mailer
+      if generic_mailer?
+        MailyHerald::Mailer
+      else
+        self.mailer_name.to_s.constantize
+      end
+    end
+
+    def has_conditions?
+      self.conditions && !self.conditions.empty?
+    end
+
+    def generic_mailer?
+      self.mailer_name == :generic
+    end
+
+    def conditions_met? entity
+      subscription = self.list.subscription_for(entity)
+
+      if self.list.context.attributes
+        evaluator = Utils::MarkupEvaluator.new(self.list.context.drop_for(entity, subscription))
+        evaluator.evaluate_conditions(self.conditions)
+      else
+        true
+      end
+    end
+
+    def destination entity
+      self.list.context.destination_for(entity)
+    end
+
+    def render_template entity
+      subscription = self.list.subscription_for(entity)
+      return unless subscription
+
+      drop = self.list.context.drop_for entity, subscription
+      perform_template_rendering drop, self.template
+    end
+
+    def render_subject entity
+      subscription = self.list.subscription_for(entity)
+      return unless subscription
+
+      drop = self.list.context.drop_for entity, subscription
+      perform_template_rendering drop, self.subject
+    end
+
+    def build_mail entity
+      if generic_mailer?
+        Mailer.generic(entity, self)
+      else
+        self.mailer.send(self.name, entity)
+      end
+    end
+
+    def deliver_to entity
+      build_mail(entity).deliver
+    end
+
+    protected
+
+    # Called from Mailer, block required
+    def deliver_with_mailer_to entity
+      unless processable?(entity)
+        MailyHerald.logger.log_processing(self, entity, prefix: "Not processable", level: :debug) 
+        return 
+      end
+
+      unless conditions_met?(entity)
+        MailyHerald.logger.log_processing(self, entity, prefix: "Conditions not met", level: :debug) 
+        return {status: :skipped}
+      end
+
+      mail = yield # Let mailer do his job
+
+      MailyHerald.logger.log_processing(self, entity, mail, prefix: "Processed") 
+
+      return {status: :delivered, data: {content: mail.to_s}}
+    rescue StandardError => e
+      MailyHerald.logger.log_processing(self, entity, prefix: "Error", level: :error) 
+      return {status: :error, data: {msg: "#{e.to_s}\n\n#{e.backtrace.join("\n")}"}}
+    end
+
+    private
+
+    def template_syntax
+      begin
+        template = Liquid::Template.parse(self.template)
+      rescue StandardError => e
+        errors.add(:template, e.to_s)
+      end
+    end
+
+    def validate_conditions
+      evaluator = Utils::MarkupEvaluator.test_conditions(self.conditions)
+    rescue StandardError => e
+      errors.add(:conditions, e.to_s) 
+    end
   end
 end