effective_orders 4.6.3 → 5.0.4

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

data/app/models/concerns/acts_as_purchasable.rb

@@ -4,17 +4,6 @@ module ActsAsPurchasable
   module Base
     def acts_as_purchasable(*options)
       @acts_as_purchasable = options || []
-
-      # if table_exists?
-      #   instance = new()
-      #   raise 'must respond_to price' unless instance.respond_to?(:price)
-      #   raise 'must respond_to purchased_order_id' unless instance.respond_to?(:purchased_order_id)
-
-      #   if defined?(EffectiveQbSync)
-      #     raise 'must respond to qb_item_name' unless instance.respond_to?(:qb_item_name)
-      #   end
-      # end
-
       include ::ActsAsPurchasable
     end
   end

data/app/models/concerns/acts_as_subscribable.rb

@@ -7,12 +7,6 @@ module ActsAsSubscribable
     def acts_as_subscribable(*options)
       @acts_as_subscribable = options || []
 
-      # if table_exists?
-      #   instance = new()
-      #   raise 'must respond to trialing_until' unless instance.respond_to?(:trialing_until) || !EffectiveOrders.trial?
-      #   raise 'must respond to subscription_status' unless instance.respond_to?(:subscription_status)
-      # end
-
       include ::ActsAsSubscribable
       (ActsAsSubscribable.descendants ||= []) << self
     end

data/app/models/effective/cart.rb

@@ -2,14 +2,16 @@ module Effective
   class Cart < ActiveRecord::Base
     self.table_name = EffectiveOrders.carts_table_name.to_s
 
-    belongs_to :user, optional: true    # Optional. We want non-logged-in users to have carts too.
-    has_many :cart_items, -> { order(:id) }, dependent: :delete_all, class_name: 'Effective::CartItem'
+    belongs_to :user, polymorphic: true, optional: true  # Optional. We want non-logged-in users to have carts too.
 
+    has_many :cart_items, -> { order(:id) }, inverse_of: :cart, dependent: :delete_all
     accepts_nested_attributes_for :cart_items
 
-    # Attributes
-    # cart_items_count        :integer
-    # timestamps
+    effective_resource do
+      cart_items_count        :integer
+
+      timestamps
+    end
 
     scope :deep, -> { includes(cart_items: :purchasable) }
 

data/app/models/effective/cart_item.rb

@@ -2,12 +2,15 @@ module Effective
   class CartItem < ActiveRecord::Base
     self.table_name = EffectiveOrders.cart_items_table_name.to_s
 
-    belongs_to :cart, counter_cache: true, class_name: 'Effective::Cart'
+    belongs_to :cart, counter_cache: true
     belongs_to :purchasable, polymorphic: true
 
-    # Attributes
-    # quantity    :integer
-    # timestamps
+    effective_resource do
+      unique      :string
+      quantity    :integer
+
+      timestamps
+    end
 
     validates :purchasable, presence: true
     validates :quantity, presence: true

data/app/models/effective/customer.rb

@@ -4,16 +4,17 @@ module Effective
 
     attr_accessor :stripe_customer
 
-    belongs_to :user
+    belongs_to :user, polymorphic: true
     has_many :subscriptions, -> { includes(:subscribable) }, class_name: 'Effective::Subscription', foreign_key: 'customer_id'
     accepts_nested_attributes_for :subscriptions
 
-    # Attributes
-    # stripe_customer_id            :string  # cus_xja7acoa03
-    # payment_method_id             :string  # Last payment method used
-    # active_card                   :string  # **** **** **** 4242 Visa 05/12
+    effective_resource do
+      stripe_customer_id            :string  # cus_xja7acoa03
+      payment_method_id             :string  # Last payment method used
+      active_card                   :string  # **** **** **** 4242 Visa 05/12
 
-    # timestamps
+      timestamps
+    end
 
     scope :deep, -> { includes(subscriptions: :subscribable) }
 

data/app/models/effective/order.rb

@@ -31,35 +31,37 @@ module Effective
     # If we want to use orders in a has_many way
     belongs_to :parent, polymorphic: true, optional: true
 
-    belongs_to :user, validate: false  # This is the buyer/user of the order. We validate it below.
-    has_many :order_items, -> { order(:id) }, inverse_of: :order, class_name: 'Effective::OrderItem', dependent: :delete_all
+    belongs_to :user, polymorphic: true, validate: false  # This is the buyer/user of the order. We validate it below.
+    has_many :order_items, -> { order(:id) }, inverse_of: :order, dependent: :delete_all
 
     accepts_nested_attributes_for :order_items, allow_destroy: false, reject_if: :all_blank
     accepts_nested_attributes_for :user, allow_destroy: false, update_only: true
 
     # Attributes
-    # state             :string
-    # purchased_at      :datetime
-    #
-    # note              :text   # From buyer to admin
-    # note_to_buyer     :text   # From admin to buyer
-    # note_internal     :text   # Internal admin only
-    #
-    # billing_name      :string   # name of buyer
-    # email             :string   # same as user.email
-    # cc                :string   # can be set by admin
-    #
-    # payment           :text     # serialized hash containing all the payment details.
-    # payment_provider  :string
-    # payment_card      :string
-    #
-    # tax_rate          :decimal, precision: 6, scale: 3
-    #
-    # subtotal          :integer
-    # tax               :integer
-    # total             :integer
-    #
-    # timestamps
+    effective_resource do
+      state             :string
+      purchased_at      :datetime
+
+      note              :text   # From buyer to admin
+      note_to_buyer     :text   # From admin to buyer
+      note_internal     :text   # Internal admin only
+
+      billing_name      :string   # name of buyer
+      email             :string   # same as user.email
+      cc                :string   # can be set by admin
+
+      payment           :text     # serialized hash containing all the payment details.
+      payment_provider  :string
+      payment_card      :string
+
+      tax_rate          :decimal, precision: 6, scale: 3
+
+      subtotal          :integer
+      tax               :integer
+      total             :integer
+
+      timestamps
+    end
 
     serialize :payment, Hash
 
@@ -135,7 +137,7 @@ module Effective
       validates :payment_provider, presence: true, inclusion: { in: EffectiveOrders.deferred_providers }
     end
 
-    scope :deep, -> { includes(:user, order_items: :purchasable) }
+    scope :deep, -> { includes(:addresses, :user, order_items: :purchasable) }
     scope :sorted, -> { order(:id) }
 
     scope :purchased, -> { where(state: EffectiveOrders::PURCHASED) }
@@ -314,15 +316,15 @@ module Effective
     end
 
     def send_payment_request_to_buyer?
-      truthy?(send_payment_request_to_buyer) && !free? && !refund?
+      EffectiveResources.truthy?(send_payment_request_to_buyer) && !free? && !refund?
     end
 
     def send_mark_as_paid_email_to_buyer?
-      truthy?(send_mark_as_paid_email_to_buyer)
+      EffectiveResources.truthy?(send_mark_as_paid_email_to_buyer)
     end
 
     def skip_buyer_validations?
-      truthy?(skip_buyer_validations)
+      EffectiveResources.truthy?(skip_buyer_validations)
     end
 
     # This is called from admin/orders#create
@@ -360,38 +362,31 @@ module Effective
 
     # Effective::Order.new(items: Product.first, user: User.first).purchase!(email: false)
     def purchase!(payment: 'none', provider: 'none', card: 'none', email: true, skip_buyer_validations: false)
-      return false if purchased?
-      error = nil
-
-      assign_attributes(
-        state: EffectiveOrders::PURCHASED,
-        payment: payment_to_h(payment),
-        payment_provider: provider,
-        payment_card: (card.presence || 'none'),
-        skip_buyer_validations: skip_buyer_validations
-      )
+      # Assign attributes
+      self.state = EffectiveOrders::PURCHASED
+      self.skip_buyer_validations = skip_buyer_validations
 
+      self.payment_provider ||= provider
+      self.payment_card ||= (card.presence || 'none')
       self.purchased_at ||= Time.zone.now
+      self.payment = payment_to_h(payment) if self.payment.blank?
 
-      Effective::Order.transaction do
-        begin
+      begin
+        Effective::Order.transaction do
           run_purchasable_callbacks(:before_purchase)
           save!
           update_purchasables_purchased_order!
-        rescue => e
-          self.state = state_was
-          self.purchased_at = nil
-
-          error = e.message
-          raise ::ActiveRecord::Rollback
         end
-      end
+      rescue => e
+        Effective::Order.transaction do
+          save!(validate: false)
+          update_purchasables_purchased_order!
+        end
 
-      raise "Failed to purchase order: #{error || errors.full_messages.to_sentence}" unless error.nil?
+        raise(e)
+      end
 
       run_purchasable_callbacks(:after_purchase)
-
-      send_refund_notification! if email && refund?
       send_order_receipts! if email
 
       true
@@ -454,6 +449,7 @@ module Effective
     def send_order_receipts!
       send_order_receipt_to_admin! if EffectiveOrders.mailer[:send_order_receipt_to_admin]
       send_order_receipt_to_buyer! if EffectiveOrders.mailer[:send_order_receipt_to_buyer]
+      send_refund_notification! if refund?
     end
 
     def send_order_receipt_to_admin!
@@ -477,7 +473,7 @@ module Effective
     end
 
     def skip_qb_sync!
-      defined?(EffectiveQbSync) ? EffectiveQbSync.skip_order!(self) : true
+      EffectiveOrders.use_effective_qb_sync ? EffectiveQbSync.skip_order!(self) : true
     end
 
     protected
@@ -544,22 +540,23 @@ module Effective
       order_items.each { |oi| oi.purchasable.public_send(name, self, oi) if oi.purchasable.respond_to?(name) }
     end
 
-    def send_email(email, *mailer_args)
+    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
-        Effective::OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
+        EffectiveOrders.mailer_klass.send(email, *args).send(deliver_method)
       rescue => e
         raise if Rails.env.development? || Rails.env.test?
       end
     end
 
-    def truthy?(value)
-      if defined?(::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES)  # Rails <5
-        ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(value)
-      else
-        ::ActiveRecord::Type::Boolean.new.cast(value)
-      end
-    end
-
     def payment_to_h(payment)
       if payment.respond_to?(:to_unsafe_h)
         payment.to_unsafe_h.to_h