maily_herald 0.0.1 → 0.8.0

data/app/models/maily_herald/one_time_mailing.rb

@@ -0,0 +1,26 @@
+module MailyHerald
+  class OneTimeMailing < Mailing
+    validates   :list,          presence: true
+
+    # Returns array of Mail::Message
+    def run
+      self.list.subscriptions.collect do |subscription|
+        entity = subscription.entity
+
+        next unless processable?(entity)
+
+        deliver_to entity
+      end
+    end
+
+    # Returns single Mail::Message
+    def deliver_with_mailer_to entity
+      attrs = super entity
+      Log.create_for(self, entity, attrs) if attrs
+    end
+
+    def to_s
+      "<OneTimeMailing: #{self.title || self.name}>"
+    end
+  end
+end

data/app/models/maily_herald/periodical_mailing.rb

@@ -0,0 +1,145 @@
+module MailyHerald
+  class PeriodicalMailing < Mailing
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :period, :period_in_days
+    end
+
+    validates   :list,          presence: true
+    validates   :start_at,      presence: true
+    validates   :period,        presence: true, numericality: {greater_than: 0}
+
+    after_save :update_schedules_callback, if: Proc.new{|m| m.state_changed? || m.period_changed? || m.start_at_changed? || m.override_subscription?}
+
+    def period_in_days
+      "%.2f" % (self.period.to_f / 1.day.seconds)
+    end
+    def period_in_days= d
+      self.period = d.to_f.days
+    end
+
+    def deliver_to entity
+      super(entity)
+    end
+
+    def deliver_with_mailer_to entity
+      current_time = Time.now
+
+      schedule = schedule_for entity
+
+      schedule.with_lock do
+        # make sure schedule hasn't been processed in the meantime
+        if schedule && schedule.processing_at <= current_time && schedule.scheduled?
+          attrs = super(entity)
+          if attrs
+            schedule.attributes = attrs
+            schedule.processing_at = current_time
+            schedule.save!
+            set_schedule_for entity, schedule
+          end
+        end
+      end if schedule
+    end
+
+    def run
+      # TODO better scope here to exclude schedules for users outside context scope
+      schedules.where("processing_at <= (?)", Time.now).each do |schedule|
+        if schedule.entity
+          deliver_to schedule.entity
+        else
+          MailyHerald.logger.log_processing(schedule.mailing, {:class => schedule.entity_type, :id => schedule.entity_id}, prefix: "Removing schedule for non-existing entity") 
+          schedule.destroy
+        end
+      end
+    end
+
+    def processed_logs entity
+      Log.ordered.for_entity(entity).for_mailing(self).processed
+    end
+
+    def start_processing_time entity
+      if processed_logs(entity).first
+        processed_logs(entity).first.processed_at
+      else
+        begin
+          Time.parse(self.start_at)
+        rescue
+          subscription = self.list.subscription_for(entity)
+          evaluator = Utils::MarkupEvaluator.new(self.list.context.drop_for(entity, subscription))
+
+          evaluator.evaluate_variable(self.start_at)
+        end
+      end
+    end
+
+    def last_processing_time entity
+      processed_logs(entity).last.try(:processing_at)
+    end
+
+    def set_schedule_for entity, last_log = nil
+      # support entity with joined subscription table for better performance
+      if entity.has_attribute?(:maily_subscription_id)
+        subscribed = !!entity.maily_subscription_active
+      else
+        subscribed = self.list.subscribed?(entity)
+      end
+
+      if !self.period || !self.start_at || !enabled? || !(self.override_subscription? || subscribed)
+        log = schedule_for(entity)
+        log.try(:destroy)
+        return
+      end
+
+      log = schedule_for(entity)
+      last_log ||= processed_logs(entity).last
+
+      log ||= Log.new
+      log.with_lock do
+        log.set_attributes_for(self, entity, {
+          status: :scheduled,
+          processing_at: calculate_processing_time(entity, last_log)
+        })
+        log.save!
+      end
+      log
+    end
+
+    def update_schedules
+      self.list.context.scope_with_subscription(self.list, :outer).each do |entity|
+        MailyHerald.logger.debug "Updating schedule of #{self} periodical for entity ##{entity.id} #{entity}"
+        set_schedule_for entity
+      end
+    end
+
+    def update_schedules_callback
+      Rails.env.test? ? update_schedules : MailyHerald::ScheduleUpdater.perform_in(10.seconds, self.id)
+    end
+
+    def schedule_for entity
+      schedules.for_entity(entity).first
+    end
+
+    def schedules
+      Log.ordered.scheduled.for_mailing(self)
+    end
+
+    def calculate_processing_time entity, last_log = nil
+      last_log ||= processed_logs(entity).last
+
+      if last_log && last_log.processing_at
+        last_log.processing_at + self.period
+      elsif start_processing_time(entity)
+        start_processing_time(entity)
+      else
+        nil
+      end
+    end
+
+    def next_processing_time entity
+      schedule_for(entity).processing_at
+    end
+
+    def to_s
+      "<PeriodicalMailing: #{self.title || self.name}>"
+    end
+  end
+end

data/app/models/maily_herald/sequence.rb

@@ -1,5 +1,172 @@
 module MailyHerald
-  class Sequence < ActiveRecord::Base
-		has_many :records, :as => :mailing, :class_name => "MailingRecord"
+  MailyHerald::Subscription #TODO fix this autoload for dev
+
+  class Sequence < Dispatch
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :name, :title, :override_subscription,
+                      :conditions, :start_at, :period
+    end
+
+    include MailyHerald::Autonaming
+
+    has_many    :logs,                class_name: "MailyHerald::Log", through: :mailings
+    if Rails::VERSION::MAJOR == 3
+      has_many    :mailings,          class_name: "MailyHerald::SequenceMailing", order: "absolute_delay ASC", dependent: :destroy
+    else
+      has_many    :mailings,          -> { order("absolute_delay ASC") }, class_name: "MailyHerald::SequenceMailing", dependent: :destroy
+    end
+
+    validates   :list,                presence: true
+
+    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
+      end
+    end
+    after_save :update_schedules_callback, if: Proc.new{|s| s.state_changed? || s.start_at_changed?}
+
+    def mailing name, options = {}
+      if SequenceMailing.table_exists?
+        mailing = SequenceMailing.find_by_name(name)
+        lock = options.delete(:locked)
+
+        if block_given? && !MailyHerald.dispatch_locked?(name) && (!mailing || lock)
+          mailing ||= self.mailings.build(name: name)
+          mailing.sequence = self
+          yield(mailing)
+          mailing.skip_updating_schedules = true if self.new_record?
+          mailing.save!
+
+          MailyHerald.lock_dispatch(name) if lock
+        end
+
+        mailing
+      end
+    end
+
+    def run
+      # TODO better scope here to exclude schedules for users outside context scope
+      schedules.where("processing_at <= (?)", Time.now).each do |schedule|
+        if schedule.entity
+          schedule.mailing.deliver_to schedule.entity
+        else
+          MailyHerald.logger.log_processing(schedule.mailing, {:class => schedule.entity_type, :id => schedule.entity_id}, prefix: "Removing schedule for non-existing entity") 
+          schedule.destroy
+        end
+      end
+    end
+
+    def processed_logs entity
+      Log.ordered.processed.for_entity(entity).for_mailings(self.mailings.select(:id))
+    end
+
+    def processed_logs_for entity, mailing
+      Log.ordered.processed.for_entity(entity).for_mailing(self.mailings.find(mailing))
+    end
+
+    def last_processing_time entity
+      ls = processed_logs(entity)
+      ls.last.processing_at if ls.last
+    end
+
+    def pending_mailings entity
+      ls = processed_logs(entity)
+      ls.empty? ? self.mailings.enabled : self.mailings.enabled.where("id not in (?)", ls.map(&:mailing_id))
+    end
+
+    def processed_mailings entity
+      ls = processed_logs(entity)
+      ls.empty? ? self.mailings.where(id: nil) : self.mailings.where("id in (?)", ls.map(&:mailing_id))
+    end
+
+    def last_processed_mailing entity
+      processed_mailings(entity).last
+    end
+
+    def next_mailing entity
+      pending_mailings(entity).first
+    end
+
+    def mailing_processing_log_for entity, mailing
+      Log.ordered.processed.for_entity(entity).for_mailing(mailing).last
+    end
+
+    def set_schedule_for entity
+      # TODO handle override subscription?
+
+      # support entity with joined subscription table for better performance
+      if entity.has_attribute?(:maily_subscription_id)
+        subscribed = !!entity.maily_subscription_active
+      else
+        subscribed = self.list.subscribed?(entity)
+      end
+
+      if !subscribed || !self.start_at || !enabled? || !(mailing = next_mailing(entity))
+        log = schedule_for(entity)
+        log.try(:destroy)
+        return
+      end
+
+      log = schedule_for(entity)
+      log ||= Log.new
+      log.with_lock do
+        log.set_attributes_for(mailing, entity, {
+          status: :scheduled,
+          processing_at: calculate_processing_time_for(entity, mailing)
+        })
+        log.save!
+      end
+      log
+    end
+
+    def update_schedules
+      self.list.context.scope_with_subscription(self.list, :outer).each do |entity|
+        MailyHerald.logger.debug "Updating schedule of #{self} sequence for entity ##{entity.id} #{entity}"
+        set_schedule_for entity
+      end
+    end
+
+    def update_schedules_callback
+      Rails.env.test? ? update_schedules : MailyHerald::ScheduleUpdater.perform_in(10.seconds, self.id)
+    end
+
+    def schedule_for entity
+      schedules.for_entity(entity).first
+    end
+
+    def schedules
+      Log.ordered.scheduled.for_mailings(self.mailings.select(:id))
+    end
+
+    def calculate_processing_time_for entity, mailing = nil
+      mailing ||= next_mailing(entity)
+      ls = processed_logs(entity)
+
+      if ls.first
+        ls.last.processing_at + (mailing.absolute_delay - ls.last.mailing.absolute_delay)
+      else
+        begin
+          Time.parse(self.start_at) + mailing.absolute_delay
+        rescue
+          subscription = self.list.subscription_for(entity)
+          evaluator = Utils::MarkupEvaluator.new(self.list.context.drop_for(entity, subscription))
+          evaluated_start = evaluator.evaluate_variable(self.start_at)
+
+          evaluated_start + mailing.absolute_delay
+        end
+      end
+    end
+
+    def next_processing_time entity
+      schedule_for(entity).try(:processing_at)
+    end
+
+    def to_s
+      "<Sequence: #{self.title || self.name}>"
+    end
   end
 end

