effective_orders 6.19.2 → 6.19.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2119b880e68ea2d6a6cff0b63b19f46af89200c95a6c917b188620b6e5a51bd2
-  data.tar.gz: '0651700787a2b4e1fc128a9d1c2afda4af0a0876de085bf6c13d4a6f4c3db243'
+  metadata.gz: 9ac540563873add27dbdaae886f216f3c20e0abe562476d7736e7c8ff73c04b2
+  data.tar.gz: 562b4bd4ecb4204e44f8910e4f633932ab172c3a377f2662beaefdd733e4e505
 SHA512:
-  metadata.gz: f85e8299609856e55e738c652acf1204cf21ed84733e468bc65181ee03e8c6b49e3915e5755ce1270898af2cde256b9aa1242536d33b04e1a85682b27780b92a
-  data.tar.gz: b182d9dcbefd3dc1b028823a29085af08a31d57d90c448d98edc69dd3977093509ad16b25f53df4fe65be9dd2abc7dc2a484ecf52ebc365697d607d1c84c40b3
+  metadata.gz: c6e7dca80311b8aa229dbba54979ff85319035d2ee7b61c7b65d7cff7502207d7a882a82921011f4680ba337d39e6d84cf4cbe8bb9137df2fe844c2fa9edcb13
+  data.tar.gz: 35e988323e5dd995719e34ad8b8a0976f32185c31fa82001604fb077b9801f7d933a40b9bcd50c9193607bb1c83dee1fceae26c5267506ba2d980cbad7861d1a

data/app/models/effective/deluxe_api.rb

@@ -14,6 +14,7 @@ module Effective
     attr_accessor :currency
 
     attr_accessor :purchase_response
+    attr_accessor :read_timeout
 
     def initialize(environment: nil, client_id: nil, client_secret: nil, access_token: nil, currency: nil)
       self.environment = environment || EffectiveOrders.deluxe.fetch(:environment)
@@ -99,7 +100,7 @@ module Effective
 
     # Create Payment
     def create_payment(order, payment_intent)
-      response = post('/payments', params: create_payment_params(order, payment_intent))
+      response = post_once('/payments', params: create_payment_params(order, payment_intent))
 
       # Sanity check response
       raise('expected responseCode') unless response.kind_of?(Hash) && response['responseCode'].present?
@@ -125,52 +126,133 @@ module Effective
       purchase_response
     end
 
+    def payment_approved?(order)
+      payment = search_payment(order)
+      return false if payment.blank?
+
+      payment.dig('payment', 'responseCode').present? && payment.dig('payment', 'authResponse').to_s.downcase.include?('approved')
+    end
+
+    # Search for an existing Payment
+    def search_payment(order)
+      date = (order.delayed_payment_purchase_ran_at || order.purchased_at || order.created_at || Time.zone.now)
+      response = post('/payments/search', params: { orderId: order.to_param, startDate: date.strftime('%m/%d/%Y'), endDate: (date + 1.day).strftime('%m/%d/%Y') })
+
+      # Sanity check response
+      raise('expected valid search') unless response.kind_of?(Hash) && response['isSuccess'] == true
+
+      # Find the payment for this order
+      payment = Array(response.dig('data', 'payments')).find { |payment| payment.dig('payment', 'orderId') == order.to_param }
+      return unless payment.present?
+
+      # Return the payment hash
+      payment
+    end
+
+    def purchase_delayed_order!(order)
+      raise('expected a delayed order') unless order.delayed?
+      raise('expected a deferred order') unless order.deferred?
+      raise('expected delayed payment intent') unless order.delayed_payment_intent.present?
+      raise('expected a delayed_ready_to_purchase? order') unless order.delayed_ready_to_purchase?
+
+      order.update_columns(delayed_payment_purchase_ran_at: Time.zone.now, delayed_payment_purchase_result: nil)
+
+      purchased = if order.total.to_i > 0
+        purchase!(order, order.delayed_payment_intent)
+      elsif order.free?
+        purchase_free!(order)
+      else
+        raise("Unexpected order amount: #{order.total}")
+      end
+
+      provider = (order.free? ? 'free' : order.payment_provider)
+      payment = self.payment()
+      card = payment["card"] || payment[:card]
+
+      if purchased
+        order.assign_attributes(delayed_payment_purchase_result: "success")
+        order.purchase!(payment: payment, provider: provider, card: card, email: true, skip_buyer_validations: true)
+
+        puts "Successfully purchased order #{order.id}"
+      else
+        order.assign_attributes(delayed_payment_purchase_result: "failed: #{Array(payment['responseMessage']).to_sentence.presence || 'none'}")
+        order.decline!(payment: payment, provider: provider, card: card, email: true)
+
+        puts "Failed to purchase order #{order.id} #{order.delayed_payment_purchase_result}"
+      end
+
+      purchased
+    end
+
+    def retry_purchase_delayed_order!(order)
+      raise('expected a delayed order') unless order.delayed?
+      raise('expected a deferred order') unless order.deferred?
+      raise('expected delayed payment intent') unless order.delayed_payment_intent.present?
+      raise('expected an order with a positive total') unless order.total.to_i > 0
+
+      order.update_columns(delayed_payment_purchase_ran_at: Time.zone.now, delayed_payment_purchase_result: nil)
+
+      # Look up the existing payment on Deluxe API
+      existing_payment = search_payment(order)
+      existing_purchased = existing_payment.present? && existing_payment.dig('payment', 'responseCode').present? && existing_payment.dig('payment', 'authResponse').to_s.downcase.include?('approved')
+
+      # If it doesn't exist, purchase it now
+      purchased = (existing_purchased || purchase!(order, order.delayed_payment_intent))
+
+      # Payment
+      provider = order.payment_provider
+      payment = (existing_payment if existing_purchased) || self.payment()
+      card = payment.dig('payment', 'card', 'cardType') || payment.dig('payment', 'card') || payment['card'] || payment[:card]
+
+      if purchased
+        order.assign_attributes(delayed_payment_purchase_result: "success")
+        order.purchase!(payment: payment, provider: provider, card: card, email: true, skip_buyer_validations: true)
+
+        puts "Successfully purchased order #{order.id}"
+      else
+        order.assign_attributes(delayed_payment_purchase_result: "failed: #{Array(payment['responseMessage']).to_sentence.presence || 'none'}")
+        order.decline!(payment: payment, provider: provider, card: card, email: true)
+
+        puts "Failed to purchase order #{order.id} #{order.delayed_payment_purchase_result}"
+      end
+
+      purchased
+    end
+
     # Called by rake task
     def purchase_delayed_orders!(orders)
