maily_herald 0.8.0 → 0.9.1

data/app/models/maily_herald/periodical_mailing.rb

@@ -17,93 +17,90 @@ module MailyHerald
       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
-
+    # Sends mailing to all subscribed entities.
+    #
+    # Performs actual sending of emails; should be called in background.
+    #
+    # Returns array of {MailyHerald::Log} with actual `Mail::Message` objects stored
+    # in {MailyHerald::Log.mail} attributes.
     def run
       # TODO better scope here to exclude schedules for users outside context scope
-      schedules.where("processing_at <= (?)", Time.now).each do |schedule|
+      schedules.where("processing_at <= (?)", Time.now).collect do |schedule|
         if schedule.entity
-          deliver_to schedule.entity
+          mail = deliver schedule
+          schedule.reload
+          schedule.mail = mail
+          schedule
         else
-          MailyHerald.logger.log_processing(schedule.mailing, {:class => schedule.entity_type, :id => schedule.entity_id}, prefix: "Removing schedule for non-existing entity") 
+          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
 
+    # Returns collection of processed {Log}s for given entity.
     def processed_logs entity
       Log.ordered.for_entity(entity).for_mailing(self).processed
     end
 
+    # Returns processing time for given entity.
+    #
+    # This is the time when next mailing should be sent.
+    # Calculation is done mased on last processed mailing for this entity or
+    # {#start_at} mailing attribute.
     def start_processing_time entity
       if processed_logs(entity).first
-        processed_logs(entity).first.processed_at
+        processed_logs(entity).first.processing_at
       else
-        begin
-          Time.parse(self.start_at)
-        rescue
-          subscription = self.list.subscription_for(entity)
+        subscription = self.list.subscription_for(entity)
+
+        if has_start_at_proc?
+          start_at.call(entity, subscription)
+        else
           evaluator = Utils::MarkupEvaluator.new(self.list.context.drop_for(entity, subscription))
 
-          evaluator.evaluate_variable(self.start_at)
+          evaluator.evaluate_start_at(self.start_at)
         end
       end
     end
 
+    # Gets the timestamp of last processed email for given entity.
     def last_processing_time entity
       processed_logs(entity).last.try(:processing_at)
     end
 
+    # Sets the delivery schedule for given entity
+    #
+    # New schedule will be created or existing one updated.
+    #
+    # Schedule is {Log} object of type "schedule".
     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
+      subscribed = self.list.subscribed?(entity)
+      log = schedule_for(entity)
+      last_log ||= processed_logs(entity).last
+      processing_at = calculate_processing_time(entity, last_log)
 
-      if !self.period || !self.start_at || !enabled? || !(self.override_subscription? || subscribed)
+      if !self.period || !self.start_at || !enabled? || !processing_at || !(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)
+          processing_at: processing_at,
         })
         log.save!
       end
       log
     end
 
-    def update_schedules
+    # Sets delivery schedules of all entities in mailing scope.
+    #
+    # New schedules will be created or existing ones updated.
+    def set_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
@@ -111,29 +108,42 @@ module MailyHerald
     end
 
     def update_schedules_callback
-      Rails.env.test? ? update_schedules : MailyHerald::ScheduleUpdater.perform_in(10.seconds, self.id)
+      Rails.env.test? ? set_schedules : MailyHerald::ScheduleUpdater.perform_in(10.seconds, self.id)
     end
 
+    # Returns {Log} object which is the delivery schedule for given entity.
     def schedule_for entity
       schedules.for_entity(entity).first
     end
 
+    # Returns collection of all delivery schedules ({Log} collection).
     def schedules
       Log.ordered.scheduled.for_mailing(self)
     end
 
+    # Calculates processing time for given entity.
     def calculate_processing_time entity, last_log = nil
       last_log ||= processed_logs(entity).last
 
+      spt = start_processing_time(entity)
+
       if last_log && last_log.processing_at
         last_log.processing_at + self.period