data/app/models/maily_herald/sequence_mailing.rb

@@ -0,0 +1,71 @@
+module MailyHerald
+  class SequenceMailing < Mailing
+    if Rails::VERSION::MAJOR == 3
+      attr_accessible :absolute_delay_in_days
+    end
+
+    attr_accessor :skip_updating_schedules
+
+    belongs_to  :sequence,      class_name: "MailyHerald::Sequence"
+
+    validates   :absolute_delay,presence: true, numericality: true
+    validates   :sequence,      presence: true
+    validate do
+      self.errors.add(:list_id, :invalid) if self.list_id != self.sequence.try(:list_id)
+    end
+
+    delegate    :subscription,  to: :sequence
+    delegate    :list,          to: :sequence
+
+    before_validation do
+      self.list_id = self.sequence.list_id
+    end
+
+    after_save if: Proc.new{|m| !m.skip_updating_schedules && (m.state_changed? || m.absolute_delay_changed?)} do
+      self.sequence.update_schedules_callback
+    end
+
+    def absolute_delay_in_days
+      "%.2f" % (self.absolute_delay.to_f / 1.day.seconds)
+    end
+    def absolute_delay_in_days= d
+      self.absolute_delay = d.to_f.days
+    end
+
+    def processed_to? entity
+      self.sequence.processed_mailings_for(entity).include?(self)
+    end
+
+    def deliver_to entity
+      super(entity)
+    end
+
+    def deliver_with_mailer_to entity
+      current_time = Time.now
+
+      schedule = self.sequence.schedule_for(entity)
+
+      schedule.with_lock do
+        # make sure schedule hasn't been processed in the meantime
+        if schedule && schedule.mailing == self && schedule.processing_at && schedule.processing_at <= current_time && schedule.scheduled?
+
+          attrs = super entity
+          if attrs
+            schedule.attributes = attrs
+            schedule.processing_at = current_time
+            schedule.save!
+            self.sequence.set_schedule_for(entity)
+          end
+        end
+      end if schedule
+    end
+
+    def override_subscription?
+      self.sequence.override_subscription? || super
+    end
+
+    def processable? entity
+      self.sequence.enabled? && super
+    end
+  end
+end

data/app/models/maily_herald/subscription.rb

@@ -0,0 +1,67 @@
+module MailyHerald
+  class Subscription < ActiveRecord::Base
+    belongs_to  :entity,        polymorphic: true
+    belongs_to  :list,          class_name: "MailyHerald::List"
+
+    validates   :entity,        presence: true
+    validates   :list,          presence: true
+    validates   :token,         presence: true, uniqueness: true
+    validate do
+      self.errors.add(:entity, :wrong_type) if self.entity_type != self.list.context.model.base_class.to_s
+    end
+
+    scope       :for_entity,    lambda {|entity| where(entity_id: entity.id, entity_type: entity.class.base_class.to_s) }
+    scope       :active,        lambda { where(active: true) }
+    scope       :for_model,     lambda {|model| joins("JOIN #{model.table_name} ON #{model.table_name}.id = #{Subscription.table_name}.entity_id AND #{Subscription.table_name}.entity_type = '#{model.base_class.to_s}'") }
+
+    serialize   :data,          Hash
+    serialize   :settings,      Hash
+
+    after_initialize do
+      if self.new_record?
+        self.token = MailyHerald::Utils.random_hex(20)
+      end
+    end
+
+    after_save :update_schedules, if: Proc.new{|s| s.active_changed?}
+
+    def active?
+      !new_record? && read_attribute(:active)
+    end
+
+    def deactivate!
+      update_attribute(:active, false)
+    end
+
+    def activate!
+      update_attribute(:active, true)
+    end
+
+    def toggle!
+      active? ? deactivate! : activate!
+    end
+
+    def token_url
+      MailyHerald::Engine.routes.url_helpers.ubsubscribe_url(self)
+    end
+
+    def to_liquid
+      {
+        "token_url" => token_url
+      }
+    end
+
+    def update_schedules
+      PeriodicalMailing.where(list_id: self.list).each do |m|
+        m.set_schedule_for self.entity
+      end
+      Sequence.where(list_id: self.list).each do |s|
+        s.set_schedule_for self.entity
+      end
+    end
+
+    def logs
+      self.list.logs.for_entity(self.entity)
+    end
+  end
+end