effective_orders 6.11.1 → 6.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ac80cab29f40a538adba24d649e4d31ca08d15af77b8bd15e906eec5a4afcc4
-  data.tar.gz: 46791fff44cb8f78ead4b829fe79e59fd8202862a05a89448e5844a2fc1e5417
+  metadata.gz: a5a55ea6c14b02fce58218a825c9f936516c0d46a1246b7190a503b97070d394
+  data.tar.gz: 97c6253dfe17a99e7113755e935432b7953c89714ef1a77dff48f6a014204a9e
 SHA512:
-  metadata.gz: 5bda2f8002c375797ee23647dd585529082a34bb274ca623b18ca2f564a4fba3768ece770ee1182164396886e5e606736b652d678c8dd79f59af8ff22799403a
-  data.tar.gz: 0a4ab62604bee87a844acb881d69e455b61e14c1b336f9318b0113fb166f1f233f230d9b48a3bfc4e749e5cdf4d1b1ac120c6bd26a5f19a2ad9fe2a648c8f16e
+  metadata.gz: 1d4f1885182a55a73e39665ab477f31bb1fc6c801fb04f13f0311fd870ad87edb84f27d8bf5ac0abb456f61fdd236961df650da27e157a7b532629e67e7c567a
+  data.tar.gz: 4c74eaa371c3e9db830ce252cd611068ab727640a836f6e6dac1c7abc05439b7a9beeb0f80bf2374367afbc6a8b37d8e8c1188057f19c2e062b1d0c73436c214

data/app/assets/javascripts/effective_orders/providers/deluxe_delayed.js

@@ -0,0 +1,32 @@
+// https://developer.deluxe.com/s/article-hosted-payment-form
+
+function initializeDeluxeDelayed() {
+  let $deluxe = $('form[data-deluxe-delayed-checkout]:not(.initialized)');
+  if($deluxe.length == 0) return;
+
+  let options = $deluxe.data('deluxe-delayed-checkout');
+
+  HostedForm.init(options, {
+    onFailure: (data) => { $('#deluxe-delayed-checkout-errors').text(JSON.stringify(data)); },
+    onInvalid: (data) => { $('#deluxe-delayed-checkout-errors').text(JSON.stringify(data)); },
+
+    onSuccess: (data) => { 
+      let value = btoa(JSON.stringify(data)); // A base64 encoded JSON object
+
+      $form = $('form[data-deluxe-delayed-checkout]').first();
+      $form.find('input[name="deluxe_delayed[payment_intent]"]').val(value);
+      $form.submit();
+
+      $('#deluxeDelayedCheckout').fadeOut('slow');
+      $('#deluxe-delayed-checkout-loading').text('Thank you! Saving card information. Please wait...');
+    },
+  }).then((instance) => {
+    $('#deluxe-delayed-checkout-loading').text('');
+    instance.renderHpf();
+  });
+
+  $deluxe.addClass('initialized');
+};
+
+$(document).ready(function() { initializeDeluxeDelayed() });
+$(document).on('turbolinks:load', function() { initializeDeluxeDelayed() });

data/app/assets/stylesheets/effective_orders/_order.scss

@@ -60,6 +60,10 @@ form.new_effective_order {
   #deluxeCheckout { height: 280px; }
 }
 
+.effective-deluxe-delayed-checkout {
+  #deluxeDelayedCheckout { height: 280px; }
+}
+
 @media print {
   .effective-orders-page-content { display: none; }
 

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

@@ -50,6 +50,23 @@ module Effective
         redirect_to deferred_url.gsub(':id', @order.to_param.to_s)
       end
 
+      def order_delayed(payment:, payment_intent:, provider:, card: 'none', deferred_url: nil, email: false)
+        @order.delay!(payment: payment, payment_intent: payment_intent, provider: provider, card: card, email: email)
+
+        Effective::Cart.where(user: current_user).destroy_all if current_user.present?
+
+        if flash[:success].blank?
+          if email
+            flash[:success] = "Delayed payment created! An email has been sent to #{@order.emails_send_to}"
+          else
+            flash[:success] = "Delayed payment created!"
+          end
+        end
+
+        deferred_url = effective_orders.deferred_order_path(':id') if deferred_url.blank?
+        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)
 

data/app/controllers/effective/orders_controller.rb

@@ -5,6 +5,8 @@ module Effective
 
     include Providers::Cheque
     include Providers::Deluxe
+    include Providers::DeluxeDelayed
+    include Providers::DeluxeDelayedPurchase
     include Providers::Etransfer
     include Providers::Free
     include Providers::MarkAsPaid

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

@@ -11,41 +11,33 @@ module Effective
         EffectiveResources.authorize!(self, :update, @order)
 
         ## Process Payment Intent
+        api = Effective::DeluxeApi.new
 
         # The payment_intent is set by the Deluxe HostedPaymentForm
-        payment_intent = deluxe_params[:payment_intent]
+        payment_intent_payload = deluxe_params[:payment_intent]
 
