effective_orders 4.6.1 → 4.6.2

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

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

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

@@ -4,11 +4,9 @@ module Effective
       extend ActiveSupport::Concern
 
       def free
-        raise('free provider is not available') unless EffectiveOrders.free?
-
         @order ||= Order.find(params[:id])
 
-        EffectiveResources.authorize!(self, :update, @order)
+        EffectiveOrders.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,12 +4,10 @@ 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])
 
-        EffectiveResources.authorize!(self, :update, @order)
-        EffectiveResources.authorize!(self, :admin, :effective_orders)
+        EffectiveOrders.authorize!(self, :update, @order)
+        EffectiveOrders.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,11 +10,9 @@ module Effective
       end
 
       def moneris_postback
-        raise('moneris provider is not available') unless EffectiveOrders.moneris?
-
         @order ||= Effective::Order.find(params[:response_order_id])
 
-        (EffectiveResources.authorize!(self, :update, @order) rescue false)
+        (EffectiveOrders.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,11 +10,9 @@ 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
 
-        (EffectiveResources.authorize!(self, :update, @order) rescue false)
+        (EffectiveOrders.authorize!(self, :update, @order) rescue false)
 
         if @order.present?
           if @order.purchased?
@@ -29,6 +27,7 @@ module Effective
         head(:ok)
       end
 
+
     end
   end
 end

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

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

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

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

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

@@ -4,11 +4,9 @@ module Effective
       extend ActiveSupport::Concern
 
       def refund
-        raise('refund provider is not available') unless EffectiveOrders.refund?
-
         @order ||= Order.find(params[:id])
 
-        EffectiveResources.authorize!(self, :update, @order)
+        EffectiveOrders.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,12 +4,10 @@ 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)
 
-        EffectiveResources.authorize!(self, :update, @order)
+        EffectiveOrders.authorize!(self, :update, @order)
 
         payment = validate_stripe_payment(stripe_params[:payment_intent_id])
 

data/app/controllers/effective/subscripter_controller.rb

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

data/app/controllers/effective/webhooks_controller.rb

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

data/app/datatables/admin/effective_customers_datatable.rb

@@ -2,12 +2,8 @@ class Admin::EffectiveCustomersDatatable < Effective::Datatable
    datatable do
 
     col :id, visible: false
-
-    col :user, search: :string
-
-    col :email do |customer|
-      customer.user.email
-    end
+    col :user
+    col 'user.email'
 
     if EffectiveOrders.stripe?
       col :stripe_customer_id
@@ -21,6 +17,6 @@ class Admin::EffectiveCustomersDatatable < Effective::Datatable
   end
 
   collection do
-    Effective::Customer.includes(:user).all
+    Effective::Customer.joins(: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, search: :string
+      col :user
       col :billing_name, visible: false
       col :email, visible: false
     end
@@ -102,7 +102,7 @@ class Admin::EffectiveOrdersDatatable < Effective::Datatable
   end
 
   def user
-    @user ||= current_user.class.find(attributes[:user_id])
+    @user ||= User.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 ||= current_user.class.find(attributes[:user_id])
+    @user ||= User.find(attributes[:user_id])
   end
 
 end

data/app/mailers/effective/orders_mailer.rb

@@ -1,218 +1,183 @@
 module Effective
   class OrdersMailer < ActionMailer::Base
-    default from: -> { EffectiveOrders.mailer[:default_from] }
-    layout -> { EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout' }
+    default from: EffectiveOrders.mailer[:default_from]
 
     helper EffectiveOrdersHelper
+    layout EffectiveOrders.mailer[:layout].presence || 'effective_orders_mailer_layout'
 
-    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(order_param)
+      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], subject: @subject)
-      end
+      mail(to: EffectiveOrders.mailer[:admin_email], from: EffectiveOrders.mailer[:default_from], subject: @subject)
     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]
+    def order_receipt_to_buyer(order_param)  # Buyer
+      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)
-      end
+      mail(to: @order.email, cc: @order.cc, subject: @subject)
     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]
+    def payment_request_to_buyer(order_param)
+      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)
-      end
+      mail(to: @order.email, cc: @order.cc, subject: @subject)
     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(order_param)
+      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)
-      end
+      mail(to: @order.email, cc: @order.cc, subject: @subject)
     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_param)
+      @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)
-      end
+      mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
     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]
+    def subscription_payment_succeeded(customer_param)
+      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)
-      end
+      mail(to: @customer.user.email, subject: @subject)
     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]
+    def subscription_payment_failed(customer_param)
+      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)
-      end
+      mail(to: @customer.user.email, subject: @subject)
     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]
+    def subscription_created(customer_param)
+      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)
-      end
+      mail(to: @customer.user.email, subject: @subject)
     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]
+    def subscription_updated(customer_param)
+      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)
-      end
+      mail(to: @customer.user.email, subject: @subject)
     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]
+    def subscription_canceled(customer_param)
+      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)
-      end
+      mail(to: @customer.user.email, subject: @subject)
     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(subscribable)
+      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)
-      end
+      mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
     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(subscribable)
+      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)
-      end
+      mail(to: @subscribable.subscribable_buyer.email, subject: @subject)
     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, customer_param)
+      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)
-      end
+      mail(to: EffectiveOrders.mailer[:admin_email], subject: @subject)
     end
 
     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
+      @order = (order.kind_of?(Effective::Order) ? order : Effective::Order.find(order))
+      @error = error.to_s
 
-    protected
+      @subject = subject_for(@order, :error, "An error occurred with order: ##{@order.try(:to_param)}")
 
-    def around_mail_action(name, param, atts = {}, &block)
-      yield
+      mail(
+        to: (to || EffectiveOrders.mailer[:admin_email]),
+        from: (from || EffectiveOrders.mailer[:default_from]),
+        subject: (subject || @subject)
+      ) do |format|
+        format.html { render(template) }
+      end
     end
 
     private