effective_orders 4.4.1 → 4.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cf23a88730117604f503a6f3e21faba53a1c476dbbd4195ef966b2aa87a0c85
-  data.tar.gz: 90920a87a7d90d46bac4cf459f3010a1e7d95899e5fd6c69c0ca8990a58acc53
+  metadata.gz: 44adcf0828b7d2908e37632adf7188210fde69b5b31ecada6fd4e489dda14213
+  data.tar.gz: ace9a901e39c54be2b848b6032c741d3ed5595b1d7d7f9007a1ed079d632acee
 SHA512:
-  metadata.gz: 199027ed41a806c19cfd3a7762b6c75d2ea6f1ce26f1545a90a7e8b2c3425d357ff99a9eae1cde269f66a40a7ee4fd4cda9a5a14728cb072bf477482b69d3d20
-  data.tar.gz: 717ee3e9b5c79c3ca741037ca5a39e8560ed5f8f545ffec60177e7139511080fbcad6fd11e760f8288aa57efc4cfafe581ec24d9ddb346a6ce655d680f287593
+  metadata.gz: 43344caae87fe3fdbe44213928cc8297b75fa5e7b437f4fe62be4270973fdbb6b984d29350ffb6c63de5d803f136b5bcbb8b1e313ad7fb9d76765139c3ad1ca4
+  data.tar.gz: 88a9e598b60b201eb776c8ca8e0a7537f07c4352af733c5d6673ef92c88abe238a6ef495fca01fe274235d8d2f0967c3a85587916e54025725f6cb9167a0f852

data/README.md

@@ -430,7 +430,6 @@ In addition to the above, the following permissions allow access to the `/admin`
 
 ```ruby
 can :admin, :effective_orders # Can access the admin screens
-can :show, :payment_details # Can see the payment purchase details on orders
 ```
 
 ## Whats Included
