effective_orders 4.6.2 → 5.0.3

data/app/controllers/effective/customers_controller.rb

@@ -1,10 +1,12 @@
 module Effective
   class CustomersController < ApplicationController
-    layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:customers] : EffectiveOrders.layout)
+    before_action(:authenticate_user!) if defined?(Devise)
 
     include Effective::CrudController
 
-    before_action :authenticate_user!
+    if (config = EffectiveOrders.layout)
+      layout(config.kind_of?(Hash) ? (config[:customers] || config[:application]) : config)
+    end
 
     submit :save, 'Save', success: -> { 'Successfully updated card.' }
     page_title 'Customer Settings'

data/app/controllers/effective/orders_controller.rb

@@ -1,18 +1,21 @@
 module Effective
   class OrdersController < ApplicationController
+    include Effective::CrudController
     include Concerns::Purchase
 
-    include Providers::Cheque if EffectiveOrders.cheque?
-    include Providers::Free if EffectiveOrders.free?
-    include Providers::MarkAsPaid if EffectiveOrders.mark_as_paid?
-    include Providers::Moneris if EffectiveOrders.moneris?
-    include Providers::Paypal if EffectiveOrders.paypal?
-    include Providers::Phone if EffectiveOrders.phone?
-    include Providers::Pretend if EffectiveOrders.pretend?
-    include Providers::Refund if EffectiveOrders.refund?
-    include Providers::Stripe if EffectiveOrders.stripe?
-
-    layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:orders] : EffectiveOrders.layout)
+    include Providers::Cheque
+    include Providers::Free
+    include Providers::MarkAsPaid
+    include Providers::Moneris
+    include Providers::Paypal
+    include Providers::Phone
+    include Providers::Pretend
+    include Providers::Refund
+    include Providers::Stripe
+
+    if (config = EffectiveOrders.layout)
+      layout(config.kind_of?(Hash) ? (config[:orders] || config[:application]) : config)
+    end
 
     before_action :authenticate_user!, except: [:ccbill_postback, :free, :paypal_postback, :moneris_postback, :pretend]
     before_action :set_page_title, except: [:show]
@@ -26,7 +29,7 @@ module Effective
     def new
       @order ||= Effective::Order.new(view_context.current_cart)
 
-      EffectiveOrders.authorize!(self, :new, @order)
+      EffectiveResources.authorize!(self, :new, @order)
 
       unless @order.valid?
         flash[:danger] = "Unable to proceed: #{flash_errors(@order)}. Please try again."
@@ -38,7 +41,7 @@ module Effective
     # Confirms an order from the cart.
     def create
       @order ||= Effective::Order.new(view_context.current_cart)
-      EffectiveOrders.authorize!(self, :create, @order)
+      EffectiveResources.authorize!(self, :create, @order)
 
       @order.assign_attributes(checkout_params)
 
@@ -57,21 +60,21 @@ module Effective
     # Might render step1 or step2
     def show
       @order = Effective::Order.find(params[:id])
-      EffectiveOrders.authorize!(self, :show, @order)
+      EffectiveResources.authorize!(self, :show, @order)
 
       @page_title ||= ((@order.user == current_user && !@order.purchased?) ? 'Checkout' : @order.to_s)
     end
 
     # Always step1
     def edit
-      @order ||= Effective::Order.find(params[:id])
-      EffectiveOrders.authorize!(self, :edit, @order)
+      @order ||= Effective::Order.not_purchased.find(params[:id])
+      EffectiveResources.authorize!(self, :edit, @order)
     end
 
     # Confirms the order from existing order
     def update
-      @order ||= Effective::Order.find(params[:id])
-      EffectiveOrders.authorize!(self, :update, @order)
+      @order ||= Effective::Order.not_purchased.find(params[:id])
+      EffectiveResources.authorize!(self, :update, @order)
 
       @order.assign_attributes(checkout_params)
 
@@ -86,28 +89,28 @@ module Effective
     # My Orders History
     def index
       @datatable = EffectiveOrdersDatatable.new(user_id: current_user.id)
-      EffectiveOrders.authorize!(self, :index, Effective::Order.new(user: current_user))
+      EffectiveResources.authorize!(self, :index, Effective::Order.new(user: current_user))
     end
 
     # Thank you for Purchasing this Order. This is where a successfully purchased order ends up
     def purchased # Thank You!
       @order = Effective::Order.purchased.find(params[:id])
-      EffectiveOrders.authorize!(self, :show, @order)
+      EffectiveResources.authorize!(self, :show, @order)
     end
 
     def deferred
       @order = Effective::Order.deferred.find(params[:id])
-      EffectiveOrders.authorize!(self, :show, @order)
+      EffectiveResources.authorize!(self, :show, @order)
     end
 
     def declined
       @order = Effective::Order.declined.find(params[:id])
-      EffectiveOrders.authorize!(self, :show, @order)
+      EffectiveResources.authorize!(self, :show, @order)
     end
 
     def send_buyer_receipt
-      @order = Effective::Order.find(params[:id])
-      EffectiveOrders.authorize!(self, :show, @order)
+      @order = Effective::Order.purchased.find(params[:id])
+      EffectiveResources.authorize!(self, :show, @order)
 
       if @order.send_order_receipt_to_buyer!
         flash[:success] = "A receipt has been sent to #{@order.emails_send_to}"
@@ -128,10 +131,10 @@ module Effective
       @orders = Effective::Order.purchased.where(id: params[:ids])
 
       begin
-        EffectiveOrders.authorize!(self, :index, Effective::Order.new(user: current_user))
+        EffectiveResources.authorize!(self, :index, Effective::Order.new(user: current_user))
 
         @orders.each do |order|
-          next unless EffectiveOrders.authorized?(self, :show, order)
+          next unless EffectiveResources.authorized?(self, :show, order)
           order.send_order_receipt_to_buyer!
         end
 

data/app/controllers/effective/providers/cheque.rb

@@ -4,9 +4,11 @@ module Effective
       extend ActiveSupport::Concern
 
       def cheque
+        raise('cheque provider is not available') unless EffectiveOrders.cheque?
+
         @order ||= Order.find(params[:id])
 
-        EffectiveOrders.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :update, @order)
 
         flash[:success] = EffectiveOrders.cheque[:success]
 

data/app/controllers/effective/providers/free.rb

@@ -4,9 +4,11 @@ module Effective
       extend ActiveSupport::Concern
 
       def free
+        raise('free provider is not available') unless EffectiveOrders.free?
+
         @order ||= Order.find(params[:id])
 
-        EffectiveOrders.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :update, @order)
 
         unless @order.free?
           flash[:danger] = 'Unable to process free order with a non-zero total'
@@ -19,7 +21,6 @@ module Effective
           provider: 'free',
           card: 'none',
           purchased_url: free_params[:purchased_url],
-          declined_url: free_params[:declined_url],
           email: false
         )
       end

data/app/controllers/effective/providers/mark_as_paid.rb

@@ -4,10 +4,12 @@ module Effective
       extend ActiveSupport::Concern
 
       def mark_as_paid
+        raise('mark_as_paid provider is not available') unless EffectiveOrders.mark_as_paid?
+
         @order ||= Order.find(params[:id])
 
-        EffectiveOrders.authorize!(self, :update, @order)
-        EffectiveOrders.authorize!(self, :admin, :effective_orders)
+        EffectiveResources.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :admin, :effective_orders)
 
         @order.assign_attributes(mark_as_paid_params.except(:payment, :payment_provider, :payment_card))
 
@@ -17,8 +19,7 @@ module Effective
           card: mark_as_paid_params[:payment_card],
           email: @order.send_mark_as_paid_email_to_buyer?,
           skip_buyer_validations: true,
-          purchased_url: effective_orders.admin_order_path(@order),
-          declined_url: effective_orders.admin_order_path(@order)
+          purchased_url: effective_orders.admin_order_path(@order)
         )
       end
 

data/app/controllers/effective/providers/moneris.rb

@@ -10,9 +10,11 @@ module Effective
       end
 
       def moneris_postback
+        raise('moneris provider is not available') unless EffectiveOrders.moneris?
+
         @order ||= Effective::Order.find(params[:response_order_id])
 
