effective_orders 5.3.2 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ff21e266d5908efc6a31250b6b265879e0e6c2330f598bd673fee6058f54b3d
-  data.tar.gz: c20fba9f6371012d5895bf17555ef003d88c57d19ba0a8e0b5e087d69b8eab0e
+  metadata.gz: 2781d889611f7bc0c7f5c09002b62ae45ad2ac4d271cd8f641cef63e1692fcc4
+  data.tar.gz: 5f8584ed6065c4caecec5b3699e9bbcd0c54c3a50fce1820bd7c10ef41c3cca9
 SHA512:
-  metadata.gz: 11dfee0b764d2b93259b0cde740ecc9fcd39b2f80d0c5dc5795ea76919ed27528fbeb69f2a84d99fc27cfe09feeab2d07bc9b809e804ce3e19abba210f51a42b
-  data.tar.gz: 05a83379f89294bf22f3c6010f944b62a4839e8129e14b6f8a81226a8315e555731afd76963a8cb0bbbe4ac9a3725dd9e46ce3d742fe84eddd993f254947e160
+  metadata.gz: f14479b485a00ad66b28544d2123d8fa504c6abef82669df4b91d844cf25163b29e8bc38b3ad9d468c0514833f7b68c9d4b5be9263d3df3b40c3c94ec7b0a376
+  data.tar.gz: d88561b37c3ffa64ecc3a79a20084dcbbb08bc0304d7213717fd06d0dcfa7f43bc6b480c3a36e164c45d9c6637e068a1069d7af6eb941f7319d434cf45c6071d

data/README.md

@@ -407,9 +407,9 @@ The payment processor handles collecting the Credit Card number, and through one
 
 Once the order has been marked purchased, the user is redirected to the `effective_orders.purchased_order_path` screen where they see a 'Thank You!' message, and the Order receipt.
 
-If the configuration option `config.mailer[:send_order_receipt_to_buyer] == true` the order receipt will be emailed to the user.
+If the configuration option `config.send_order_receipt_to_buyer == true` the order receipt will be emailed to the user.
 
-As well, if the configuration option `config.mailer[:send_order_receipt_to_admin] == true` the order receipt will be emailed to the site admin.
+As well, if the configuration option `config.send_order_receipt_to_admin == true` the order receipt will be emailed to the site admin.
 
 The Order has now been purchased.
 
@@ -427,7 +427,7 @@ If you are using effective_orders to roll your own custom payment workflow, you
 
 #### Send Order Receipts in the Background
 
-Emails will be sent immediately unless `config.mailer[:deliver_method] == :deliver_later`.
+Emails will be sent immediately unless `config.deliver_method == :deliver_later`.
 
 ### Effective::Order Model
 

data/app/controllers/effective/webhooks_controller.rb

@@ -89,18 +89,11 @@ module Effective
       end
     end
 
-    def send_email(email, *args)
-      raise('expected args to be an Array') unless args.kind_of?(Array)
+    def send_email(email, customer)
+      return unless EffectiveOrders.send_subscription_events
 
-      if defined?(Tenant)
-        tenant = Tenant.current || raise('expected a current tenant')
-        args << { tenant: tenant }
-      end
-
-      deliver_method = EffectiveOrders.mailer[:deliver_method] || EffectiveResources.deliver_method
-
-      EffectiveOrders.mailer_klass.send(email, *args).send(deliver_method)
-      EffectiveOrders.mailer_klass.send(:subscription_event_to_admin, email.to_s, *args).send(deliver_method)
+      EffectiveOrders.send_email(email, customer)
+      EffectiveOrders.send_email(:subscription_event_to_admin, email.to_s, customer)
     end
 
     def run_subscribable_buyer_callbacks!

data/app/mailers/effective/orders_mailer.rb

@@ -1,232 +1,169 @@
 module Effective