@@ -471,8 +470,6 @@ If the configuration options `config.billing_address` and/or `config.shipping_ad
 
 If `config.use_address_full_name` is set to `true` then appropriate form field will be shown and the user will be prompted for the appropriate address full name during the checkout process, based on [effective_addresses](https://github.com/code-and-effect/effective_addresses/).
 
-As well, if the config option `config.collect_user_fields` is present, form fields to collect those user attributes will be present on this page.
-
 When the user submits the form on this screen, a POST to `effective_orders.order_path` is made, and the `Effective::Order` object is validated and created.
 
 On this final checkout screen, links to all configured payment providers are displayed, and the user may choose which payment processor should be used to make a payment.

data/app/controllers/admin/customers_controller.rb

@@ -5,7 +5,7 @@ module Admin
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_customers] : EffectiveOrders.layout)
 
     def index
-      @datatable = EffectiveCustomersDatatable.new(self)
+      @datatable = Admin::EffectiveCustomersDatatable.new(self)
 
       @page_title = 'Customers'
 

data/app/controllers/admin/order_items_controller.rb

@@ -5,7 +5,7 @@ module Admin
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_orders] : EffectiveOrders.layout)
 
     def index
-      @datatable = EffectiveOrderItemsDatatable.new(self)
+      @datatable = Admin::EffectiveOrderItemsDatatable.new(self)
 
       @page_title = 'Order Items'
 

data/app/controllers/admin/orders_controller.rb

@@ -123,7 +123,7 @@ module Admin
     end
 
     def index
-      @datatable = EffectiveOrdersDatatable.new(self)
+      @datatable = Admin::EffectiveOrdersDatatable.new(self)
 
       @page_title = 'Orders'
 

data/app/controllers/effective/concerns/purchase.rb

@@ -9,9 +9,9 @@ module Effective
         begin
           @order.purchase!(payment: payment, provider: provider, card: card, email: email, skip_buyer_validations: skip_buyer_validations)
 
-          Effective::Cart.where(user_id: @order.user_id).destroy_all
+          Effective::Cart.where(user: @order.user).destroy_all
 
-          unless flash[:success]
+          if flash[:success].blank?
             if EffectiveOrders.mailer[:send_order_receipt_to_buyer] && email
               flash[:success] = "Payment successful! A receipt has been sent to #{@order.user.email}"
             else
@@ -19,19 +19,42 @@ module Effective
             end
           end
 
-          redirect_to (purchased_url.presence || effective_orders.purchased_order_path(':id')).gsub(':id', @order.to_param.to_s)
+          purchased_url ||= effective_orders.purchased_order_path(':id')
+          redirect_to purchased_url.gsub(':id', @order.to_param.to_s)
         rescue => e
           flash[:danger] = "An error occurred while processing your payment: #{e.message}. Please try again."
-          redirect_to(declined_url.presence || effective_orders.cart_path).gsub(':id', @order.to_param.to_s)
+
+          declined_url ||= effective_orders.declined_order_path(':id')
+          redirect_to declined_url.gsub(':id', @order.to_param.to_s)
         end
       end
 
-      def order_declined(payment:, provider:, card: 'none', message: nil, declined_url: nil)
+      def order_deferred(provider:, email: true, deferred_url: nil)
+        @order.defer!(provider: provider, email: email)
+
+        Effective::Cart.where(user: @order.user).destroy_all
+
+        if flash[:success].blank?
+          if email
+            flash[:success] = "Deferred payment created! A request for payment has been sent to #{@order.user.email}"
+          else
+            flash[:success] = "Deferred payment created!"
+          end
+        end
+
+        deferred_url ||= effective_orders.deferred_order_path(':id')
+        redirect_to deferred_url.gsub(':id', @order.to_param.to_s)
+      end
+
+      def order_declined(payment:, provider:, card: 'none', declined_url: nil)
         @order.decline!(payment: payment, provider: provider, card: card)
 
-        flash[:danger] = message.presence || 'Payment was unsuccessful. Your credit card was declined by the payment processor. Please try again.'
+        if flash[:danger].blank?
+          flash[:danger] = 'Payment was unsuccessful. Your credit card was declined by the payment processor. Please try again.'
+        end
 
-        redirect_to(declined_url.presence || effective_orders.declined_order_path(@order)).gsub(':id', @order.to_param.to_s)
+        declined_url ||= effective_orders.declined_order_path(':id')
+        redirect_to declined_url.gsub(':id', @order.to_param.to_s)
       end
 
     end

data/app/controllers/effective/orders_controller.rb

@@ -7,6 +7,7 @@ module Effective
     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?
@@ -84,34 +85,24 @@ module Effective
 
     # My Orders History
     def index
-      @orders = Effective::Order.deep.purchased.where(user: current_user)
-      @pending_orders = Effective::Order.deep.pending.where(user: current_user)
-
+      @datatable = EffectiveOrdersDatatable.new(user_id: current_user.id)
       EffectiveOrders.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 = if params[:id].present?
-        Effective::Order.find(params[:id])
-      elsif current_user.present?
-        Effective::Order.sorted.purchased_by(current_user).last
-      end
-
-      if @order.blank?
-        redirect_to(effective_orders.orders_path) and return
-      end
-
+      @order = Effective::Order.purchased.find(params[:id])
       EffectiveOrders.authorize!(self, :show, @order)
+    end
 
-      redirect_to(effective_orders.order_path(@order)) unless @order.purchased?
+    def deferred
+      @order = Effective::Order.deferred.find(params[:id])
+      EffectiveOrders.authorize!(self, :show, @order)
     end
 
     def declined
-      @order = Effective::Order.find(params[:id])
+      @order = Effective::Order.declined.find(params[:id])
       EffectiveOrders.authorize!(self, :show, @order)
-
-      redirect_to(effective_orders.order_path(@order)) unless @order.declined?
     end
 
     def send_buyer_receipt
@@ -141,7 +132,6 @@ module Effective
 
         @orders.each do |order|
           next unless EffectiveOrders.authorized?(self, :show, order)
-
           order.send_order_receipt_to_buyer!
         end
 
@@ -163,6 +153,7 @@ module Effective
         when 'index'        ; 'Order History'
         when 'purchased'    ; 'Thank You'
         when 'declined'     ; 'Payment Declined'
+        when 'deferred'     ; 'Thank You'
         else 'Checkout'
       end
     end

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

@@ -3,37 +3,20 @@ module Effective
     module Cheque
       extend ActiveSupport::Concern
 
-      def pay_by_cheque
+      def cheque
         @order ||= Order.find(params[:id])
-        @page_title = 'Payment Required'
 
         EffectiveOrders.authorize!(self, :update, @order)
 
-        @order.state = EffectiveOrders::PENDING
-        @order.payment_provider = 'cheque'
+        flash[:success] = EffectiveOrders.cheque[:success]
 
-        begin
-          @order.save!
-          @order.send_pending_order_invoice_to_buyer!
-
-          Effective::Cart.where(user_id: @order.user_id).destroy_all
-
-          message = "Successfully indicated order will be payed by cheque. A pending order invoice has been sent to #{@order.user.email}"
+        order_deferred(provider: 'cheque', deferred_url: cheque_params[:deferred_url])
+      end
 
-          # When posted from admin form, there will be a redirect url
-          if params[:purchased_url].present?
-            flash[:success] = message
-            redirect_to params[:purchased_url].gsub(':id', @order.to_param.to_s)
-          else
-            # Otherwise this is the user flow
-            flash.now[:success] = message
-            render 'effective/orders/cheque/pay_by_cheque'
-          end
-        rescue => e
-          flash[:danger] = "Unable to save your order: #{@order.errors.full_messages.to_sentence}. Please try again."
-          redirect_to params[:declined_url].presence || effective_orders.order_path(@order)
-        end
+      def cheque_params
+        params.require(:cheque).permit(:deferred_url)
       end
+
     end
   end
 end

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

@@ -17,8 +17,8 @@ module Effective
           card: mark_as_paid_params[:payment_card],
           email: @order.send_mark_as_paid_email_to_buyer?,
           skip_buyer_validations: true,
-          purchased_url: params[:purchased_url].presence || effective_orders.admin_order_path(@order),
-          declined_url: params[:declined_url].presence || effective_orders.admin_order_path(@order)
+          purchased_url: effective_orders.admin_order_path(@order),
+          declined_url: effective_orders.admin_order_path(@order)
         )
       end
 

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

@@ -0,0 +1,22 @@
+module Effective
+  module Providers
+    module Phone
+      extend ActiveSupport::Concern
+
+      def phone
+        @order ||= Order.find(params[:id])
+
+        EffectiveOrders.authorize!(self, :update, @order)
+
+        flash[:success] = EffectiveOrders.phone[:success]
+
+        order_deferred(provider: 'phone', deferred_url: phone_params[:deferred_url])
+      end
+
+      def phone_params
+        params.require(:phone).permit(:deferred_url)
+      end
+
+    end
+  end
+end

data/app/datatables/{effective_customers_datatable.rb → admin/effective_customers_datatable.rb}

@@ -1,4 +1,4 @@
-class EffectiveCustomersDatatable < Effective::Datatable
+class Admin::EffectiveCustomersDatatable < Effective::Datatable
    datatable do
 
     col :id, visible: false

data/app/datatables/admin/effective_orders_datatable.rb

@@ -0,0 +1,100 @@
+class Admin::EffectiveOrdersDatatable < Effective::Datatable
+  bulk_actions do
+    bulk_action(
+    'Send payment request email to selected orders',
+      effective_orders.bulk_send_payment_request_admin_orders_path,
+      data: { confirm: 'Send payment request emails?' }
+    )
+
+    bulk_action(
+    'Send receipt email to selected purchased orders',
+      effective_orders.bulk_send_buyer_receipt_orders_path,
+      data: { confirm: 'Send receipt emails?' }
+    )
+  end
+
+  filters do
+    scope :purchased, default: true
+    scope :deferred
+    scope :refunds
+    scope :not_purchased
+    scope :all
+  end
+
+  datatable do
+    order :id, :desc
+
+    bulk_actions_col
+
+    col :created_at, visible: false
+    col :updated_at, visible: false
+
+    col :id, label: 'Number' do |order|
+      '#' + order.to_param
+    end
+
+    col :purchased_at do |order|
+      order.purchased_at&.strftime('%F %H:%M') || 'not purchased'
+    end
+
+    if attributes[:user_id].blank?
+      col :user
+      col 'user.email', visible: false
+      col :billing_name, visible: false
+    end
+
+    if EffectiveOrders.billing_address
+      col :billing_address, visible: false
+    end
+
+    if EffectiveOrders.shipping_address
+      col :shipping_address, visible: false
+    end
+
+    col :order_items, search: { as: :string }
+
+    col :subtotal, as: :price, visible: false
+    col :tax, as: :price, visible: false
+
+    col :tax_rate, visible: false do |order|
+      tax_rate_to_percentage(order.tax_rate)
+    end
+
+    col :total, as: :price
+
+    col :payment_provider, label: 'Provider', visible: false, search: { collection: EffectiveOrders.payment_providers }
+    col :payment_card, label: 'Card', visible: false
+
+    if EffectiveOrders.collect_note
+      col :note, visible: false
+    end
+
+    col :note_to_buyer, visible: false
+    col :note_internal, visible: false
+
+    actions_col partial: 'admin/orders/datatable_actions', partial_as: :order
+
+    aggregate :total
+  end
+
+  collection do
+    scope = Effective::Order.all.includes(:addresses, :order_items, :user)
+
+    if EffectiveOrders.orders_collection_scope.respond_to?(:call)
+      scope = EffectiveOrders.orders_collection_scope.call(scope)
+    end
+
+    if attributes[:user_id].present?
+      scope = scope.where(user: user)
+    else
+      scope = scope.joins(:user)
+    end
+
+    scope
+  end
+
+  def user
+    @user ||= User.find(attributes[:user_id])
+  end
+
+end

data/app/datatables/effective_orders_datatable.rb

@@ -1,31 +1,19 @@
-class EffectiveOrdersDatatable < Effective::Datatable
-  bulk_actions do
-    if EffectiveOrders.authorized?(view.controller, :admin, :effective_orders)
-      bulk_action(
-      'Send payment request email to selected pending orders',
-        effective_orders.bulk_send_payment_request_admin_orders_path,
-        data: { confirm: 'Send payment request emails to pending orders?' }
-      )
-    end
-
-    bulk_action(
-    'Send receipt email to selected purchased orders',
-      effective_orders.bulk_send_buyer_receipt_orders_path,
-      data: { confirm: 'Send receipt emails to purchased orders?' }
-    )
-  end
+# This is a user specific EffectiveOrdersDatatable
 
+class EffectiveOrdersDatatable < Effective::Datatable
   filters do
-    scope :purchased, default: true
-    scope :not_purchased
-    scope :all
+    unless attributes[:not_purchased]
+      scope :purchased, default: true
+      scope :deferred
+      scope :refunds
+      scope :not_purchased
+      scope :all
+    end
   end
 
   datatable do
     order :id, :desc
 
-    bulk_actions_col
-
     col :created_at, visible: false
     col :updated_at, visible: false
 
@@ -33,18 +21,10 @@ class EffectiveOrdersDatatable < Effective::Datatable
       '#' + order.to_param
     end
 
-    col :purchased_at do |order|
-      order.purchased_at&.strftime('%F %H:%M') || 'not purchased'
-    end
-
-    if attributes[:user_id].blank?
-      col :user
-
-      col :email, label: 'Email', visible: false, search: :string, sort: :email do |order|
-        link_to order.user.email, (edit_admin_user_path(order.user) rescue admin_user_path(order.user) rescue '#')
+    unless attributes[:not_purchased]
+      col :purchased_at do |order|
+        order.purchased_at&.strftime('%F %H:%M') || 'not purchased'
       end
-
-      col :billing_name, visible: false
     end
 
     if EffectiveOrders.billing_address
@@ -55,10 +35,6 @@ class EffectiveOrdersDatatable < Effective::Datatable
       col :shipping_address, visible: false
     end
 
-    # col :state, label: 'State', search: { collection: EffectiveOrders::STATES.invert } do |order|
-    #   EffectiveOrders::STATES[order.state]
-    # end
-
     col :order_items, search: { as: :string }
 
     col :subtotal, as: :price, visible: false
@@ -73,27 +49,31 @@ class EffectiveOrdersDatatable < Effective::Datatable
     col :payment_provider, label: 'Provider', visible: false, search: { collection: EffectiveOrders.payment_providers }
     col :payment_card, label: 'Card', visible: false
 
-    col :note, visible: EffectiveOrders.collect_note
-    col :note_to_buyer, visible: false
-    col :note_internal, visible: false
+    if EffectiveOrders.collect_note
+      col :note
+    end
 
-    actions_col partial: 'admin/orders/actions', partial_as: :order
+    col :note_to_buyer
 
-    aggregate :total
+    actions_col partial: 'effective/orders/datatable_actions', partial_as: :order
   end
 
   collection do
-    scope = Effective::Order.unscoped.includes(:addresses, :order_items, :user)
+    scope = Effective::Order.all.where(user: user).includes(:addresses, :order_items, :user)
 
     if EffectiveOrders.orders_collection_scope.respond_to?(:call)
       scope = EffectiveOrders.orders_collection_scope.call(scope)
     end
 
-    if attributes[:user_id].present?
-      scope = scope.where(user_id: attributes[:user_id])
+    if attributes[:not_purchased]
+      scope = scope.not_purchased
     end
 
     scope
   end
 
+  def user
+    @user ||= User.find(attributes[:user_id])
+  end
+
 end