-      now = Time.zone.now
+      # Orders that failed to purchase and need to be retried
+      retry_orders = []
 
+      # First pass over all the orders
       Array(orders).each do |order|
         puts "Trying order #{order.id}"
 
         begin
-          raise('expected a delayed order') unless order.delayed?
-          raise('expected a deferred order') unless order.deferred?
-          raise('expected delayed payment intent') unless order.delayed_payment_intent.present?
-          raise('expected a delayed_ready_to_purchase? order') unless order.delayed_ready_to_purchase?
-
-          order.update_columns(delayed_payment_purchase_ran_at: now, delayed_payment_purchase_result: nil)
-
-          purchased = if order.total.to_i > 0
-            purchase!(order, order.delayed_payment_intent)
-          elsif order.free?
-            purchase_free!(order)
-          else
-            raise("Unexpected order amount: #{order.total}")
-          end
-
-          provider = (order.free? ? 'free' : order.payment_provider)
-          payment = self.payment()
-          card = payment["card"] || payment[:card]
+          purchase_delayed_order!(order)
+        rescue => e
+          order.update_columns(delayed_payment_purchase_ran_at: Time.zone.now, delayed_payment_purchase_result: "error: #{e.message}")
+          retry_orders << order
 
-          if purchased
-            order.assign_attributes(delayed_payment_purchase_result: "success")
-            order.purchase!(payment: payment, provider: provider, card: card, email: true, skip_buyer_validations: true)
+          puts "Error purchasing #{order.id}: #{e.message}"
+        end
+      end
 
-            puts "Successfully purchased order #{order.id}"
-          else
-            order.assign_attributes(delayed_payment_purchase_result: "failed with message: #{Array(payment['responseMessage']).to_sentence.presence || 'none'}")
-            order.decline!(payment: payment, provider: provider, card: card, email: true)
+      # Second pass over all the orders that raised an error on call to purchase
+      orders = Effective::Order.where(id: retry_orders.map(&:id))
 
-            puts "Failed to purchase order #{order.id} #{order.delayed_payment_purchase_result}"
-          end
+      Array(orders).each do |order|
+        puts "Retrying order #{order.id}"
 
+        begin
+          retry_purchase_delayed_order!(order)
         rescue => e
-          order.update_columns(delayed_payment_purchase_ran_at: now, delayed_payment_purchase_result: "error: #{e.message}")
+          order.update_columns(delayed_payment_purchase_ran_at: Time.zone.now, delayed_payment_purchase_result: "error: #{e.message}")
 
           EffectiveLogger.error(e.message, associated: order) if defined?(EffectiveLogger)
           ExceptionNotifier.notify_exception(e, data: { order_id: order.id }) if defined?(ExceptionNotifier)
 
-          puts "Error purchasing #{order.id}: #{e.message}"
+          puts "Error retry purchasing #{order.id}: #{e.message}"
 
           raise(e) if Rails.env.development? || Rails.env.test?
         end
@@ -260,7 +342,7 @@ module Effective
 
       orderData = {
         autoGenerateOrderId: true,
-        orderID: order.to_param,
+        orderId: order.to_param,
         orderIdIsUnique: true
       }
 
@@ -282,7 +364,7 @@ module Effective
       uri = URI.parse(api_url + endpoint + query.to_s)
 
       http = Net::HTTP.new(uri.host, uri.port)
-      http.read_timeout = 20
+      http.read_timeout = (read_timeout || 30)
       http.use_ssl = true
 
       result = with_retries do
@@ -301,7 +383,7 @@ module Effective
       uri = URI.parse(api_url + endpoint)
 
       http = Net::HTTP.new(uri.host, uri.port)
-      http.read_timeout = 20
+      http.read_timeout = (read_timeout || 30)
       http.use_ssl = true
 
       result = with_retries do
@@ -316,6 +398,21 @@ module Effective
       JSON.parse(result.body)
     end
 
+    def post_once(endpoint, params:)
+      uri = URI.parse(api_url + endpoint)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.read_timeout = (read_timeout || 30)
+      http.use_ssl = true
+
+      puts "[POST] #{uri} #{params}" if Rails.env.development?
+
+      response = http.post(uri.path, params.to_json, headers)
+      raise Exception.new("#{response.code} #{response.body}") unless response.code == '200'
+
+      JSON.parse(response.body)
+    end
+
     private
 
     def headers

data/lib/effective_orders/version.rb

@@ -1,3 +1,3 @@
 module EffectiveOrders
-  VERSION = '6.19.2'.freeze
+  VERSION = '6.19.4'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_orders
 version: !ruby/object:Gem::Version
-  version: 6.19.2
+  version: 6.19.4
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-03 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails