effective_orders 4.6.0 → 4.6.1

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'

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))
 

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,9 +4,11 @@ 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',

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'

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])
 

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

@@ -79,7 +79,7 @@ class EffectiveOrdersDatatable < Effective::Datatable
   end
 
   def user
-    @user ||= User.find(attributes[:user_id])
+    @user ||= current_user.class.find(attributes[:user_id])
   end
 
 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