-        if payment_intent.blank?
+        if payment_intent_payload.blank?
           flash[:danger] = 'Unable to process deluxe order without payment. please try again.'
-          return order_not_processed(declined_url: payment_intent[:declined_url])
+          return order_not_processed(declined_url: deluxe_params[:declined_url])
         end
 
         # Decode the base64 encoded JSON object into a Hash
-        payment_intent = (JSON.parse(Base64.decode64(payment_intent)) rescue nil)
-        raise('expected payment_intent to be a Hash') unless payment_intent.kind_of?(Hash)
-        raise('expected a token payment') unless payment_intent['type'] == 'Token'
+        payment_intent = api.decode_payment_intent_payload(payment_intent_payload)
+        card_info = api.card_info(payment_intent)
 
-        valid = payment_intent['status'] == 'success'
+        valid = (payment_intent['status'] == 'success')
 
         if valid == false
-          card_info = deluxe_api.card_info(payment_intent)
-          return order_declined(payment: card_info, provider: 'deluxe', card: card_info['card'], declined_url: declined_url)
+          return order_declined(payment: card_info, provider: 'deluxe', card: card_info['card'], declined_url: deluxe_params[:declined_url])
         end
 
-        ## Process Authorization
-        authorization = deluxe_api.authorize_payment(@order, payment_intent)
-        valid = [0].include?(authorization['responseCode'])
+        ## Purchase Order right now
+        purchased = api.purchase!(@order, payment_intent)
 
-        if valid == false
-          flash[:danger] = "Payment was unsuccessful. The credit card authorization failed with message: #{Array(authorization['responseMessage']).to_sentence.presence || 'none'}. Please try again."
-          return order_declined(payment: authorization, provider: 'deluxe', card: authorization['card'], declined_url: deluxe_params[:declined_url])
-        end
-
-        ## Complete Payment
-        payment = deluxe_api.complete_payment(@order, authorization)
-        valid = [0].include?(payment['responseCode'])
+        payment = api.payment
+        raise('expected a payment Hash') unless payment.kind_of?(Hash)
 
-        if valid == false
+        if purchased == false
           flash[:danger] = "Payment was unsuccessful. The credit card payment failed with message: #{Array(payment['responseMessage']).to_sentence.presence || 'none'}. Please try again."
           return order_declined(payment: payment, provider: 'deluxe', card: payment['card'], declined_url: deluxe_params[:declined_url])
         end
@@ -66,10 +58,6 @@ module Effective
         params.require(:deluxe).permit(:payment_intent, :purchased_url, :declined_url)
       end
 
-      def deluxe_api
-        @deluxe_api ||= Effective::DeluxeApi.new
-      end
-
     end
   end
 end

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

@@ -0,0 +1,48 @@
+module Effective
+  module Providers
+    module DeluxeDelayed
+      extend ActiveSupport::Concern
+
+      def deluxe_delayed
+        raise('deluxe provider is not available') unless EffectiveOrders.deluxe?
+        raise('deluxe_delayed provider is not available') unless EffectiveOrders.deluxe_delayed?
+
+        @order = Effective::Order.deep.find(params[:id])
+
+        EffectiveResources.authorize!(self, :update, @order)
+
+        ## Process Payment Intent
+        api = Effective::DeluxeApi.new
+
+        # The payment_intent is set by the Deluxe HostedPaymentForm
+        payment_intent_payload = deluxe_delayed_params[:payment_intent]
+
+        if payment_intent_payload.blank?
+          flash[:danger] = 'Unable to process deluxe delayed order without payment intent. please try again.'
+          return order_not_processed(declined_url: deluxe_delayed_params[:declined_url])
+        end
+
+        # Decode the base64 encoded JSON object into a Hash
+        payment_intent = api.decode_payment_intent_payload(payment_intent_payload)
+        card_info = api.card_info(payment_intent)
+
+        valid = payment_intent['status'] == 'success'
+
+        if valid == false
+          return order_declined(payment: card_info, provider: 'deluxe_delayed', card: card_info['card'], declined_url: deluxe_delayed_params[:declined_url])
+        end
+
+        flash[:success] = EffectiveOrders.deluxe_delayed[:success]
+
+        order_delayed(payment: card_info, payment_intent: payment_intent_payload, provider: 'deluxe_delayed', card: card_info['card'], deferred_url: deluxe_delayed_params[:deferred_url])
+      end
+
+      private
+
+      def deluxe_delayed_params
+        params.require(:deluxe_delayed).permit(:payment_intent, :deferred_url, :declined_url)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Effective
+  module Providers
+    module DeluxeDelayedPurchase
+      extend ActiveSupport::Concern
+
+      # Admin action
+      def deluxe_delayed_purchase
+        raise('deluxe_delayed_purchase provider is not available') unless EffectiveOrders.deluxe_delayed?
+
+        @order ||= Order.deep.find(params[:id])
+
+        EffectiveResources.authorize!(self, :update, @order)
+        EffectiveResources.authorize!(self, :admin, :effective_orders)
+
+        raise('expected a delayed? and deferred? order') unless @order.delayed? && @order.deferred?
+
+        ## Purchase Order right now
+        api = Effective::DeluxeApi.new
+
+        purchased = api.purchase!(@order, @order.delayed_payment_intent)
+        payment = api.payment
+
+        if purchased == false
+          flash[:danger] = "Payment was unsuccessful. The credit card payment failed with message: #{Array(payment['responseMessage']).to_sentence.presence || 'none'}. Please try again."
+          return order_declined(payment: payment, provider: 'deluxe_delayed', card: payment['card'], declined_url: deluxe_delayed_purchase_params[:declined_url])
+        end
+
+        @order.assign_attributes(deluxe_delayed_purchase_params.except(:purchased_url, :declined_url, :id))
+
+        order_purchased(
+          payment: payment,
+          provider: 'deluxe_delayed',
+          card: payment['card'],
+          email: @order.send_mark_as_paid_email_to_buyer?,
+          skip_buyer_validations: true,
+          purchased_url: effective_orders.admin_order_path(@order),
+          current_user: nil # Admin action, we don't want to assign current_user to the order
+        )
+      end
+
+      def deluxe_delayed_purchase_params
+        params.require(:effective_order).permit(
+          :id, :note_to_buyer, :note_internal, :send_mark_as_paid_email_to_buyer,
+          :purchased_url, :declined_url
+        )
+      end
+
+    end
+  end
+end