-  class OrdersMailer < ActionMailer::Base
-    default from: -> { EffectiveOrders.mailer[:default_from].presence }
-    default cc: -> { EffectiveOrders.mailer[:default_cc].presence }
-    default bcc: -> { EffectiveOrders.mailer[:default_bcc].presence }
-    layout -> { EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout' }
+  class OrdersMailer < EffectiveOrders.parent_mailer_class
+    include EffectiveMailer
 
     helper EffectiveOrdersHelper
 
-    def order_receipt_to_admin(order_param, atts = {})
-      around_mail_action(:order_receipt_to_admin, order_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_order_receipt_to_admin]
+    def order_receipt_to_admin(resource, opts = {})
+      raise('expected an Effective::Order') unless resource.kind_of?(Effective::Order)
 
-        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-        @user = @order.user
+      @order = resource
+      subject = subject_for(__method__, "Order Receipt: ##{@order.to_param}", resource, opts)
+      headers = headers_for(resource, opts)
 
-        @subject = subject_for(@order, :order_receipt_to_admin, "Order Receipt: ##{@order.to_param}")
-
-        mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
-      end
+      mail(to: mailer_admin, subject: subject, **headers)
     end
 
-    def order_receipt_to_buyer(order_param, atts = {})  # Buyer
-      around_mail_action(:order_receipt_to_buyer, order_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_order_receipt_to_buyer]
-
-        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-        @user = @order.user
+    def order_receipt_to_buyer(resource, opts = {})
+      raise('expected an Effective::Order') unless resource.kind_of?(Effective::Order)
 
-        @subject = subject_for(@order, :order_receipt_to_buyer, "Order Receipt: ##{@order.to_param}")
+      @order = resource
+      subject = subject_for(__method__, "Order Receipt: ##{@order.to_param}", resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail({to: @order.email, cc: @order.cc, subject: @subject}.compact)
-      end
+      mail(to: @order.email, cc: @order.cc.presence, subject: subject, **headers)
     end
 
     # This is sent when an admin creates a new order or /admin/orders/new
     # Or when Pay by Cheque or Pay by Phone (deferred payments)
     # Or uses the order action Send Payment Request
-    def payment_request_to_buyer(order_param, atts = {})
-      around_mail_action(:payment_request_to_buyer, order_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_payment_request_to_buyer]
-
-        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-        @user = @order.user
+    def payment_request_to_buyer(resource, opts = {})
+      raise('expected an Effective::Order') unless resource.kind_of?(Effective::Order)
 
-        @subject = subject_for(@order, :payment_request_to_buyer, "Payment request - Order ##{@order.to_param}")
+      @order = resource
+      subject = subject_for(__method__, "Payment request - Order ##{@order.to_param}", resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail({to: @order.email, cc: @order.cc, subject: @subject}.compact)
-      end
+      mail(to: @order.email, cc: @order.cc.presence, subject: subject, **headers)
     end
 
-
     # This is sent when someone chooses to Pay by Cheque
-    def pending_order_invoice_to_buyer(order_param, atts = {})
-      around_mail_action(:pending_order_invoice_to_buyer, order_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_pending_order_invoice_to_buyer]
+    def pending_order_invoice_to_buyer(resource, opts = {})
+      raise('expected an Effective::Order') unless resource.kind_of?(Effective::Order)
 
-        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-        @user = @order.user
+      @order = resource
+      subject = subject_for(__method__, "Pending Order: ##{@order.to_param}", resource, opts)
+      headers = headers_for(resource, opts)
 
-        @subject = subject_for(@order, :pending_order_invoice_to_buyer, "Pending Order: ##{@order.to_param}")
-
-        mail({to: @order.email, cc: @order.cc, subject: @subject}.compact)
-      end
+      mail(to: @order.email, cc: @order.cc.presence, subject: subject, **headers)
     end
 
     # This is sent to admin when someone Accepts Refund
-    def refund_notification_to_admin(order_param, atts = {})
-      around_mail_action(:refund_notification_to_admin, order_param, atts) do
-        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-        @user = @order.user
+    def refund_notification_to_admin(order, opts = {})
+      raise('expected an Effective::Order') unless resource.kind_of?(Effective::Order)
 
-        @subject = subject_for(@order, :refund_notification_to_admin, "New Refund: ##{@order.to_param}")
+      @order = resource
+      subject = subject_for(__method__, "New Refund: ##{@order.to_param}", resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
-      end
+      mail(to: mailer_admin, subject: subject, **headers)
     end
 
     # Sent by the invoice.payment_succeeded webhook event
-    def subscription_payment_succeeded(customer_param, atts = {})
-      around_mail_action(:subscription_payment_succeeded, customer_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_payment_succeeded]
-
-        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
-        @subscriptions = @customer.subscriptions
-        @user = @customer.user
+    def subscription_payment_succeeded(resource, opts = {})
+      raise('expected an Effective::Customer') unless resource.kind_of?(Effective::Customer)
 
-        @subject = subject_for(@customer, :subscription_payment_succeeded, 'Thank you for your payment')
+      @customer = resource
+      subject = subject_for(__method__, 'Thank you for your payment', resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail(to: @customer.user.email, subject: @subject)
-      end
+      mail(to: @customer.user.email, subject: subject, **headers)
     end
 
     # Sent by the invoice.payment_failed webhook event
-    def subscription_payment_failed(customer_param, atts = {})
-      around_mail_action(:subscription_payment_failed, customer_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_payment_failed]
-
-        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
-        @subscriptions = @customer.subscriptions
-        @user = @customer.user
+    def subscription_payment_failed(resource, opts = {})
+      raise('expected an Effective::Customer') unless resource.kind_of?(Effective::Customer)
 
-        @subject = subject_for(@customer, :subscription_payment_failed, 'Payment failed - please update your card details')
+      @customer = resource
+      subject = subject_for(__method__, 'Payment failed - please update your card details', resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail(to: @customer.user.email, subject: @subject)
-      end
+      mail(to: @customer.user.email, subject: subject, **headers)
     end
 
     # Sent by the customer.subscription.created webhook event
-    def subscription_created(customer_param, atts = {})
-      around_mail_action(:subscription_created, customer_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_created]
-
-        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
-        @subscriptions = @customer.subscriptions
-        @user = @customer.user
+    def subscription_created(resource, opts = {})
+      raise('expected an Effective::Customer') unless resource.kind_of?(Effective::Customer)
 
-        @subject = subject_for(@customer, :subscription_created, 'New Subscription')
+      @customer = resource
+      subject = subject_for(__method__, 'New Subscription', resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail(to: @customer.user.email, subject: @subject)
-      end
+      mail(to: @customer.user.email, subject: subject, **headers)
     end
 
     # Sent by the customer.subscription.updated webhook event
-    def subscription_updated(customer_param, atts = {})
-      around_mail_action(:subscription_updated, customer_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_updated]
-
-        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
-        @subscriptions = @customer.subscriptions
-        @user = @customer.user
+    def subscription_updated(resource, opts = {})
+      raise('expected an Effective::Customer') unless resource.kind_of?(Effective::Customer)
 
-        @subject = subject_for(@customer, :subscription_updated, 'Subscription Changed')
+      @customer = resource
+      subject = subject_for(__method__, 'Subscription Changed', resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail(to: @customer.user.email, subject: @subject)
-      end
+      mail(to: @customer.user.email, subject: subject, **headers)
     end
 
-    # Sent by the invoice.payment_failed webhook event
-    def subscription_canceled(customer_param, atts = {})
-      around_mail_action(:subscription_canceled, customer_param, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_canceled]
-
-        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
-        @subscriptions = @customer.subscriptions
-        @user = @customer.user
+     # Sent by the invoice.payment_failed webhook event
+     def subscription_canceled(resource, opts = {})
+      raise('expected an Effective::Customer') unless resource.kind_of?(Effective::Customer)
 
-        @subject = subject_for(@customer, :subscription_canceled, 'Subscription canceled')
+      @customer = resource
+      subject = subject_for(__method__, 'Subscription canceled', resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail(to: @customer.user.email, subject: @subject)
-      end
+      mail(to: @customer.user.email, subject: subject, **headers)
     end
 
     # Sent by the effective_orders:notify_trial_users rake task.
-    def subscription_trialing(subscribable, atts = {})
-      around_mail_action(:subscription_trialing, subscribable, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_trialing]
+    def subscription_trialing(resource, opts = {})
+      raise('expected a subscribable resource') unless resource.respond_to?(:subscribable_buyer)
 
-        @subscribable = subscribable
-        @user = @subscribable.subscribable_buyer
+      @subscribable = resource
+      subject = subject_for(__method__, 'Trial is active', resource, opts)
+      headers = headers_for(resource, opts)
 
-        @subject = subject_for(@customer, :subscription_trialing, 'Trial is active')
-
-        mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
-      end
+      mail(to: @subscribable.subscribable_buyer.email, subject: subject, **headers)
     end
 
     # Sent by the effective_orders:notify_trial_users rake task.
-    def subscription_trial_expired(subscribable, atts = {})
-      around_mail_action(:subscription_trial_expired, subscribable, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_trial_expired]
+    def subscription_trial_expired(resource, opts = {})
+      raise('expected a subscribable resource') unless resource.respond_to?(:subscribable_buyer)
 
-        @subscribable = subscribable
-        @user = @subscribable.subscribable_buyer
+      @subscribable = resource
+      subject = subject_for(__method__, 'Trial expired', resource, opts)
+      headers = headers_for(resource, opts)
 
-        @subject = subject_for(@customer, :subscription_trial_expired, 'Trial expired')
-
-        mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
-      end
+      mail(to: @subscribable.subscribable_buyer.email, subject: subject, **headers)
     end
 
-    def subscription_event_to_admin(event, customer_param, atts = {})
-      around_mail_action(:subscription_event_to_admin, event, atts) do
-        return true unless EffectiveOrders.mailer[:send_subscription_event_to_admin]
+    def subscription_event_to_admin(event, resource, opts = {})
+      raise('expected an event') unless event.present?
+      raise('expected an Effective::Customer') unless resource.kind_of?(Effective::Customer)
 
-        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
-        @subscriptions = @customer.subscriptions
-        @user = @customer.user
-        @event = event.to_s
+      @event = event
+      @customer = resource
 
-        @subject = subject_for(@customer, :subscription_event_to_admin, "Subscription event - @event - @customer").gsub('@event', @event.to_s).gsub('@customer', @customer.to_s)
+      subject = subject_for(__method__, "Subscription event - #{@event} - #{@customer}", resource, opts)
+      headers = headers_for(resource, opts)
 
-        mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
-      end
+      mail(to: mailer_admin, subject: subject, **headers)
     end
 
+    # This is only called by EffectiveQbSync
     def order_error(order: nil, error: nil, to: nil, from: nil, subject: nil, template: 'order_error')
-      around_mail_action(:order_error, order, {error: error, to: to, from: from, subject: subject, template: template}) do
-        @order = (order.kind_of?(Effective::Order) ? order : Effective::Order.find(order))
-        @error = error.to_s
-
-        @subject = subject_for(@order, :error, "An error occurred with order: ##{@order.try(:to_param)}")
-
-        mail(
-          to: (to || EffectiveOrders.mailer[:admin_email]),
-          from: (from || EffectiveOrders.mailer[:default_from]),
-          subject: (subject || @subject)
-        ) do |format|
-          format.html { render(template) }
-        end
-      end
-    end
-
-    protected
+      raise('expected an Effective::Order') unless order.kind_of?(Effective::Order)
 
-    def around_mail_action(name, param, atts = {}, &block)
-      yield
-    end
-
-    private
+      @order = order
+      @error = error.to_s
 
-    def subject_for(order, action, fallback)
-      subject = EffectiveOrders.mailer["subject_for_#{action}".to_sym]
-      prefix = EffectiveOrders.mailer[:subject_prefix].to_s
+      to ||= EffectiveOrders.mailer_admin
+      from ||= EffectiveOrders.mailer_sender
+      subject ||= subject_for(__method__,"An error occurred with order: ##{@order.to_param}", resource, opts)
+      headers = headers_for(resource, opts)
 
-      subject = self.instance_exec(order, &subject) if subject.respond_to?(:call)
-      subject = subject.presence || fallback
-
-      prefix.present? ? (prefix.chomp(' ') + ' ' + subject) : subject
+      mail(to: to, from: from, subject: subject, **headers) do |format|
+        format.html { render(template) }
+      end
     end
 
   end

data/app/models/effective/order.rb

@@ -419,17 +419,17 @@ module Effective
     end
 
     def send_order_receipt_to_admin?
-      return false if free? && !EffectiveOrders.mailer[:send_order_receipts_when_free]
-      EffectiveOrders.mailer[:send_order_receipt_to_admin]
+      return false if free? && !EffectiveOrders.send_order_receipts_when_free
+      EffectiveOrders.send_order_receipt_to_admin
     end
 
     def send_order_receipt_to_buyer?
-      return false if free? && !EffectiveOrders.mailer[:send_order_receipts_when_free]
-      EffectiveOrders.mailer[:send_order_receipt_to_buyer]
+      return false if free? && !EffectiveOrders.send_order_receipts_when_free
+      EffectiveOrders.send_order_receipt_to_buyer
     end
 
     def send_payment_request_to_buyer?
-      return false if free? && !EffectiveOrders.mailer[:send_order_receipts_when_free]
+      return false if free? && !EffectiveOrders.send_order_receipts_when_free
       return false if refund?
 
       EffectiveResources.truthy?(send_payment_request_to_buyer)
@@ -587,23 +587,23 @@ module Effective
     end
 
     def send_order_receipt_to_admin!
-      send_email(:order_receipt_to_admin, to_param) if purchased?
+      EffectiveOrders.send_email(:order_receipt_to_admin, self) if purchased?
     end
 
     def send_order_receipt_to_buyer!
-      send_email(:order_receipt_to_buyer, to_param) if purchased?
+      EffectiveOrders.send_email(:order_receipt_to_buyer, self) if purchased?
     end
 
     def send_payment_request_to_buyer!
-      send_email(:payment_request_to_buyer, to_param) unless purchased?
+      EffectiveOrders.send_email(:payment_request_to_buyer, self) unless purchased?
     end
 
     def send_pending_order_invoice_to_buyer!
-      send_email(:pending_order_invoice_to_buyer, to_param) unless purchased?
+      EffectiveOrders.send_email(:pending_order_invoice_to_buyer, self) unless purchased?
     end
 
     def send_refund_notification!
-      send_email(:refund_notification_to_admin, to_param) if purchased? && refund?
+      EffectiveOrders.send_email(:refund_notification_to_admin, self) if purchased? && refund?
     end
 
     def skip_qb_sync!
@@ -707,23 +707,6 @@ module Effective
       true
     end
 
-    def send_email(email, *args)
-      raise('expected args to be an Array') unless args.kind_of?(Array)
-
-      if defined?(Tenant)
-        tenant = Tenant.current || raise('expected a current tenant')
-        args << { tenant: tenant }
-      end
-
-      deliver_method = EffectiveOrders.mailer[:deliver_method] || EffectiveResources.deliver_method
-
-      begin
-        EffectiveOrders.mailer_klass.send(email, *args).send(deliver_method)
-      rescue => e
-        raise if Rails.env.development? || Rails.env.test?
-      end
-    end
-
     def payment_to_h(payment)
       if payment.respond_to?(:to_unsafe_h)
         payment.to_unsafe_h.to_h

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

@@ -15,7 +15,7 @@
 
     = f.check_box :send_payment_request_to_buyer,
       label: 'Yes, send a payment request email to the buyer and any cc.',
-      value: (f.object.send_payment_request_to_buyer.nil? ? EffectiveOrders.mailer[:send_payment_request_to_buyer] : f.object.send_payment_request_to_buyer?)
+      value: (f.object.send_payment_request_to_buyer.nil? ? EffectiveOrders.send_payment_request_to_buyer : f.object.send_payment_request_to_buyer?)
 
   .row
     .col-md-6.effective-order-note-to-buyer

data/app/views/effective/orders/mark_as_paid/_form.html.haml

@@ -19,7 +19,7 @@
 
       = f.check_box :send_mark_as_paid_email_to_buyer,
         label: 'Yes, send a receipt email to the buyer.',
-        input_html: { checked: (f.object.send_mark_as_paid_email_to_buyer.nil? ? EffectiveOrders.mailer[:send_order_receipts_when_mark_as_paid] : f.object.send_mark_as_paid_email_to_buyer?) }
+        input_html: { checked: (f.object.send_mark_as_paid_email_to_buyer.nil? ? EffectiveOrders.send_order_receipts_when_mark_as_paid : f.object.send_mark_as_paid_email_to_buyer?) }
 
       = f.text_area :note_to_buyer, hint: 'This message will be displayed on the receipt.'
 

data/config/effective_orders.rb

@@ -72,68 +72,37 @@ EffectiveOrders.setup do |config|
   config.pretend_message = '* payment information is not required to process this order at this time.'
 
   # Mailer Settings
-  # effective_orders sends out receipts to buyers and admins as well as trial and subscription related emails.
-  # For all the emails, the same :subject_prefix will be prefixed.  Leave as nil / empty string if you don't want any prefix
+  # Please see config/initializers/effective_resources.rb for default effective_* gem mailer settings
   #
-  # All the subject_* keys below can one of:
-  # - nil / empty string to use the built in defaults
-  # - A string with the full subject line for this email
-  # - A Proc to create the subject line based on the email
-  # The subject_prefix will then be applied ontop of these.
+  # Configure the class responsible to send e-mails.
+  # config.mailer = 'Effective::OrdersMailer'
   #
-  # send_order_receipt_to_buyer: Proc.new { |order| "Order #{order.to_param} has been purchased"}
-  # subject_for_subscription_payment_succeeded: Proc.new { |order| "Order #{order.to_param} has been purchased"}
-
-  # subject_for_subscription_trialing: Proc.new { |subscribable| "Pending Order #{order.to_param}"}
-
-  # Use this mailer class. You can extend.
-  config.mailer_class_name = 'Effective::OrdersMailer'
-
-  config.mailer = {
-    send_order_receipt_to_admin: true,
-    send_order_receipt_to_buyer: true,
-    send_payment_request_to_buyer: true,
-    send_pending_order_invoice_to_buyer: true,
-    send_order_receipts_when_mark_as_paid: false,
-    send_order_receipts_when_free: false,
-
-    send_subscription_event_to_admin: true,
-    send_subscription_created: true,
-    send_subscription_updated: true,
-    send_subscription_canceled: true,
-    send_subscription_payment_succeeded: true,
-    send_subscription_payment_failed: true,
-
-    send_subscription_trialing: true,   # Only if you schedule the rake task to run
-    send_subscription_trial_expired: true,    # Only if you schedule the rake task to run
-
-    subject_prefix: '[example]',
-
-    # Procs yield an Effective::Order object
-    subject_for_order_receipt_to_admin: '',
-    subject_for_order_receipt_to_buyer: '',
-    subject_for_payment_request_to_buyer: '',
-    subject_for_pending_order_invoice_to_buyer: '',
-    subject_for_refund_notification_to_admin: '',
+  # Override effective_resource mailer defaults
+  #
+  # config.parent_mailer = nil      # The parent class responsible for sending emails
+  # config.deliver_method = nil     # The deliver method, deliver_later or deliver_now
+  # config.mailer_layout = nil      # Default mailer layout
+  # config.mailer_sender = nil      # Default From value
+  # config.mailer_admin = nil       # Default To value for Admin correspondence
+  # config.mailer_subject = nil     # Proc.new method used to customize Subject
 
-    # Procs yield an Effective::Customer object
-    subject_for_subscription_created: '',
-    subject_for_subscription_updated: '',
-    subject_for_subscription_canceled: '',
-    subject_for_subscription_payment_succeeded: '',
-    subject_for_subscription_payment_failed: '',
+  config.mailer_layout = 'effective_orders_mailer_layout'
 
-    # Procs yield the acts_as_subscribable object
-    subject_for_subscription_trialing: '',
-    subject_for_subscription_trial_expired: '',
+  # Email settings
+  config.send_order_receipt_to_admin = true
+  config.send_order_receipt_to_buyer = true
+  config.send_payment_request_to_buyer = true
+  config.send_pending_order_invoice_to_buyer = true
 
-    layout: 'effective_orders_mailer_layout',
+  config.send_order_receipts_when_mark_as_paid = true
+  config.send_order_receipts_when_free = true
 
-    default_from: 'info@example.com',
-    admin_email: 'admin@example.com',   # Refund notifications will also be sent here
+  # Stripe Webhooks controller
+  config.send_subscription_events = true
 
-    deliver_method: nil  # When nil, will try deliver_later and fallback to deliver_now
-  }
+  # These two only take affect if you schedule the rake task to run
+  config.send_subscription_trialing = true
+  config.send_subscription_trial_expired = true
 
   #######################################
   ## Payment Provider specific options ##
@@ -226,7 +195,7 @@ EffectiveOrders.setup do |config|
   # Refunds
   # This does not issue a refund with the payment processor at all.
   # Instead, we mark the order as purchased, create a refund object to track it, and
-  # send an email to mailer[:admin_email] with instructions to issue a refund
+  # send an email to config.mailer_admin with instructions to issue a refund
   config.refund = false
 
   # config.refund = {

data/lib/effective_orders/engine.rb

@@ -23,8 +23,8 @@ module EffectiveOrders
 
     initializer 'effective_orders.refund', after: :load_config_initializers do
       if EffectiveOrders.refund?
-        unless (EffectiveOrders.mailer[:admin_email].to_s.include?('@') rescue false)
-          raise("config.mailer[:admin_email] must be present when refunds enabled.")
+        unless (EffectiveOrders.mailer_admin.to_s.include?('@') rescue false)
+          raise("config.mailer_admin must be present when refunds enabled.")
         end
       end
     end

data/lib/effective_orders/version.rb

@@ -1,3 +1,3 @@
 module EffectiveOrders
-  VERSION = '5.3.2'.freeze
+  VERSION = '5.4.0'.freeze
 end

data/lib/effective_orders.rb

@@ -33,15 +33,25 @@ module EffectiveOrders
     [
       :orders_table_name, :order_items_table_name, :carts_table_name, :cart_items_table_name,
       :customers_table_name, :subscriptions_table_name, :products_table_name,
-      :layout, :mailer_class_name, :mailer,
+      :layout,
       :orders_collection_scope, :order_tax_rate_method,
       :obfuscate_order_ids, :use_effective_qb_sync, :use_effective_qb_online,
       :billing_address, :shipping_address,
       :collect_note, :collect_note_required, :collect_note_message,
       :terms_and_conditions, :terms_and_conditions_label, :minimum_charge,
 
+      # Mailer
+      :mailer, :parent_mailer, :deliver_method, :mailer_layout, :mailer_sender, :mailer_admin, :mailer_subject,
+
+      # Emails
+      :send_order_receipt_to_admin, :send_order_receipt_to_buyer, :send_payment_request_to_buyer, :send_pending_order_invoice_to_buyer,
+      :send_order_receipts_when_mark_as_paid, :send_order_receipts_when_free,
+      :send_subscription_events,
+      :send_subscription_trialing, :send_subscription_trial_expired,
+
       # Features
       :free_enabled, :mark_as_paid_enabled, :pretend_enabled, :pretend_message,
+
       # Payment processors. false or Hash
       :cheque, :moneris, :moneris_checkout, :paypal, :phone, :refund, :stripe, :subscriptions, :trial
     ]
@@ -144,9 +154,8 @@ module EffectiveOrders
     use_effective_qb_online && defined?(EffectiveQbOnline)
   end
 
-  def self.mailer_klass
-    name = mailer_class_name.presence || 'Effective::OrdersMailer'
-    name.safe_constantize || raise("unable to constantize mailer class. check config.mailer_class_name")
+  def self.mailer_class
+    mailer&.constantize || Effective::OrdersMailer
   end
 
   def self.can_skip_checkout_step1?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_orders
 version: !ruby/object:Gem::Version
-  version: 5.3.2
+  version: 5.4.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-03 00:00:00.000000000 Z
+date: 2022-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails