effective_messaging 0.1.8 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e35295ff8cf6a9a6853b90d759fac39fab3bc3c72525811069334ab8cf3fef34
-  data.tar.gz: aa9ae425f27a31c1451022c85c4d725fc5021c6086e3df9c2692294182288962
+  metadata.gz: be48cb89363c5dd4146206380ab6c0debf9a846d92d617237d9efd38ab7ea77c
+  data.tar.gz: '014369c2395911329879c116344837106cb6722ceb70f6e7413e71bff527fe52'
 SHA512:
-  metadata.gz: ee5b67860a4d555136248666481efd153549b9a1a1503a577e35c30d3f1f3d05933585dfed3a3be1f0fb6793211ef597c2bc187957fff8a0777fdd01b3ee36b0
-  data.tar.gz: 6bd025233cd26a5f6e99cd22e6601e190423dc3e3990d9ccb9976161a2436aaf56dfba8fa56f405c16fcbb8c2776b8d127d9fc81c12d4b11588ebe0752e91bfd
+  metadata.gz: f60c2115c09f7237c2a9d1ddcf0109e2f728d615d0ac364344692c0fea0872c3ce53a1960f8d801223d9deebc5f6d8e8f6037e92bab11bfcedc39ef9c7b6f4ce
+  data.tar.gz: c68ce9e88599ad0267615e43f860d13cce6c0f65f3ef799277923b100211648923abecedfd7496402101581b1c3749a168a3364e3bc32f41143eb615a60e1904

data/app/controllers/admin/notification_logs_controller.rb

@@ -0,0 +1,15 @@
+module Admin
+  class NotificationLogsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_messaging) }
+
+    include Effective::CrudController
+
+    private
+
+    def permitted_params
+      params.require(:effective_notification_log).permit!
+    end
+
+  end
+end

data/app/controllers/admin/notifications_controller.rb

@@ -5,7 +5,7 @@ module Admin
 
     include Effective::CrudController
 
-    submit :create_notification_job, 'Send Now'
+    submit :send_now, 'Send Now'
 
     private
 

data/app/datatables/admin/effective_notification_logs_datatable.rb

@@ -0,0 +1,22 @@
+module Admin
+  class EffectiveNotificationLogsDatatable < Effective::Datatable
+    datatable do
+      order :created_at
+
+      col :id, visible: false
+      col :created_at, as: :date, label: 'Date'
+
+      col :notification
+      col :report, visible: !attributes[:inline]
+      col :resource
+      col :user
+      col :email, visible: false
+
+      actions_col
+    end
+
+    collection do
+      Effective::NotificationLog.deep.all
+    end
+  end
+end

data/app/datatables/admin/effective_notifications_datatable.rb

@@ -2,8 +2,8 @@ module Admin
   class EffectiveNotificationsDatatable < Effective::Datatable
     filters do
       scope :all
-      scope :notifiable, label: 'Upcoming'
-      scope :completed, label: 'Past'
+      scope :enabled
+      scope :disabled
     end
 
     datatable do
@@ -13,8 +13,26 @@ module Admin
       col :created_at, visible: false
       col :id, visible: false
 
-      col :send_at
-      col :report, search: Effective::Report.emails.sorted
+      col :audience, visible: false
+
+      col :audience_emails, label: 'Send to' do |notification|
+        if notification.audience == 'emails'
+          notification.audience_emails.join(', ')
+        else
+          'report user'
+        end
+      end
+
+      col :enabled
+
+      col :schedule
+      col :schedule_type, visible: false
+      col :immediate_days, visible: false
+      col :immediate_times, visible: false
+      col :scheduled_method, visible: false
+      col :scheduled_dates, visible: false
+
+      col :report, search: Effective::Report.notifiable.sorted
 
       col :subject
       col :body, visible: false
@@ -23,9 +41,8 @@ module Admin
       col :cc, visible: false
       col :bcc, visible: false
 
-      col :started_at, visible: false
-      col :completed_at
-      col :notifications_sent, visible: false
+      col :last_notified_at
+      col :last_notified_count
 
       actions_col
     end

data/app/jobs/effective/notification_job.rb

@@ -1,9 +1,8 @@
 module Effective
   class NotificationJob < ApplicationJob
 
-    def perform(id, force)
-      notification = Notification.find(id)
-      notification.notify!(force: force)
+    def perform(id)
+      Notification.find(id).notify!
     end
 
   end

data/app/mailers/effective/notifications_mailer.rb

@@ -2,11 +2,33 @@ module Effective
   class NotificationsMailer < EffectiveMessaging.parent_mailer_class
     include EffectiveMailer
 
-    # Does not use effective_email_templates mailer
+    def notify(notification, opts = {})
+      raise('expected an Effective::Notification') unless notification.kind_of?(Effective::Notification)
+
+      # Returns a Hash of params to pass to mail()
+      # Includes a :to, :from, etc
+      rendered = notification.render_email
+
+      # Attach report
+      attach_report!(notification)
+
+      # Works with effective_logging to associate this email with the notification
+      headers = headers_for(notification, opts)
+
+      # Use postmark broadcast-stream
+      headers.merge!(message_stream: 'broadcast-stream') if defined?(Postmark)
+
+      # Calls effective_resources subject proc, so we can prepend [LETTERS]
+      subject = subject_for(__method__, rendered.fetch(:subject), notification, opts)
 
-    def notification(notification, resource, opts = {})
+      # Pass everything to mail
+      mail(rendered.merge(headers).merge(subject: subject))
+    end
+
+    # Does not use effective_email_templates mailer
+    def notify_resource(notification, resource, opts = {})
       raise('expected an Effective::Notification') unless notification.kind_of?(Effective::Notification)
-      raise('expected a resource') unless resource.present?
+      raise('expected an acts_as_reportable resource') unless resource.class.try(:acts_as_reportable?)
 
       # Returns a Hash of params to pass to mail()
       # Includes a :to, :from, etc
@@ -16,9 +38,7 @@ module Effective
       headers = headers_for(notification, opts)
 
       # Use postmark broadcast-stream
-      if defined?(Postmark)
-        headers.merge!(message_stream: 'broadcast-stream')
-      end
+      headers.merge!(message_stream: 'broadcast-stream') if defined?(Postmark)
 
       # Calls effective_resources subject proc, so we can prepend [LETTERS]
       subject = subject_for(__method__, rendered.fetch(:subject), resource, opts)
@@ -29,9 +49,30 @@ module Effective
 
     private
 
+    def attach_report!(notification)
+      return unless notification.attach_report?
+      raise("expected a scheduled email notification") unless notification.scheduled_email?
+
+      report = notification.report
+      raise("expected a report for notification id=#{notification.id}") unless report.present?
+
+      # Attach Report CSV built from datatables
+      datatable = EffectiveReportDatatable.new(view_context, report: report)
+
+      attachments["#{Time.zone.now.strftime('%F')}-#{report.to_s.parameterize}.csv"] = {
+        mime_type: datatable.csv_content_type,
+        content: datatable.csv_file
+      }
+    end
+
     def mailer_settings
       EffectiveMessaging
     end
 
+    # Authorization for the Datatables.
+    def authorize!(action, resource)
+      true
+    end
+
   end
 end

data/app/models/effective/notification.rb

@@ -16,13 +16,48 @@ module Effective
     belongs_to :user, polymorphic: true, optional: true
 
     # Effective namespace
-    belongs_to :report, class_name: 'Effective::Report'
+    belongs_to :report, class_name: 'Effective::Report', optional: true
+
+    # Tracks the send outs
+    has_many :notification_logs, dependent: :delete_all
+    accepts_nested_attributes_for :notification_logs
+
+    AUDIENCES = [
+      ['Send to user or email from the report', 'report'],
+      ['Send to specific addresses', 'emails']
+    ]
+
+    SCHEDULE_TYPES = [
+      ['On the first day they appear in the report and every x days thereafter', 'immediate'],
+      ['When present in the report on the following dates', 'scheduled']
+    ]
+
+    # TODO: ['Send once', 'Send daily', 'Send weekly', 'Send monthly', 'Send quarterly', 'Send yearly', 'Send now']
+    SCHEDULED_METHODS = [
+      ['The following dates...', 'dates'],
+    ]
 
     CONTENT_TYPES = ['text/plain', 'text/html']
 
     effective_resource do
-      send_at           :datetime
+      audience           :string
+      audience_emails    :text
+
+      enabled            :boolean
+      attach_report      :boolean
 
+      schedule_type      :string
+
+      # When the schedule is immediate. We send the email when they first appear in the data source
+      # And then every immediate_days after for immediate_times
+      immediate_days     :integer
+      immediate_times    :integer
+
+      # When the schedule id scheduled. We send the email to everyone in the audience on the given dates
+      scheduled_method    :string
+      scheduled_dates     :text
+
+      # Email
       subject           :string
       body              :text
 
@@ -30,51 +65,122 @@ module Effective
       cc                :string
       bcc               :string
 
-      # Tracking background jobs email send out
-      started_at         :datetime
-      completed_at       :datetime
-      notifications_sent :integer
+      # Background tracking
+      last_notified_at      :datetime
+      last_notified_count   :integer
 
       timestamps
     end
 
+    serialize :audience_emails, Array
+    serialize :scheduled_dates, Array
+
     scope :sorted, -> { order(:id) }
     scope :deep, -> { includes(report: :report_columns) }
 
-    scope :upcoming, -> { where('send_at > ?', Time.zone.now) }
-    scope :started, -> { where.not(started_at: nil) }
-    scope :completed, -> { where.not(completed_at: nil) }
+    scope :enabled, -> { where(enabled: true) }
+    scope :disabled, -> { where(enabled: false) }
+
+    before_validation do
+      self.from ||= EffectiveMessaging.froms.first
+    end
+
+    # Emails or Report
+    validates :audience, presence: true, inclusion: { in: AUDIENCES.map(&:last) }
+    validates :audience_emails, presence: true, if: -> { audience_emails? }
+
+    # Scheduled or Immediate
+    validates :schedule_type, presence: true, inclusion: { in: SCHEDULE_TYPES.map(&:last) }
+
+    # Attach Report - Only for scheduled emails
+    validates :attach_report, absence: true, unless: -> { scheduled_email? }
+
+    # Immediate
+    with_options(if: -> { immediate? }) do
+      validates :immediate_days, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :immediate_times, presence: true, numericality: { greater_than_or_equal_to: 1 }
+    end
 
-    # Called by the notifier rake task
-    scope :notifiable, -> { where(started_at: nil) }
+    # Scheduled
+    validates :scheduled_method, presence: true, inclusion: { in: SCHEDULED_METHODS.map(&:last) }, if: -> { scheduled? }
 
-    before_validation(if: -> { send_at_changed? }) do
-      assign_attributes(started_at: nil, completed_at: nil, notifications_sent: nil)
+    with_options(if: -> { scheduled_method.to_s == 'dates' }) do
+      validates :scheduled_dates, presence: true
     end
 
-    validates :send_at, presence: true
+    validate(if: -> { scheduled_dates.present? }) do
+      scheduled_dates.each do |str|
+        errors.add(:scheduled_dates, "expected a string") unless str.kind_of?(String)
+        errors.add(:scheduled_dates, "#{str} is an invalid date") unless (Time.zone.parse(str) rescue false)
+      end
+    end
+
+    # Email
     validates :from, presence: true, email: true
     validates :subject, presence: true, liquid: true
     validates :body, presence: true, liquid: true
 
+    # Report
+    validates :report, presence: true
+
     validate(if: -> { report.present? }) do
-      self.errors.add(:report, 'must include an email column') unless report.email_report_column.present?
+      errors.add(:report, 'must include an email or user column') unless report.email_report_column || report.user_report_column
     end
 
     validate(if: -> { report.present? && subject.present? }) do
       if(invalid = template_variables(body: false) - report_variables).present?
-        self.errors.add(:subject, "Invalid variable: #{invalid.to_sentence}")
+        errors.add(:subject, "Invalid variable: #{invalid.to_sentence}")
       end
     end
 
     validate(if: -> { report.present? && body.present? }) do
       if(invalid = template_variables(subject: false) - report_variables).present?
-        self.errors.add(:body, "Invalid variable: #{invalid.to_sentence}")
+        errors.add(:body, "Invalid variable: #{invalid.to_sentence}")
       end
     end
 
     def to_s
-      subject.presence || 'notification'
+      subject.presence || model_name.human
+    end
+
+    def schedule
+      if immediate?
+        "Send immediately then every #{immediate_days} days for #{immediate_times} times total"
+      elsif scheduled? && scheduled_method == 'dates'
+        "Send on #{scheduled_dates.length} scheduled days: #{scheduled_dates.sort.to_sentence}"
+      else
+        'todo'
+      end
+    end
+
+    def immediate?
+      schedule_type == 'immediate'
+    end
+
+    def scheduled?
+      schedule_type == 'scheduled'
+    end
+
+    def audience_emails?
+      audience == 'emails'
+    end
+
+    def audience_report?
+      audience == 'report'
+    end
+
+    # Only scheduled emails can have attached reports.
+    # Only scheduled emails can do Send Now
+    def scheduled_email?
+      scheduled? && audience_emails?
+    end
+
+    def audience_emails
+      Array(self[:audience_emails]) - [nil, '']
+    end
+
+    def scheduled_dates
+      Array(self[:scheduled_dates]) - [nil, '']
     end
 
     def template_subject
@@ -93,53 +199,111 @@ module Effective
       @rows_count ||= report.collection().count if report
     end
 
-    def in_progress?
-      started_at.present? && completed_at.blank?
-    end
-
-    def notifiable?
-      started_at.blank? && completed_at.blank?
+    # Button on the Admin interface. Enqueues the job to send right away.
+    def send_now!
+      raise('expected to be persisted') unless persisted?
+      NotificationJob.perform_later(id)
+      true
     end
 
-    def notify_now?
-      notifiable? && Time.zone.now >= send_at
+    # The main function
+    def notify!
+      scheduled_email? ? notify_by_schedule! : notify_by_resources!
     end
 
-    def notify!(force: false, limit: nil)
-      return false unless (notify_now? || force)
-
-      update!(started_at: Time.zone.now, completed_at: nil, notifications_sent: nil)
-
-      index = 0
+    # Operates on every resource in the data source. Sends one email for each row
+    def notify_by_resources!
+      notified = 0
 
       report.collection().find_each do |resource|
+        next unless notifiable?(resource)
         print('.')
 
+        # For logging
         assign_attributes(current_resource: resource)
-        Effective::NotificationsMailer.notification(self, resource).deliver_now
 
-        index += 1
-        break if limit && index >= limit
+        # Send the resource email
+        build_notification_log(resource: resource).save!
+        Effective::NotificationsMailer.notify_resource(self, resource).deliver_now
+
+        notified += 1
 
-        GC.start if (index % 250) == 0
+        GC.start if (notified % 250) == 0
       end
 
-      update!(current_resource: nil, completed_at: Time.zone.now, notifications_sent: index)
+      notified > 0 ? update!(last_notified_at: Time.zone.now, last_notified_count: notified) : touch
     end
 
-    # The 'Send Now' action on admin. Enqueues a job that calls notify!(force: true)
-    def create_notification_job!
-      update!(started_at: Time.zone.now, completed_at: nil, notifications_sent: nil)
+    def notify_by_schedule!
+      notified = 0
 
-      NotificationJob.perform_later(id, true) # force = true
-      true
+      if notifiable_scheduled?
+        build_notification_log(resource: nil).save!
+        Effective::NotificationsMailer.notify(self).deliver_now
+        notified += 1
+      end
+
+      notified > 0 ? update!(last_notified_at: Time.zone.now, last_notified_count: notified) : touch
+    end
+
+    def notifiable?(resource)
+      raise('expected an acts_as_reportable resource') unless resource.class.try(:acts_as_reportable?)
+
+      if schedule_type == 'immediate'
+        notifiable_immediate?(resource: resource)
+      elsif schedule_type == 'scheduled'
+        notifiable_scheduled?(date: nil)
+      else
+        raise("unsupported schedule_type")
+      end
     end
 
-    def render_email(resource)
-      raise('expected a resource') unless resource.present?
+    # Consider the notification logs which track how many and how long ago this notification was sent
+    # It's notifiable? when first time or if it's been immediate_days since last notification
+    def notifiable_immediate?(resource:)
+      raise('expected an immexiate? notification') unless immediate?
+
+      email = resource_email(resource) || resource_user(resource).try(:email)
+      raise("expected an email for #{report} #{report&.id} and #{resource} #{resource&.id}") unless email.present?
+
+      logs = notification_logs.select { |log| log.email == email }
+
+      if logs.count == 0
+        true # This is the first time. We should send.
+      elsif logs.count < immediate_times
+        # We still have to send it but consider dates.
+        last_sent_days_ago = logs.map(&:days_ago).min || 0
+        last_sent_days_ago >= immediate_days
+      else
+        false # We've already sent enough times
+      end
+    end
+
+    def notifiable_scheduled?(date: nil)
+      raise('expected a scheduled? notification') unless scheduled?
+
+      date ||= Time.zone.now.beginning_of_day
+
+      case scheduled_method
+      when 'dates'
+        scheduled_dates.find { |day| day == date.strftime('%F') }.present?
+      else
+        raise('unsupported scheduled_method')
+      end
+    end
+
+    def render_email(resource = nil)
+      raise('expected an acts_as_reportable resource') if resource.present? && !resource.class.try(:acts_as_reportable?)
+
+      to = if audience == 'emails'
+        audience_emails.presence
+      elsif audience == 'report'
+        resource_email(resource) || resource_user(resource).try(:email)
+      end
+
+      raise('expected a to email address') unless to.present?
 
       assigns = assigns_for(resource)
-      to = assigns.fetch(report.email_report_column.name) || raise('expected an email assigns')
 
       {
         to: to,
@@ -153,12 +317,23 @@ module Effective
     end
 
     def assigns_for(resource)
+      return {} unless resource.present?
+
       Array(report&.report_columns).inject({}) do |h, column|
         value = resource.send(column.name)
         h[column.name] = column.format(value); h
       end
     end
 
+    def build_notification_log(resource: nil)
+      user = resource_user(resource)
+
+      email = resource_email(resource) || user.try(:email)
+      email ||= audience_emails_to_s if scheduled_email?
+
+      notification_logs.build(email: email, report: report, resource: resource, user: user)
+    end
+
     private
 
     def template_variables(body: true, subject: true)
@@ -169,5 +344,27 @@ module Effective
       end.flatten.uniq.compact
     end
 
+    def audience_emails_to_s
+      audience_emails.presence&.join(',')
+    end
+
+    def resource_user(resource)
+      return unless resource.present?
+
+      column = report&.user_report_column
+      return unless column.present?
+
+      resource.public_send(column.name) || (resource if resource.respond_to?(:email))
+    end
+
+    def resource_email(resource)
+      return unless resource.present?
+
+      column = report&.email_report_column
+      return unless column.present?
+
+      resource.public_send(column.name)
+    end
+
   end
 end

data/app/models/effective/notification_log.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Effective
+  class NotificationLog < ActiveRecord::Base
+    self.table_name = EffectiveMessaging.notification_logs_table_name.to_s
+
+    belongs_to :notification
+
+    belongs_to :report, class_name: 'Effective::Report', optional: true
+    belongs_to :resource, polymorphic: true, optional: true
+    belongs_to :user, polymorphic: true, optional: true
+
+    effective_resource do
+      email        :string
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:id) }
+    scope :deep, -> { includes(:notification, :report, :resource, :user) }
+
+    validates :email, presence: true, email: true
+
+    def to_s
+      model_name.human
+    end
+
+    def days_ago
+      now = Time.zone.now.to_date
+      (now - (created_at&.to_date || now)).to_i
+    end
+
+  end
+end

data/app/views/admin/notification_logs/_notification_log.html.haml

@@ -0,0 +1 @@
+= effective_table_with(notification_log)

data/app/views/admin/notifications/_form.html.haml

@@ -3,5 +3,9 @@
     = render 'admin/notifications/form_notification', notification: notification
 
   - if notification.persisted? && notification.respond_to?(:logs_datatable)
+    = tab 'Notification Logs' do
+      - datatable = Admin::EffectiveNotificationLogsDatatable.new(notification: notification)
+      = render_inline_datatable(datatable)
+
     = tab 'Logs' do
-      = render_datatable(notification.logs_datatable)
+      = render_inline_datatable(notification.logs_datatable)

data/app/views/admin/notifications/_form_notification.html.haml

@@ -1,44 +1,63 @@
 = effective_form_with(model: [:admin, notification], engine: true) do |f|
-  %h2 Data Source
-  %p
-    Please select a
-    = link_to 'report', effective_reports.admin_reports_path, target: '_blank'
-    with an email report column to use as the data source.
+  %h2 Audience
+  %p Please select who the notifications should be sent to
+  = f.radios :audience, Effective::Notification::AUDIENCES, label: false, buttons: true
 
-  %p Each result from the report will be sent a notification.
+  = f.show_if(:audience, 'report') do
+    %p The notification will be sent to the user or email from the report.
 
-  .row
-    .col-md-6
-      = f.select :report_id, Effective::Report.sorted.emails.all, label: 'Report with email column',
-        'data-load-ajax-url': effective_messaging.new_admin_notification_path,
-        'data-load-ajax-div': '#effective-messaging-ajax'
+  = f.show_if(:audience, 'emails') do
+    %p The notification will be sent to the following address(es):
+
+    = f.select :audience_emails, f.object.audience_emails, label: 'Send to', multiple: true, tags: true, hint: 'Add one or more email address by pressing enter'
 
   %h2 Schedule
-  %p Please select a date when the notifications should be sent
+  %p Please select how and when the notifications should be sent
+
+  = f.check_box :enabled, label: "Yes, this notification is enabled and notification emails should be sent"
+
+  = f.show_if(:enabled, true) do
+    = f.select :schedule_type, Effective::Notification::SCHEDULE_TYPES
 
+    = f.show_if(:schedule_type, 'immediate') do
+      .d-flex
+        Send notification immediately and then every
+        .mx-3= f.number_field :immediate_days, label: false, min: 0, max: 365
+        day(s) thereafter, for
+        .mx-3= f.number_field :immediate_times, label: false, min: 1, max: 1000
+        total notification(s).
+
+    = f.show_if(:schedule_type, 'scheduled') do
+      /= f.radios :scheduled_method, Effective::Notification::SCHEDULED_METHODS, label: false, required: true
+      = f.hidden_field :scheduled_method, value: 'dates'
+
+      /= f.show_if(:scheduled_method, 'dates') do
+      %p Send notification on the following scheduled dates:
+      = f.select :scheduled_dates, f.object.scheduled_dates, label: false, multiple: true, tags: true, hint: 'Add one or more dates by pressing enter. Please input in the format YYYY-MM-DD'
+
+  %h2 Report
   .row
     .col-md-6
-      - minDate = [f.object.created_at, Time.zone.now].compact.min
+      = f.select :report_id, Effective::Report.sorted.notifiable.all,
+        hint: "Please select a #{link_to 'report', effective_reports.admin_reports_path, target: '_blank'} with a user or email column to use as the data source",
+        'data-load-ajax-url': effective_messaging.new_admin_notification_path,
+        'data-load-ajax-div': '#effective-messaging-ajax'
 
-      = f.datetime_field :send_at, label: 'Send the notification at', input_js: { minDate: minDate.strftime('%F %H:%M:%S') },
-        hint: 'A future date. Changing this value will reset the started_at and completed_at dates so this notification can be sent again.'
-    .col-md-6
-      - if f.object.completed_at.present?
-        = f.static_field :completed_at
-      - elsif f.object.started_at.present?
-        = f.static_field :started_at
+  = f.show_if(:audience, 'emails') do
+    = f.show_if(:schedule_type, 'scheduled') do
+      = f.check_box :attach_report, label: 'Yes, attach a .csv file with the report data', hint: 'only available to scheduled emails sent to specific addresses'
 
   %h2 Notification
-  %p The following notification will be sent to each row in the data source
+  %p The following email notification will be sent
 
-  - froms = Array(EffectiveMessaging.froms)
+  - froms = Array(EffectiveMessaging.froms) - [nil, '']
 
   - if froms.present?
-    - f.object.from ||= froms.first
-    = f.select :from, Array(froms)
+    = f.select :from, Array(froms).map { |from| [from, from] }
   - else
     = f.email_field :from
 
+  = f.email_field :bcc
   = f.text_field :subject
   = f.text_area :body
 
@@ -53,8 +72,8 @@
   = f.submit do
     = f.save 'Save'
 
-    - if f.object.persisted? && !f.object.in_progress?
-      = f.save 'Send Now', class: 'btn btn-warning', 'data-confirm': "Really send #{pluralize(notification.rows_count, 'notification')} now?"
+    - if EffectiveResources.authorized?(self, :send_now, f.object)
+      = f.save 'Send Now', class: 'btn btn-warning', 'data-confirm': "Really send now?"
 
     = f.save 'Add New', class: 'btn btn-secondary'
     = f.save 'Continue', class: 'btn btn-secondary'

data/app/views/admin/notifications/_notification.html.haml

@@ -6,31 +6,7 @@
 %p Currently there are #{pluralize(notification.rows_count, 'rows')} that would be notified.
 
 = card(notification) do
-  %table.table
-    %tbody
-      %tr
-        %th Send At
-        %td= notification.send_at.strftime('%F %H:%M')
-
-      %tr
-        %th Report
-        %td= link_to(notification.report, effective_reports.admin_report_path(notification.report), target: '_blank')
-
-      %tr
-        %th Current rows count
-        %td= notification.rows_count
-
-      %tr
-        %th Started At
-        %td= notification.started_at&.strftime('%F %H:%M') || 'Never'
-
-      %tr
-        %th Completed At
-        %td= notification.completed_at&.strftime('%F %H:%M') || 'Never'
-
-      %tr
-        %th Notifications Sent
-        %td= notification.notifications_sent.presence || 'None'
+  = effective_table_with(notification)
 
 - if notification.rows_count > 0
   %p Using a random row from the data source, a preview of the notification follows:

data/config/effective_messaging.rb

@@ -3,6 +3,7 @@ EffectiveMessaging.setup do |config|
   config.chat_users_table_name = :chat_users
   config.chat_messages_table_name = :chat_messages
   config.notifications_table_name = :notifications
+  config.notification_logs_table_name = :notification_logs
 
   # Layout Settings
   # Configure the Layout per controller, or all at once

data/config/routes.rb

@@ -14,6 +14,7 @@ EffectiveMessaging::Engine.routes.draw do
     resources :chats
     resources :chat_messages, only: [:index, :show, :destroy]
     resources :notifications
+    resources :notification_logs, only: [:index, :destroy]
   end
 
 end

data/db/migrate/01_create_effective_messaging.rb.erb

@@ -49,7 +49,19 @@ class CreateEffectiveMessaging < ActiveRecord::Migration[6.0]
 
       t.integer :report_id
 
-      t.datetime :send_at
+      t.string :audience
+      t.text :audience_emails
+
+      t.boolean :enabled, default: false
+      t.boolean :attach_report, default: false
+
+      t.string :schedule_type
+
+      t.integer :immediate_days
+      t.integer :immediate_times
+
+      t.string :scheduled_method
+      t.text :scheduled_dates
 
       t.string :subject
       t.text :body
@@ -58,9 +70,23 @@ class CreateEffectiveMessaging < ActiveRecord::Migration[6.0]
       t.string :cc
       t.string :bcc
 
-      t.datetime :started_at
-      t.datetime :completed_at
-      t.integer :notifications_sent
+      t.datetime :last_notified_at
+      t.integer :last_notified_count
+
+      t.timestamps
+    end
+
+    create_table <%= @notification_logs_table_name %>  do |t|
+      t.integer :notification_id
+      t.integer :report_id
+
+      t.integer :user_id
+      t.string :user_type
+
+      t.integer :resource_id
+      t.string :resource_type
+
+      t.string :email
 
       t.timestamps
     end

data/lib/effective_messaging/version.rb

@@ -1,3 +1,3 @@
 module EffectiveMessaging
-  VERSION = '0.1.8'.freeze
+  VERSION = '0.2.1'.freeze
 end

data/lib/effective_messaging.rb

@@ -7,7 +7,7 @@ module EffectiveMessaging
 
   def self.config_keys
     [
-      :chats_table_name, :chat_users_table_name, :chat_messages_table_name, :notifications_table_name,
+      :chats_table_name, :chat_users_table_name, :chat_messages_table_name, :notifications_table_name, :notification_logs_table_name,
       :layout,
       :froms,
       :mailer, :parent_mailer, :deliver_method, :mailer_layout, :mailer_sender, :mailer_admin, :mailer_subject
@@ -20,4 +20,8 @@ module EffectiveMessaging
     mailer&.constantize || Effective::MessagingMailer
   end
 
+  def self.Notification
+    Effective::Notification
+  end
+
 end

data/lib/generators/effective_messaging/install_generator.rb

@@ -24,6 +24,7 @@ module EffectiveMessaging
         @chat_users_table_name  = ':' + EffectiveMessaging.chat_users_table_name.to_s
         @chat_messages_table_name  = ':' + EffectiveMessaging.chat_messages_table_name.to_s
         @notifications_table_name  = ':' + EffectiveMessaging.notifications_table_name.to_s
+        @notification_logs_table_name  = ':' + EffectiveMessaging.notification_logs_table_name.to_s
 
         migration_template ('../' * 3) + 'db/migrate/01_create_effective_messaging.rb.erb', 'db/migrate/create_effective_messaging.rb'
       end

data/lib/tasks/effective_messaging_tasks.rake

@@ -1,22 +1,24 @@
-# rake effective_messaging:notify
+# rake effective_messaging:send_notifications
 namespace :effective_messaging do
   desc 'Sends scheduled notifications for effective messaging'
-  task notify: :environment do
+  task send_notifications: :environment do
     puts 'Sending notifications'
 
-    notifications = Effective::Notification.all.deep.notifiable
+    table = ActiveRecord::Base.connection.table_exists?(:notifications)
+    blank_tenant = defined?(Tenant) && Tenant.current.blank?
 
-    notifications.find_each do |notification|
-      begin
-        notified = notification.notify!
-        Rails.logger.info "Sent notifications for #{notification.report}" if notified
-      rescue => e
-        if defined?(ExceptionNotifier)
+    if table && !blank_tenant
+      notifications = Effective::Notification.all.deep.enabled
+
+      notifications.find_each do |notification|
+        begin
+          notification.notify!
+          Rails.logger.info "Sent notifications for #{notification} and #{notification.report}"
+        rescue => e
           data = { notification_id: notification.id, report_id: notification.report_id, resource_id: notification.current_resource&.id }
-          ExceptionNotifier.notify_exception(e, data: data)
+          ExceptionNotifier.notify_exception(e, data: data) if defined?(ExceptionNotifier)
+          puts "Error with effective_messaging #{notification.id} resource #{notification.current_resource&.id}: #{e.errors.inspect}"
         end
-
-        puts "Error with effective_messaging #{notification.id} resource #{notification.current_resource&.id}: #{e.errors.inspect}"
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_messaging
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-10 00:00:00.000000000 Z
+date: 2023-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -123,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: haml-rails
+  name: haml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,6 +150,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: effective_test_bot
   requirement: !ruby/object:Gem::Requirement
@@ -195,10 +209,12 @@ files:
 - app/assets/stylesheets/effective_messaging/base.scss
 - app/controllers/admin/chat_messages_controller.rb
 - app/controllers/admin/chats_controller.rb
+- app/controllers/admin/notification_logs_controller.rb
 - app/controllers/admin/notifications_controller.rb
 - app/controllers/effective/chats_controller.rb
 - app/datatables/admin/effective_chat_messages_datatable.rb
 - app/datatables/admin/effective_chats_datatable.rb
+- app/datatables/admin/effective_notification_logs_datatable.rb
 - app/datatables/admin/effective_notifications_datatable.rb
 - app/datatables/effective_chats_datatable.rb
 - app/helpers/effective_messaging_helper.rb
@@ -211,11 +227,13 @@ files:
 - app/models/effective/chat_message.rb
 - app/models/effective/chat_user.rb
 - app/models/effective/notification.rb
+- app/models/effective/notification_log.rb
 - app/views/admin/chat_messages/_chat_message.html.haml
 - app/views/admin/chats/_chat.html.haml
 - app/views/admin/chats/_form.html.haml
 - app/views/admin/chats/_form_chat.html.haml
 - app/views/admin/chats/_layout.html.haml
+- app/views/admin/notification_logs/_notification_log.html.haml
 - app/views/admin/notifications/_form.html.haml
 - app/views/admin/notifications/_form_notification.html.haml
 - app/views/admin/notifications/_notification.html.haml
@@ -256,7 +274,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Centralize the communication between one or more users.