data/app/datatables/admin/effective_orders_datatable.rb

@@ -100,6 +100,14 @@ module Admin
 
       col :total, as: :price
 
+      if EffectiveOrders.delayed?
+        col :delayed_payment, visible: false
+        col :delayed_payment_date
+        col :delayed_payment_intent, visible: false
+        col :delayed_payment_purchase_ran_at, visible: false
+        col :delayed_payment_purchase_result, visible: false
+      end
+
       if EffectiveOrders.collect_note
         col :note, visible: false
       end

data/app/datatables/effective_orders_datatable.rb

@@ -60,6 +60,12 @@ class EffectiveOrdersDatatable < Effective::Datatable
     col :surcharge, as: :price, visible: false
     col(:surcharge_percent, visible: false) { |order| rate_to_percentage(order.surcharge_percent) }
 
+    if EffectiveOrders.delayed?
+      col :delayed_payment
+      col :delayed_payment_date
+      col :delayed_payment_intent
+    end
+
     col :total, as: :price
 
     if EffectiveOrders.collect_note

data/app/helpers/effective_deluxe_delayed_helper.rb

@@ -0,0 +1,15 @@
+module EffectiveDeluxeDelayedHelper
+
+  # https://developer.deluxe.com/s/article-hosted-payment-form
+  def deluxe_delayed_hosted_payment_form_options(order)
+    {
+      xtoken: EffectiveOrders.deluxe.fetch(:access_token),
+      containerId: "deluxeDelayedCheckout",
+      xcssid: "deluxeDelayedCheckoutCss",
+      xrtype: "Generate Token",
+      xpm: "1", # 0 = CC & ACH, 1 = CC, 2 = ACH
+      xautoprompt: false,
+      xbtntext: order_checkout_label(:deluxe_delayed)
+    }
+  end
+end

data/app/helpers/effective_orders_helper.rb

@@ -44,6 +44,8 @@ module EffectiveOrdersHelper
       'Pay by Cheque'
     when :deluxe
       'Pay Now'
+    when :deluxe_delayed
+      'Save now and charge me later'
     when :etransfer
       'Pay by E-transfer'
     when :free

data/app/models/effective/deluxe_api.rb

@@ -13,6 +13,8 @@ module Effective
     attr_accessor :access_token
     attr_accessor :currency
 
+    attr_accessor :purchase_response
+
     def initialize(environment: nil, client_id: nil, client_secret: nil, access_token: nil, currency: nil)
       self.environment = environment || EffectiveOrders.deluxe.fetch(:environment)
       self.client_id = client_id || EffectiveOrders.deluxe.fetch(:client_id)
@@ -21,11 +23,58 @@ module Effective
       self.currency = currency || EffectiveOrders.deluxe.fetch(:currency)
     end
 
+    def payment
+      raise('expected purchase response to be present') unless purchase_response.kind_of?(Hash)
+      purchase_response
+    end
+
+    # This calls Authorize Payment and Complete Payment
+    # Returns true if all good.
+    # Returns false if there was an error.
+    # Always sets the @purchase_response which is api.payment
+    def purchase!(order, payment_intent)
+      raise('expected a deluxe payment provider') unless ['deluxe', 'deluxe_delayed'].include?(order.payment_provider)
+
+      payment_intent = decode_payment_intent_payload(payment_intent) if payment_intent.kind_of?(String)
+      raise('expected payment_intent to be a Hash') unless payment_intent.kind_of?(Hash)
+      raise('expected a token payment') unless payment_intent['type'] == 'Token'
+
+      # Start a purchase. Which is an Authorization and a Completion
+      self.purchase_response = nil
+
+      # Process Authorization
+      authorization = authorize_payment(order, payment_intent)
+      self.purchase_response = authorization
+
+      valid = [0].include?(authorization['responseCode'])
+      return false unless valid
+
+      ## Complete Payment
+      payment = complete_payment(order, authorization)
+      self.purchase_response = payment
+
+      valid = [0].include?(payment['responseCode'])
+      return false unless valid
+
+      # Valid purchase. This is authorized and completed.
+      true
+    end
+
     # Health Check
     def health_check
       get('/')
     end
 