-        (EffectiveOrders.authorize!(self, :update, @order) rescue false)
+        (EffectiveResources.authorize!(self, :update, @order) rescue false)
 
         # Delete the Purchased and Declined Redirect URLs
         purchased_url = params.delete(:rvar_purchased_url)

data/app/controllers/effective/providers/paypal.rb

@@ -10,9 +10,11 @@ module Effective
       # TODO: Make paypal postback work with admin checkout workflow
 
       def paypal_postback
+        raise('paypal provider is not available') unless EffectiveOrders.paypal?
+
         @order ||= Effective::Order.where(id: (params[:invoice].to_i rescue 0)).first
 
-        (EffectiveOrders.authorize!(self, :update, @order) rescue false)
+        (EffectiveResources.authorize!(self, :update, @order) rescue false)
 
         if @order.present?
           if @order.purchased?
@@ -27,7 +29,6 @@ module Effective
         head(:ok)
       end
 
-
     end
   end
 end

data/app/controllers/effective/providers/phone.rb

@@ -4,9 +4,11 @@ module Effective
       extend ActiveSupport::Concern
 
       def phone
+        raise('phone provider is not available') unless EffectiveOrders.phone?
+
         @order ||= Order.find(params[:id])
 
-        EffectiveOrders.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :update, @order)
 
         flash[:success] = EffectiveOrders.phone[:success]
 

data/app/controllers/effective/providers/pretend.rb

@@ -4,16 +4,17 @@ module Effective
       extend ActiveSupport::Concern
 
       def pretend
+        raise('pretend provider is not available') unless EffectiveOrders.pretend?
+
         @order ||= Order.find(params[:id])
 
-        EffectiveOrders.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :update, @order)
 
         order_purchased(
           payment: 'for pretend',
           provider: 'pretend',
           card: 'none',
-          purchased_url: pretend_params[:purchased_url],
-          declined_url: pretend_params[:declined_url]
+          purchased_url: pretend_params[:purchased_url]
         )
       end
 

data/app/controllers/effective/providers/refund.rb

@@ -4,9 +4,11 @@ module Effective
       extend ActiveSupport::Concern
 
       def refund
+        raise('refund provider is not available') unless EffectiveOrders.refund?
+
         @order ||= Order.find(params[:id])
 
-        EffectiveOrders.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :update, @order)
 
         unless @order.refund?
           flash[:danger] = 'Unable to process refund order with a positive total'
@@ -19,8 +21,7 @@ module Effective
         order_purchased(
           payment: 'refund. no payment required.',
           provider: 'refund',
-          purchased_url: refund_params[:purchased_url],
-          declined_url: refund_params[:declined_url]
+          purchased_url: refund_params[:purchased_url]
         )
       end
 

data/app/controllers/effective/providers/stripe.rb

@@ -4,10 +4,12 @@ module Effective
       extend ActiveSupport::Concern
 
       def stripe
+        raise('stripe provider is not available') unless EffectiveOrders.stripe?
+
         @order = Order.find(params[:id])
         @customer = Effective::Customer.for_user(@order.user)
 
-        EffectiveOrders.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :update, @order)
 
         payment = validate_stripe_payment(stripe_params[:payment_intent_id])
 
@@ -24,8 +26,7 @@ module Effective
           payment: payment,
           provider: 'stripe',
           card: payment[:card],
-          purchased_url: stripe_params[:purchased_url],
-          declined_url: stripe_params[:declined_url]
+          purchased_url: stripe_params[:purchased_url]
         )
       end
 

data/app/controllers/effective/subscripter_controller.rb

@@ -1,9 +1,11 @@
 module Effective
   class SubscripterController < ApplicationController
-    layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:subscriptions] : EffectiveOrders.layout)
-
     include Effective::CrudController
 
+    if (config = EffectiveOrders.layout)
+      layout(config.kind_of?(Hash) ? (config[:subscriptions] || config[:application]) : config)
+    end
+
     submit :save, 'Save', redirect: :back, success: -> { 'Successfully updated plan.' }
 
     def resource

data/app/controllers/effective/webhooks_controller.rb

@@ -89,9 +89,18 @@ module Effective
       end
     end
 
-    def send_email(email, *mailer_args)
-      Effective::OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
-      Effective::OrdersMailer.public_send(:subscription_event_to_admin, email.to_s, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
+    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
+
+      EffectiveOrders.mailer_klass.send(email, *args).send(deliver_method)
+      EffectiveOrders.mailer_klass.send(:subscription_event_to_admin, email.to_s, *args).send(deliver_method)
     end
 
     def run_subscribable_buyer_callbacks!

data/app/datatables/admin/effective_customers_datatable.rb

@@ -2,8 +2,12 @@ class Admin::EffectiveCustomersDatatable < Effective::Datatable
    datatable do
 
     col :id, visible: false
-    col :user
-    col 'user.email'
+
+    col :user, search: :string
+
+    col :email do |customer|
+      customer.user.email
+    end
 
     if EffectiveOrders.stripe?
       col :stripe_customer_id
@@ -17,6 +21,6 @@ class Admin::EffectiveCustomersDatatable < Effective::Datatable
   end
 
   collection do
-    Effective::Customer.joins(:user).all
+    Effective::Customer.includes(:user).all
   end
 end

data/app/datatables/admin/effective_orders_datatable.rb

@@ -40,7 +40,7 @@ class Admin::EffectiveOrdersDatatable < Effective::Datatable
     end
 
     if attributes[:user_id].blank?
-      col :user
+      col :user, search: :string
       col :billing_name, visible: false
       col :email, visible: false
     end
@@ -102,7 +102,7 @@ class Admin::EffectiveOrdersDatatable < Effective::Datatable
   end
 
   def user
-    @user ||= User.find(attributes[:user_id])
+    @user ||= current_user.class.find(attributes[:user_id])
   end
 
 end

data/app/datatables/effective_orders_datatable.rb

@@ -6,8 +6,6 @@ class EffectiveOrdersDatatable < Effective::Datatable
       scope :purchased, default: true
       scope :deferred
       scope :refunds
-      scope :not_purchased
-      scope :all
     end
   end
 
@@ -79,7 +77,7 @@ class EffectiveOrdersDatatable < Effective::Datatable
   end
 
   def user
-    @user ||= User.find(attributes[:user_id])
+    @user ||= view.current_user.class.find(attributes[:user_id])
   end
 
 end

data/app/helpers/effective_orders_helper.rb

@@ -107,13 +107,7 @@ module EffectiveOrdersHelper
     end
   end
 
-  def render_orders(obj, opts = {})
-    orders = Array(obj.kind_of?(User) ? Effective::Order.purchased_by(obj) : obj)
-
-    if orders.any? { |order| order.kind_of?(Effective::Order) == false }
-      raise 'expected a User or Effective::Order'
-    end
-
+  def render_orders(orders, opts = {})
     render(partial: 'effective/orders/orders_table', locals: { orders: orders }.merge(opts))
   end
 

data/app/mailers/effective/orders_mailer.rb

@@ -1,183 +1,218 @@
 module Effective
   class OrdersMailer < ActionMailer::Base
-    default from: EffectiveOrders.mailer[:default_from]
+    default from: -> { EffectiveOrders.mailer[:default_from] }
+    layout -> { EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout' }
 
     helper EffectiveOrdersHelper
-    layout EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout'
 
-    def order_receipt_to_admin(order_param)
-      return true unless EffectiveOrders.mailer[:send_order_receipt_to_admin]
+    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]
 
-      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-      @user = @order.user
+        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+        @user = @order.user
 
-      @subject = subject_for(@order, :order_receipt_to_admin, "Order Receipt: ##{@order.to_param}")
+        @subject = subject_for(@order, :order_receipt_to_admin, "Order Receipt: ##{@order.to_param}")
 
-      mail(to: EffectiveOrders.mailer[:admin_email], from: EffectiveOrders.mailer[:default_from], subject: @subject)
+        mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
+      end
     end
 
-    def order_receipt_to_buyer(order_param)  # Buyer
-      return true unless EffectiveOrders.mailer[:send_order_receipt_to_buyer]
+    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
+        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+        @user = @order.user
 
-      @subject = subject_for(@order, :order_receipt_to_buyer, "Order Receipt: ##{@order.to_param}")
+        @subject = subject_for(@order, :order_receipt_to_buyer, "Order Receipt: ##{@order.to_param}")
 
-      mail(to: @order.email, cc: @order.cc, subject: @subject)
+        mail(to: @order.email, cc: @order.cc, subject: @subject)
+      end
     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)
-      return true unless EffectiveOrders.mailer[:send_payment_request_to_buyer]
+    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
+        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+        @user = @order.user
 
-      @subject = subject_for(@order, :payment_request_to_buyer, "Request for Payment: Invoice ##{@order.to_param}")
+        @subject = subject_for(@order, :payment_request_to_buyer, "Request for Payment: Invoice ##{@order.to_param}")
 
-      mail(to: @order.email, cc: @order.cc, subject: @subject)
+        mail(to: @order.email, cc: @order.cc, subject: @subject)
+      end
     end
 
+
     # This is sent when someone chooses to Pay by Cheque
-    def pending_order_invoice_to_buyer(order_param)
-      return true unless EffectiveOrders.mailer[:send_pending_order_invoice_to_buyer]
+    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]
 
-      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-      @user = @order.user
+        @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
+        @user = @order.user
 
-      @subject = subject_for(@order, :pending_order_invoice_to_buyer, "Pending Order: ##{@order.to_param}")
+        @subject = subject_for(@order, :pending_order_invoice_to_buyer, "Pending Order: ##{@order.to_param}")
 
-      mail(to: @order.email, cc: @order.cc, subject: @subject)
+        mail(to: @order.email, cc: @order.cc, subject: @subject)
+      end
     end
 
     # This is sent to admin when someone Accepts Refund
-    def refund_notification_to_admin(order_param)
-      @order = (order_param.kind_of?(Effective::Order) ? order_param : Effective::Order.find(order_param))
-      @user = @order.user
+    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
 
-      @subject = subject_for(@order, :refund_notification_to_admin, "New Refund: ##{@order.to_param}")
+        @subject = subject_for(@order, :refund_notification_to_admin, "New Refund: ##{@order.to_param}")
 
-      mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
+        mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
+      end
     end
 
     # Sent by the invoice.payment_succeeded webhook event
-    def subscription_payment_succeeded(customer_param)
-      return true unless EffectiveOrders.mailer[:send_subscription_payment_succeeded]
+    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
+        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+        @subscriptions = @customer.subscriptions
+        @user = @customer.user
 
-      @subject = subject_for(@customer, :subscription_payment_succeeded, 'Thank you for your payment')
+        @subject = subject_for(@customer, :subscription_payment_succeeded, 'Thank you for your payment')
 
-      mail(to: @customer.user.email, subject: @subject)
+        mail(to: @customer.user.email, subject: @subject)
+      end
     end
 
     # Sent by the invoice.payment_failed webhook event
-    def subscription_payment_failed(customer_param)
-      return true unless EffectiveOrders.mailer[:send_subscription_payment_failed]
+    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
+        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+        @subscriptions = @customer.subscriptions
+        @user = @customer.user
 
-      @subject = subject_for(@customer, :subscription_payment_failed, 'Payment failed - please update your card details')
+        @subject = subject_for(@customer, :subscription_payment_failed, 'Payment failed - please update your card details')
 
-      mail(to: @customer.user.email, subject: @subject)
+        mail(to: @customer.user.email, subject: @subject)
+      end
     end
 
     # Sent by the customer.subscription.created webhook event
-    def subscription_created(customer_param)
-      return true unless EffectiveOrders.mailer[:send_subscription_created]
+    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
+        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+        @subscriptions = @customer.subscriptions
+        @user = @customer.user
 
-      @subject = subject_for(@customer, :subscription_created, 'New Subscription')
+        @subject = subject_for(@customer, :subscription_created, 'New Subscription')
 
-      mail(to: @customer.user.email, subject: @subject)
+        mail(to: @customer.user.email, subject: @subject)
+      end
     end
 
     # Sent by the customer.subscription.updated webhook event
-    def subscription_updated(customer_param)
-      return true unless EffectiveOrders.mailer[:send_subscription_updated]
+    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
+        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+        @subscriptions = @customer.subscriptions
+        @user = @customer.user
 
-      @subject = subject_for(@customer, :subscription_updated, 'Subscription Changed')
+        @subject = subject_for(@customer, :subscription_updated, 'Subscription Changed')
 
-      mail(to: @customer.user.email, subject: @subject)
+        mail(to: @customer.user.email, subject: @subject)
+      end
     end
 
     # Sent by the invoice.payment_failed webhook event
-    def subscription_canceled(customer_param)
-      return true unless EffectiveOrders.mailer[:send_subscription_canceled]
+    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
+        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+        @subscriptions = @customer.subscriptions
+        @user = @customer.user
 
-      @subject = subject_for(@customer, :subscription_canceled, 'Subscription canceled')
+        @subject = subject_for(@customer, :subscription_canceled, 'Subscription canceled')
 
-      mail(to: @customer.user.email, subject: @subject)
+        mail(to: @customer.user.email, subject: @subject)
+      end
     end
 
     # Sent by the effective_orders:notify_trial_users rake task.
-    def subscription_trialing(subscribable)
-      return true unless EffectiveOrders.mailer[:send_subscription_trialing]
+    def subscription_trialing(subscribable, atts = {})
+      around_mail_action(:subscription_trialing, subscribable, atts) do
+        return true unless EffectiveOrders.mailer[:send_subscription_trialing]
 
-      @subscribable = subscribable
-      @user = @subscribable.subscribable_buyer
+        @subscribable = subscribable
+        @user = @subscribable.subscribable_buyer
 
-      @subject = subject_for(@customer, :subscription_trialing, 'Trial is active')
+        @subject = subject_for(@customer, :subscription_trialing, 'Trial is active')
 
-      mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
+        mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
+      end
     end
 
     # Sent by the effective_orders:notify_trial_users rake task.
-    def subscription_trial_expired(subscribable)
-      return true unless EffectiveOrders.mailer[:send_subscription_trial_expired]
+    def subscription_trial_expired(subscribable, atts = {})
+      around_mail_action(:subscription_trial_expired, subscribable, atts) do
+        return true unless EffectiveOrders.mailer[:send_subscription_trial_expired]
 
-      @subscribable = subscribable
-      @user = @subscribable.subscribable_buyer
+        @subscribable = subscribable
+        @user = @subscribable.subscribable_buyer
 
-      @subject = subject_for(@customer, :subscription_trial_expired, 'Trial expired')
+        @subject = subject_for(@customer, :subscription_trial_expired, 'Trial expired')
 
-      mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
+        mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
+      end
     end
 
-    def subscription_event_to_admin(event, customer_param)
-      return true unless EffectiveOrders.mailer[:send_subscription_event_to_admin]
+    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]
 
-      @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
-      @subscriptions = @customer.subscriptions
-      @user = @customer.user
-      @event = event.to_s
+        @customer = (customer_param.kind_of?(Effective::Customer) ? customer_param : Effective::Customer.find(customer_param))
+        @subscriptions = @customer.subscriptions
+        @user = @customer.user
+        @event = event.to_s
 
-      @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(@customer, :subscription_event_to_admin, "Subscription event - @event - @customer").gsub('@event', @event.to_s).gsub('@customer', @customer.to_s)
 
-      mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
+        mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
+      end
     end
 
     def order_error(order: nil, error: nil, to: nil, from: nil, subject: nil, template: 'order_error')
-      @order = (order.kind_of?(Effective::Order) ? order : Effective::Order.find(order))
-      @error = error.to_s
+      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
 
-      @subject = subject_for(@order, :error, "An error occurred with order: ##{@order.try(:to_param)}")
+    protected
 
-      mail(
-        to: (to || EffectiveOrders.mailer[:admin_email]),
-        from: (from || EffectiveOrders.mailer[:default_from]),
-        subject: (subject || @subject)
-      ) do |format|
-        format.html { render(template) }
-      end
+    def around_mail_action(name, param, atts = {}, &block)
+      yield
     end
 
     private