-      elsif start_processing_time(entity)
-        start_processing_time(entity)
+      elsif individual_scheduling? && spt
+        spt
+      elsif general_scheduling?
+        if spt >= Time.now
+          spt
+        else
+          diff = (Time.now - spt).to_f
+          spt ? spt + ((diff/self.period).ceil * self.period) : nil
+        end
       else
         nil
       end
     end
 
+    # Get next email processing time for given entity.
     def next_processing_time entity
       schedule_for(entity).processing_at
     end
@@ -141,5 +151,24 @@ module MailyHerald
     def to_s
       "<PeriodicalMailing: #{self.title || self.name}>"
     end
+
+    private
+
+    def deliver_with_mailer schedule
+      current_time = Time.now
+
+      schedule.with_lock do
+        # make sure schedule hasn't been processed in the meantime
+        if schedule && schedule.processing_at <= current_time && schedule.scheduled?
+          schedule = super(schedule)
+          if schedule
+            schedule.processing_at = current_time if schedule.processed?
+            schedule.save!
+
+            set_schedule_for schedule.entity, schedule
+          end
+        end
+      end if schedule
+    end
   end
 end

data/app/models/maily_herald/sequence.rb

@@ -29,6 +29,15 @@ module MailyHerald
     end
     after_save :update_schedules_callback, if: Proc.new{|s| s.state_changed? || s.start_at_changed?}
 
+    # Fetches or defines an {SequenceMailing}.
+    #
+    # If no block provided, {SequenceMailing} with given +name+ is returned.
+    #
+    # If block provided, {SequenceMailing} with given +name+ is created or edited 
+    # and block is evaluated within that mailing.
+    #
+    # @option options [true, false] :locked (false) Determines whether Mailing is locked.
+    # @see Dispatch#locked?
     def mailing name, options = {}
       if SequenceMailing.table_exists?
         mailing = SequenceMailing.find_by_name(name)
@@ -48,45 +57,64 @@ module MailyHerald
       end
     end
 
+    # Sends sequence mailings to all subscribed entities.
+    #
+    # Performs actual sending of emails; should be called in background.
+    #
+    # Returns array of {MailyHerald::Log} with actual `Mail::Message` objects stored
+    # in {MailyHerald::Log.mail} attributes.
     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
+          mail = schedule.mailing.send(:deliver, schedule)
+          schedule.reload
+          schedule.mail = mail
+          schedule
         else
-          MailyHerald.logger.log_processing(schedule.mailing, {:class => schedule.entity_type, :id => schedule.entity_id}, prefix: "Removing schedule for non-existing entity") 
+          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
 
+    # Returns collection of processed {Log}s for given entity.
     def processed_logs entity
       Log.ordered.processed.for_entity(entity).for_mailings(self.mailings.select(:id))
     end
 
+    # Returns collection of processed {Log}s for given entity and mailing.
+    #
+    # @param entity [ActiveRecord::Base]
+    # @param mailing [SequenceMailing]
     def processed_logs_for entity, mailing
       Log.ordered.processed.for_entity(entity).for_mailing(self.mailings.find(mailing))
     end
 
+    # Gets the timestamp of last processed email for given entity.
     def last_processing_time entity
       ls = processed_logs(entity)
       ls.last.processing_at if ls.last
     end
 
+    # Gets collection of {SequenceMailing} objects that are to be sent to entity.
     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
 
+    # Gets collection of {SequenceMailing} objects that were sent to entity.
     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
 
+    # Gets last {SequenceMailing} object delivered to user.
     def last_processed_mailing entity
       processed_mailings(entity).last
     end
 
+    # Gets next {SequenceMailing} object to be delivered to user.
     def next_mailing entity
       pending_mailings(entity).first
     end
@@ -95,17 +123,19 @@ module MailyHerald
       Log.ordered.processed.for_entity(entity).for_mailing(mailing).last
     end
 
+    # Sets the delivery schedule for given entity
+    #
+    # New schedule will be created or existing one updated.
+    #
+    # Schedule is {Log} object of type "schedule".
     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
+      subscribed = self.list.subscribed?(entity)
+      mailing = next_mailing(entity)
+      start_time = calculate_processing_time_for(entity, mailing) if mailing
 
-      if !subscribed || !self.start_at || !enabled? || !(mailing = next_mailing(entity))
+      if !subscribed || !self.start_at || !enabled? || !mailing || !start_time 
         log = schedule_for(entity)
         log.try(:destroy)
         return
@@ -116,14 +146,17 @@ module MailyHerald
       log.with_lock do
         log.set_attributes_for(mailing, entity, {
           status: :scheduled,
-          processing_at: calculate_processing_time_for(entity, mailing)
+          processing_at: start_time,
         })
         log.save!
       end
       log
     end
 
-    def update_schedules
+    # Sets delivery schedules of all entities in mailing scope.
+    #
+    # New schedules will be created or existing ones updated.
+    def set_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
@@ -131,17 +164,20 @@ module MailyHerald
     end
 
     def update_schedules_callback
-      Rails.env.test? ? update_schedules : MailyHerald::ScheduleUpdater.perform_in(10.seconds, self.id)
+      Rails.env.test? ? set_schedules : MailyHerald::ScheduleUpdater.perform_in(10.seconds, self.id)
     end
 
+    # Returns {Log} object which is the delivery schedule for given entity.
     def schedule_for entity
       schedules.for_entity(entity).first
     end
 
+    # Returns collection of all delivery schedules ({Log} collection).
     def schedules
       Log.ordered.scheduled.for_mailings(self.mailings.select(:id))
     end
 
+    # Calculates processing time for given entity.
     def calculate_processing_time_for entity, mailing = nil
       mailing ||= next_mailing(entity)
       ls = processed_logs(entity)
@@ -149,18 +185,21 @@ module MailyHerald
       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)
+        subscription = self.list.subscription_for(entity)
+
+        if has_start_at_proc?
+          evaluated_start = start_at.call(entity, subscription)
+        else
           evaluator = Utils::MarkupEvaluator.new(self.list.context.drop_for(entity, subscription))
-          evaluated_start = evaluator.evaluate_variable(self.start_at)
 
-          evaluated_start + mailing.absolute_delay
+          evaluated_start = evaluator.evaluate_start_at(self.start_at)
         end
+
+        evaluated_start ? evaluated_start + mailing.absolute_delay : nil
       end
     end
 
+    # Get next email processing time for given entity.
     def next_processing_time entity
       schedule_for(entity).try(:processing_at)
     end

data/app/models/maily_herald/sequence_mailing.rb

@@ -21,9 +21,7 @@ module MailyHerald
       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
+    after_save :update_schedules_callback, if: Proc.new{|m| !m.skip_updating_schedules && (m.state_changed? || m.absolute_delay_changed?)} 
 
     def absolute_delay_in_days
       "%.2f" % (self.absolute_delay.to_f / 1.day.seconds)
@@ -32,40 +30,51 @@ module MailyHerald
       self.absolute_delay = d.to_f.days
     end
 
+    # Checks if mailing has been sent to given entity.
     def processed_to? entity
       self.sequence.processed_mailings_for(entity).include?(self)
     end
 
-    def deliver_to entity
-      super(entity)
+    def update_schedules_callback
+      self.sequence.update_schedules_callback
     end
 
-    def deliver_with_mailer_to entity
-      current_time = Time.now
+    # Returns collection of all delivery schedules ({Log} collection).
+    def schedules
+      self.sequence.schedules
+    end
 
-      schedule = self.sequence.schedule_for(entity)
+    def override_subscription?
+      self.sequence.override_subscription? || super
+    end
+
+    def processable? entity
+      self.sequence.enabled? && super
+    end
+
+    def locked?
+      MailyHerald.dispatch_locked?(self.sequence.name)
+    end
+
+    private
+
+    def deliver_with_mailer schedule
+      current_time = Time.now
 
       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 = super schedule
+          if schedule
+            schedule.processing_at = current_time if schedule.processed?
             schedule.save!
-            self.sequence.set_schedule_for(entity)
+
+            self.sequence.set_schedule_for(schedule.entity) if schedule.processed?
           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