+    def healthy?
+      response = health_check()
+
+      return false unless response.kind_of?(Hash)
+      return false unless response['timestamp'].to_s.start_with?(Time.zone.now.strftime('%Y-%m-%d'))
+      return false unless response['environment'].present?
+
+      true
+    end
+
     # Authorize Payment
     def authorize_payment(order, payment_intent)
       response = post('/payments/authorize', params: authorize_payment_params(order, payment_intent))
@@ -191,6 +240,18 @@ module Effective
       { 'active_card' => active_card, 'card' => card, 'expDate' => date, 'cvv' => cvv }.compact
     end
 
+    # Decode the base64 encoded JSON object into a Hash
+    def decode_payment_intent_payload(payload)
+      raise('expected a string') unless payload.kind_of?(String)
+
+      payment_intent = (JSON.parse(Base64.decode64(payload)) rescue nil)
+
+      raise('expected payment_intent to be a Hash') unless payment_intent.kind_of?(Hash)
+      raise('expected a token payment') unless payment_intent['type'] == 'Token'
+
+      payment_intent
+    end
+
     private
 
     def headers

data/app/models/effective/order.rb

@@ -15,7 +15,7 @@ module Effective
     acts_as_statused(
       :pending,         # New orders are created in a pending state
       :confirmed,       # Once the order has passed checkout step 1
-      :deferred,        # Deferred providers. cheque, etransfer or phone was selected.
+      :deferred,        # Deferred providers. cheque, etransfer, phone or deluxe_delayed was selected.
       :purchased,       # Purchased by provider
       :declined,        # Declined by provider
       :voided,          # Voided by admin
@@ -94,6 +94,21 @@ module Effective
 
       total             :integer   # Subtotal + Tax + Surcharge + Surcharge Tax
 
+      # For use with the Deluxe Delayed Payment feature
+
+      # When an order is created. These two attributes can be set to create a delayed? order
+      delayed_payment         :boolean
+      delayed_payment_date    :date
+
+      # When the order goes to checkout we require the delayed_payment_intent
+      # This stores the user's card information in a secure way
+      # This is required for the order to become deferred?
+      delayed_payment_intent  :text
+
+      # Set by the rake task that runs 1/day and processes any delayed orders before or on that day
+      delayed_payment_purchase_ran_at   :datetime
+      delayed_payment_purchase_result   :text
+
       timestamps
     end
 
@@ -135,6 +150,15 @@ module Effective
     scope :refunds, -> { purchased.where('total < ?', 0) }
     scope :pending_refunds, -> { not_purchased.where('total < ?', 0) }
 
+    scope :delayed, -> { where(delayed_payment: true).where.not(delayed_payment_date: nil) }
+    scope :delayed_payment_date_past, -> { delayed.where(arel_table[:delayed_payment_date].lteq(Time.zone.today)) }
+    scope :delayed_payment_date_upcoming, -> { delayed.where(arel_table[:delayed_payment_date].gt(Time.zone.today)) }
+
+    # Used by the rake effective_orders:purchase_delayed_orders task
+    scope :delayed_ready_to_purchase, -> { 
+      delayed.deferred.delayed_payment_date_past.where(delayed_payment_purchase_ran_at: nil)
+    }
+
     # effective_reports
     def reportable_scopes
       { purchased: nil, not_purchased: nil, deferred: nil, refunds: nil, pending_refunds: nil }
@@ -165,6 +189,11 @@ module Effective
 
     validates :order_items, presence: { message: 'No items are present. Please add additional items.' }
 
+    # Delayed Payment Validations
+    validates :delayed_payment_date, presence: true, if: -> { delayed_payment? }
+    validates :delayed_payment_date, absence: true, unless: -> { delayed_payment? }
+    validates :delayed_payment_intent, presence: { message: 'please provide your card information' }, if: -> { delayed? && deferred? }
+
     validate do
       if EffectiveOrders.organization_enabled?
         errors.add(:base, "must have a User or #{EffectiveOrders.organization_class_name || 'Organization'}") if user_id.blank? && organization_id.blank?
@@ -392,46 +421,12 @@ module Effective
       purchased? ? 'Total Paid' : 'Total Due'
     end
 
-    # Visa - 1234
     def payment_method
-      return nil unless purchased?
-
-      provider = payment_provider if ['cheque', 'etransfer', 'phone', 'credit card'].include?(payment_provider)
-
-      # Normalize payment card
-      card = case payment_card.to_s.downcase.gsub(' ', '').strip
-        when '' then nil
-        when 'v', 'visa' then 'Visa'
-        when 'm', 'mc', 'master', 'mastercard' then 'MasterCard'
-        when 'a', 'ax', 'american', 'americanexpress' then 'American Express'
-        when 'd', 'discover' then 'Discover'
-        else payment_card.to_s
-      end
-
-      # Try again
-      if card == 'none' && payment['card_type'].present?
-        card = case payment['card_type'].to_s.downcase.gsub(' ', '').strip
-          when '' then nil
-          when 'v', 'visa' then 'Visa'
-          when 'm', 'mc', 'master', 'mastercard' then 'MasterCard'
-          when 'a', 'ax', 'american', 'americanexpress' then 'American Express'
-          when 'd', 'discover' then 'Discover'
-          else payment_card.to_s
-        end
-      end
-
-      last4 = if payment[:active_card] && payment[:active_card].include?('**** **** ****')
-        payment[:active_card][15,4]
-      end
-
-      last4 ||= if payment['active_card'] && payment['active_card'].include?('**** **** ****')
-        payment['active_card'][15,4]
-      end
-
-      # stripe, moneris, moneris_checkout
-      last4 ||= (payment['f4l4'] || payment['first6last4']).to_s.last(4)
+      payment_method_value if purchased?
+    end
 
-      [provider.presence, card.presence, last4.presence].compact.join(' - ')
+    def delayed_payment_method
+      payment_method_value if delayed?
     end
 
     def duplicate
@@ -538,6 +533,39 @@ module Effective
     def refund?
       total.to_i < 0
     end
+    
+    # A new order is created.
+    # If the delayed_payment and delayed_payment date are set, it's a delayed order
+    # A delayed order is one in which we have to capture a payment intent for the amount of the order.
+    # Once it's delayed and deferred we can purchase it at anytime.
+    def delayed?
+      delayed_payment? && delayed_payment_date.present?
+    end
+
+    def delayed_ready_to_purchase?
+      return false unless delayed? 
+      return false unless deferred?
+      return false unless delayed_payment_intent.present?
+      return false if delayed_payment_date_future?
+      return false if delayed_payment_purchase_ran_at.present? # We ran before and probably failed
+
+      true
+    end
+
+    def delayed_payment_date_future?
+      return false unless delayed?
+      delayed_payment_date > Time.zone.now.to_date
+    end
+
+    def delayed_payment_date_today?
+      return false unless delayed?
+      delayed_payment_date == Time.zone.now.to_date
+    end
+
+    def delayed_payment_date_past?
+      return false unless delayed?
+      delayed_payment_date < Time.zone.now.to_date
+    end
 
     def pending_refund?
       return false if EffectiveOrders.buyer_purchases_refund?
@@ -696,6 +724,23 @@ module Effective
       sync_quickbooks!(skip: true)
     end
 
+    # This was submitted via the deluxe_delayed provider checkout
+    # This is a special case of a deferred provider. We require the payment_intent and payment info
+    def delay!(payment:, payment_intent:, provider:, card:, email: false, validate: true)
+      raise('expected payment intent to be a String') unless payment_intent.kind_of?(String)
+      raise('expected a delayed payment provider') unless EffectiveOrders.delayed_providers.include?(provider)
+      raise('expected a delayed payment order with a delayed_payment_date') unless delayed_payment? && delayed_payment_date.present?
+
+      assign_attributes(
+        delayed_payment_intent: payment_intent, 
+
+        payment: payment_to_h(payment),
+        payment_card: (card.presence || 'none')
+      )
+
+      defer!(provider: provider, email: email, validate: validate)
+    end
+
     def defer!(provider: 'none', email: true, validate: true)
       raise('order already purchased') if purchased?
 
@@ -725,9 +770,7 @@ module Effective
         end
       rescue ActiveRecord::RecordInvalid => e
         self.status = status_was
-
         error = e.message
-        raise ::ActiveRecord::Rollback
       end
 
       raise "Failed to defer order: #{error || errors.full_messages.to_sentence}" unless error.nil?
@@ -766,9 +809,7 @@ module Effective
           run_purchasable_callbacks(:after_decline)
         rescue ActiveRecord::RecordInvalid => e
           self.status = status_was
-
           error = e.message
-          raise ::ActiveRecord::Rollback
         end
       end
 
@@ -884,6 +925,47 @@ module Effective
       subtotal + tax
     end
 
+    # Visa - 1234
+    def payment_method_value
+      provider = payment_provider if ['cheque', 'etransfer', 'phone', 'credit card'].include?(payment_provider)
+      provider = 'credit card' if ['deluxe_delayed'].include?(payment_provider)
+
+      # Normalize payment card
+      card = case payment_card.to_s.downcase.gsub(' ', '').strip
+        when '' then nil
+        when 'v', 'visa' then 'Visa'
+        when 'm', 'mc', 'master', 'mastercard' then 'MasterCard'
+        when 'a', 'ax', 'american', 'americanexpress' then 'American Express'
+        when 'd', 'discover' then 'Discover'
+        else payment_card.to_s
+      end
+
+      # Try again
+      if card == 'none' && payment['card_type'].present?
+        card = case payment['card_type'].to_s.downcase.gsub(' ', '').strip
+          when '' then nil
+          when 'v', 'visa' then 'Visa'
+          when 'm', 'mc', 'master', 'mastercard' then 'MasterCard'
+          when 'a', 'ax', 'american', 'americanexpress' then 'American Express'
+          when 'd', 'discover' then 'Discover'
+          else payment_card.to_s
+        end
+      end
+
+      last4 = if payment[:active_card] && payment[:active_card].include?('**** **** ****')
+        payment[:active_card][15,4]
+      end
+
+      last4 ||= if payment['active_card'] && payment['active_card'].include?('**** **** ****')
+        payment['active_card'][15,4]
+      end
+
+      # stripe, moneris, moneris_checkout
+      last4 ||= (payment['f4l4'] || payment['first6last4']).to_s.last(4)
+
+      [provider.presence, card.presence, last4.presence].compact.join(' - ')
+    end
+
     private
 
     def present_order_items

data/app/views/effective/orders/_checkout_step2.html.haml

@@ -14,6 +14,9 @@
   - elsif EffectiveOrders.refund? && order.refund?
     = render partial: '/effective/orders/refund/form', locals: provider_locals
 
+  - elsif EffectiveOrders.delayed? && order.delayed?
+    = render partial: '/effective/orders/delayed/form', locals: provider_locals
+
   - else
     - if EffectiveOrders.pretend?
       = render partial: '/effective/orders/pretend/form', locals: provider_locals
@@ -38,6 +41,10 @@
       = render partial: '/effective/orders/deferred/form', locals: provider_locals
 
   - if EffectiveResources.authorized?(controller, :admin, :effective_orders) && order.user != current_user
+    - if EffectiveOrders.delayed? && order.delayed? && order.deferred?
+      .effective-order-admin-purchase-actions
+        = render partial: '/effective/orders/delayed/form_purchase', locals: provider_locals
+
     - if EffectiveOrders.mark_as_paid?
       .effective-order-admin-purchase-actions
         = render partial: '/effective/orders/mark_as_paid/form', locals: provider_locals

data/app/views/effective/orders/_datatable_actions.html.haml

@@ -1,6 +1,6 @@
 = dropdown(variation: :dropleft) do
   - if EffectiveResources.authorized?(controller, :checkout, order)
-    = dropdown_link_to 'Checkout', effective_orders.order_path(order)
+    = dropdown_link_to 'Checkout', effective_orders.order_path(order), 'data-turbolinks': false
   - else
     = dropdown_link_to 'View', effective_orders.order_path(order)
 

data/app/views/effective/orders/_order_deferred.html.haml

@@ -6,4 +6,8 @@
           %th Payment
       %tbody
         %tr
-          %td Waiting for payment by #{order.payment_provider}
+          %td
+            - if order.delayed?
+              Your #{order.delayed_payment_method} will be charged on #{order.delayed_payment_date.strftime('%F')} for the full amount
+            - else
+              Waiting for payment by #{order.payment_provider}

data/app/views/effective/orders/delayed/_form.html.haml

@@ -0,0 +1,25 @@
+.card
+  .card-body
+    %h2 Save Card Info
+
+    %p 
+      = succeed('.') do
+        - distance = distance_of_time_in_words(Time.zone.now, order.delayed_payment_date)
+
+        The payment date for this order
+
+        - if order.delayed_payment_date_future?
+          is in #{distance} from now on #{order.delayed_payment_date.strftime('%F')}
+        - elsif order.delayed_payment_date_today?
+          was today
+        - else
+          was #{distance} ago on #{order.delayed_payment_date.strftime('%F')}
+
+    %p
+      Instead of charging your card right away, the following action will securely save a token
+      representing your card information. The full amount will be charged on the payment date.
+
+    - provider_locals = { order: order, deferred_url: deferred_url, declined_url: declined_url }
+
+    - EffectiveOrders.delayed_providers.each do |provider|
+      = render partial: "/effective/orders/#{provider}/form", locals: provider_locals

data/app/views/effective/orders/delayed/_form_purchase.html.haml

@@ -0,0 +1,30 @@
+.card
+  .card-body
+    %h2 Admin: Purchase Delayed Order
+
+    - raise('unexpected purchased order') if order.purchased?
+    - raise('expected a deferred delayed order') unless order.delayed? && order.deferred?
+    - raise('expecting a payment intent') unless order.delayed_payment_intent.present?
+    - raise('expecting a payment method') unless order.delayed_payment_method.present?
+
+    %p 
+      = succeed('.') do
+        - distance = distance_of_time_in_words(Time.zone.now, order.delayed_payment_date)
+
+        The payment date for this order
+
+        - if order.delayed_payment_date_future?
+          is in #{distance} from now on #{order.delayed_payment_date.strftime('%F')}
+        - elsif order.delayed_payment_date_today?
+          was today
+        - else
+          was #{distance} ago on #{order.delayed_payment_date.strftime('%F')}
+
+    %p The #{order.delayed_payment_method} on file will be charged automatically on the payment date.
+
+    %p You can also charge it right now.
+
+    - provider_locals = { order: order, purchased_url: purchased_url, declined_url: declined_url }
+
+    - EffectiveOrders.delayed_providers.each do |provider|
+      = render partial: "/effective/orders/#{provider}/form_purchase", locals: provider_locals

data/app/views/effective/orders/deluxe_delayed/_css.html.haml

@@ -0,0 +1,12 @@
+:css
+  #dppPaymentContainer {
+    .form-control { }
+    .form-label { }
+
+    button {
+      color: #fff;
+      background-color: #0d6efd;
+      border_color: #0d6efd;
+      padding: 0.375rem 0.75rem;
+    }
+  }

data/app/views/effective/orders/deluxe_delayed/_element.html.haml

@@ -0,0 +1,9 @@
+.effective-deluxe-delayed-checkout
+  #deluxe-delayed-checkout-loading.text-center Loading...
+  #deluxe-delayed-checkout-errors.text-danger
+
+  %style#deluxeDelayedCheckoutCss
+    -# Pass in custom CSS to the Deluxe Delayed hosted payment form iframe
+    = render('effective/orders/deluxe_delayed/css')
+
+  #deluxeDelayedCheckout

data/app/views/effective/orders/deluxe_delayed/_form.html.haml

@@ -0,0 +1,10 @@
+- deluxe_delayed = deluxe_delayed_hosted_payment_form_options(order)
+
+= effective_form_with(scope: :deluxe_delayed, url: effective_orders.deluxe_delayed_order_path(order), data: { 'deluxe-delayed-checkout': deluxe_delayed.to_json }) do |f|
+  = f.hidden_field :declined_url, value: declined_url
+  = f.hidden_field :deferred_url, value: deferred_url
+
+  -# This is set by the deluxe.js javascript on Submit
+  = f.hidden_field :payment_intent, required: true
+
+  = render('effective/orders/deluxe_delayed/element')

data/app/views/effective/orders/deluxe_delayed/_form_purchase.html.haml

@@ -0,0 +1,18 @@
+= effective_form_with(model: order, url: effective_orders.deluxe_delayed_purchase_order_path(order), method: :post) do |f|
+  = f.hidden_field :id
+
+  = f.hidden_field :purchased_url, value: purchased_url
+  = f.hidden_field :declined_url, value: declined_url
+
+  = f.check_box :send_mark_as_paid_email_to_buyer,
+    label: 'Yes, send a receipt email to the buyer.',
+    input_html: { checked: (f.object.send_mark_as_paid_email_to_buyer.nil? ? EffectiveOrders.send_order_receipts_when_mark_as_paid : f.object.send_mark_as_paid_email_to_buyer?) }
+
+  .row
+    .col
+      = f.text_area :note_to_buyer, hint: 'This message will be displayed to the buyer on the receipt.'
+    .col
+      = f.text_area :note_internal, hint: 'For or internal admin use only. This note will never be displayed to the buyer.'
+
+  = f.submit(center: true) do
+    = f.save 'Purchase Order from Saved Card'

data/app/views/effective/orders/mark_as_paid/_form.html.haml

@@ -4,6 +4,8 @@
       Admin:
       = order.refund? ? 'Complete Refund' : 'Mark as Paid'
 
+      - raise('unexpected purchased order') if order.purchased?
+
     = effective_form_with(model: order, url: effective_orders.mark_as_paid_order_path(order), method: :post) do |f|
       .row
         .col-6

data/config/effective_orders.rb

@@ -133,6 +133,15 @@ EffectiveOrders.setup do |config|
   #   currency: 'CAD'
   # }
 
+  # Deluxe Delayed
+  # This is a deferred payment
+  config.deluxe_delayed = false
+
+  # config.deluxe_delayed = {
+  #   confirm: 'Save card info for later payment',
+  #   success: 'Thank you! You have indicated that this order will be purchased by credit card at a later date. We will save your card information securely and process the payment when the order is ready'
+  # }
+
   # E-transfer
   # This is an deferred payment
   config.etransfer = false

data/config/routes.rb

@@ -8,7 +8,10 @@ EffectiveOrders::Engine.routes.draw do
         post :send_buyer_receipt
 
         post :cheque
-        post :deluxe
+        post :deluxe              # 1-off payment and purchase
+        post :deluxe_delayed      # 1-off payment_intent saving
+        post :deluxe_delayed_purchase # Admin action to purchase a delayed order
+
         post :etransfer
         post :free
         post :mark_as_paid

data/db/migrate/101_create_effective_orders.rb

@@ -40,6 +40,12 @@ class CreateEffectiveOrders < ActiveRecord::Migration[6.0]
       t.integer   :surcharge_tax
       t.integer   :total
 
+      t.boolean   :delayed_payment, default: false
+      t.date      :delayed_payment_date
+      t.text      :delayed_payment_intent
+      t.datetime  :delayed_payment_purchase_ran_at
+      t.text      :delayed_payment_purchase_result
+
       t.timestamps
     end
 

data/lib/effective_orders/version.rb

@@ -1,3 +1,3 @@
 module EffectiveOrders
-  VERSION = '6.11.1'.freeze
+  VERSION = '6.12.1'.freeze
 end

data/lib/effective_orders.rb

@@ -42,7 +42,7 @@ module EffectiveOrders
       :free_enabled, :mark_as_paid_enabled, :pretend_enabled, :pretend_message, :buyer_purchases_refund,
 
       # Payment processors. false or Hash
-      :cheque, :deluxe, :etransfer, :moneris, :moneris_checkout, :paypal, :phone, :refund, :stripe, :subscriptions, :trial
+      :cheque, :deluxe, :deluxe_delayed, :etransfer, :moneris, :moneris_checkout, :paypal, :phone, :refund, :stripe, :subscriptions, :trial
     ]
   end
 
@@ -85,10 +85,18 @@ module EffectiveOrders
     deluxe.kind_of?(Hash)
   end
 
+  def self.deluxe_delayed?
+    deluxe_delayed.kind_of?(Hash)
+  end
+
   def self.deferred?
     deferred_providers.present?
   end
 
+  def self.delayed?
+    delayed_providers.present?
+  end
+
   def self.mark_as_paid?
     mark_as_paid_enabled == true
   end
@@ -178,7 +186,11 @@ module EffectiveOrders
   end
 
   def self.deferred_providers
-    [('cheque' if cheque?), ('etransfer' if etransfer?), ('phone' if phone?)].compact
+    [('cheque' if cheque?), ('deluxe_delayed' if deluxe_delayed?), ('etransfer' if etransfer?), ('phone' if phone?)].compact
+  end
+
+  def self.delayed_providers
+    [('deluxe_delayed' if deluxe_delayed?)].compact
   end
 
   def self.credit_card_payment_providers

data/lib/tasks/effective_orders_tasks.rake

@@ -66,4 +66,10 @@ namespace :effective_orders do
     end
   end
 
+  # rake effective_orders:purchase_delayed_orders
+  desc 'Purchases delayed orders on their delayed_payment_date for effective orders'
+  task purchase_delayed_orders: :environment do
+    puts 'Todo'
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_orders
 version: !ruby/object:Gem::Version
-  version: 6.11.1
+  version: 6.12.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-17 00:00:00.000000000 Z
+date: 2024-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -194,6 +194,7 @@ files:
 - app/assets/javascripts/effective_orders.js
 - app/assets/javascripts/effective_orders/customers.js.coffee
 - app/assets/javascripts/effective_orders/providers/deluxe.js
+- app/assets/javascripts/effective_orders/providers/deluxe_delayed.js
 - app/assets/javascripts/effective_orders/providers/moneris_checkout.js.coffee
 - app/assets/javascripts/effective_orders/providers/stripe.js.coffee
 - app/assets/javascripts/effective_orders/subscriptions.js.coffee
@@ -210,6 +211,8 @@ files:
 - app/controllers/effective/orders_controller.rb
 - app/controllers/effective/providers/cheque.rb
 - app/controllers/effective/providers/deluxe.rb
+- app/controllers/effective/providers/deluxe_delayed.rb
+- app/controllers/effective/providers/deluxe_delayed_purchase.rb
 - app/controllers/effective/providers/etransfer.rb
 - app/controllers/effective/providers/free.rb
 - app/controllers/effective/providers/mark_as_paid.rb
@@ -230,6 +233,7 @@ files:
 - app/datatables/admin/report_transactions_grouped_by_qb_name_datatable.rb
 - app/datatables/effective_orders_datatable.rb
 - app/helpers/effective_carts_helper.rb
+- app/helpers/effective_deluxe_delayed_helper.rb
 - app/helpers/effective_deluxe_helper.rb
 - app/helpers/effective_moneris_checkout_helper.rb
 - app/helpers/effective_orders_helper.rb
@@ -295,9 +299,15 @@ files:
 - app/views/effective/orders/declined.html.haml
 - app/views/effective/orders/deferred.html.haml
 - app/views/effective/orders/deferred/_form.html.haml
+- app/views/effective/orders/delayed/_form.html.haml
+- app/views/effective/orders/delayed/_form_purchase.html.haml
 - app/views/effective/orders/deluxe/_css.html.haml
 - app/views/effective/orders/deluxe/_element.html.haml
 - app/views/effective/orders/deluxe/_form.html.haml
+- app/views/effective/orders/deluxe_delayed/_css.html.haml
+- app/views/effective/orders/deluxe_delayed/_element.html.haml
+- app/views/effective/orders/deluxe_delayed/_form.html.haml
+- app/views/effective/orders/deluxe_delayed/_form_purchase.html.haml
 - app/views/effective/orders/edit.html.haml
 - app/views/effective/orders/etransfer/_form.html.haml
 - app/views/effective/orders/free/_form.html.haml