activemerchant 1.133.0 → 1.137.0

data/lib/active_merchant/billing/gateways/plexo.rb

@@ -67,6 +67,7 @@ module ActiveMerchant #:nodoc:
       def verify(credit_card, options = {})
         post = {}
         post[:ReferenceId] = options[:reference_id] || generate_unique_id
+        post[:Flow] = 'direct'
         post[:MerchantId] = options[:merchant_id] || @credentials[:merchant_id]
         post[:StatementDescriptor] = options[:statement_descriptor] if options[:statement_descriptor]
         post[:CustomerId] = options[:customer_id] if options[:customer_id]
@@ -76,6 +77,7 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options[:metadata])
         add_amount(money, post, options)
         add_browser_details(post, options)
+        add_invoice_number(post, options)
 
         commit('/verify', post, options)
       end
@@ -90,7 +92,8 @@ module ActiveMerchant #:nodoc:
           gsub(%r(("Number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
           gsub(%r(("Cvc\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
           gsub(%r(("InvoiceNumber\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
-          gsub(%r(("MerchantId\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
+          gsub(%r(("MerchantId\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("Cryptogram\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
       end
 
       private
@@ -105,12 +108,14 @@ module ActiveMerchant #:nodoc:
         post[:Installments] = options[:installments] if options[:installments]
         post[:StatementDescriptor] = options[:statement_descriptor] if options[:statement_descriptor]
         post[:CustomerId] = options[:customer_id] if options[:customer_id]
+        post[:Flow] = 'direct'
 
         add_payment_method(post, payment, options)
         add_items(post, options[:items])
         add_metadata(post, options[:metadata])
         add_amount(money, post, options)
         add_browser_details(post, options)
+        add_invoice_number(post, options)
       end
 
       def header(parameters = {})
@@ -186,21 +191,55 @@ module ActiveMerchant #:nodoc:
         post[:BrowserDetails][:IpAddress] = browser_details[:ip] if browser_details[:ip]
       end
 
+      def add_invoice_number(post, options)
+        post[:InvoiceNumber] = options[:invoice_number] if options[:invoice_number]
+      end
+
       def add_payment_method(post, payment, options)
-        post[:paymentMethod] = {}
+        payment_method = build_payment_method(payment)
 
-        if payment&.is_a?(CreditCard)
-          post[:paymentMethod][:type] = 'card'
-          post[:paymentMethod][:Card] = {}
-          post[:paymentMethod][:Card][:Number] = payment.number
-          post[:paymentMethod][:Card][:ExpMonth] = format(payment.month, :two_digits) if payment.month
-          post[:paymentMethod][:Card][:ExpYear] = format(payment.year, :two_digits) if payment.year
-          post[:paymentMethod][:Card][:Cvc] = payment.verification_value if payment.verification_value
+        if payment_method.present?
+          add_card_holder(payment_method[:NetworkToken] || payment_method[:Card], payment, options)
+          post[:paymentMethod] = payment_method
+        end
+      end
 
-          add_card_holder(post[:paymentMethod][:Card], payment, options)
+      def build_payment_method(payment)
+        case payment
+        when NetworkTokenizationCreditCard
+          {
+            source: 'network-token',
+            id: payment.brand,
+            NetworkToken: {
+              Number: payment.number,
+              Bin: get_last_eight_digits(payment.number),
+              Last4: get_last_four_digits(payment.number),
+              ExpMonth: (format(payment.month, :two_digits) if payment.month),
+              ExpYear: (format(payment.year, :two_digits) if payment.year),
+              Cryptogram: payment.payment_cryptogram
+            }
+          }
+        when CreditCard
+          {
+            type: 'card',
+            Card: {
+              Number: payment.number,
+              ExpMonth: (format(payment.month, :two_digits) if payment.month),
+              ExpYear: (format(payment.year, :two_digits) if payment.year),
+              Cvc: payment.verification_value
+            }
+          }
         end
       end
 
+      def get_last_eight_digits(number)
+        number[-8..-1]
+      end
+
+      def get_last_four_digits(number)
+        number[-4..-1]
+      end
+
       def add_card_holder(card, payment, options)
         requires!(options, :email)
 

data/lib/active_merchant/billing/gateways/plugnpay.rb

@@ -178,11 +178,15 @@ module ActiveMerchant
         success = SUCCESS_CODES.include?(response[:finalstatus])
         message = success ? 'Success' : message_from(response)
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test?,
           authorization: response[:orderid],
           avs_result: { code: response[:avs_code] },
-          cvv_result: response[:cvvresp])
+          cvv_result: response[:cvvresp]
+        )
       end
 
       def parse(body)

data/lib/active_merchant/billing/gateways/priority.rb

@@ -55,7 +55,8 @@ module ActiveMerchant #:nodoc:
 
         add_merchant_id(params)
         add_amount(params, amount, options)
-        add_auth_purchase_params(params, credit_card, options)
+        add_auth_purchase_params(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
 
         commit('purchase', params: params)
       end
@@ -67,7 +68,8 @@ module ActiveMerchant #:nodoc:
 
         add_merchant_id(params)
         add_amount(params, amount, options)
-        add_auth_purchase_params(params, credit_card, options)
+        add_auth_purchase_params(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
 
         commit('purchase', params: params)
       end
@@ -100,7 +102,7 @@ module ActiveMerchant #:nodoc:
         add_merchant_id(params)
         add_amount(params, amount, options)
         params['paymentToken'] = payment_token(authorization) || options[:payment_token]
-        params['tenderType'] = options[:tender_type].present? ? options[:tender_type] : 'Card'
+        add_auth_purchase_params(params, options)
 
         commit('capture', params: params)
       end
@@ -150,9 +152,8 @@ module ActiveMerchant #:nodoc:
         params['merchantId'] = @options[:merchant_id]
       end
 
-      def add_auth_purchase_params(params, credit_card, options)
+      def add_auth_purchase_params(params, options)
         add_replay_id(params, options)
-        add_credit_card(params, credit_card, 'purchase', options)
         add_purchases_data(params, options)
         add_shipping_data(params, options)
         add_pos_data(params, options)

data/lib/active_merchant/billing/gateways/psigate.rb

@@ -102,11 +102,15 @@ module ActiveMerchant #:nodoc:
       def commit(money, creditcard, options = {})
         response = parse(ssl_post(url, post_data(money, creditcard, options)))
 
-        Response.new(successful?(response), message_from(response), response,
+        Response.new(
+          successful?(response),
+          message_from(response),
+          response,
           test: test?,
           authorization: build_authorization(response),
           avs_result: { code: response[:avsresult] },
-          cvv_result: response[:cardidresult])
+          cvv_result: response[:cardidresult]
+        )
       end
 
       def url

data/lib/active_merchant/billing/gateways/psl_card.rb

@@ -259,11 +259,15 @@ module ActiveMerchant
       def commit(request)
         response = parse(ssl_post(self.live_url, post_data(request)))
 
-        Response.new(response[:ResponseCode] == APPROVED, response[:Message], response,
+        Response.new(
+          response[:ResponseCode] == APPROVED,
+          response[:Message],
+          response,
           test: test?,
           authorization: response[:CrossReference],
           cvv_result: CVV_CODE[response[:AVSCV2Check]],
-          avs_result: { code: AVS_CODE[response[:AVSCV2Check]] })
+          avs_result: { code: AVS_CODE[response[:AVSCV2Check]] }
+        )
       end
 
       # Put the passed data into a format that can be submitted to PSL

data/lib/active_merchant/billing/gateways/qbms.rb

@@ -142,12 +142,16 @@ module ActiveMerchant #:nodoc:
         response = parse(type, data)
         message = (response[:status_message] || '').strip
 
-        Response.new(success?(response), message, response,
+        Response.new(
+          success?(response),
+          message,
+          response,
           test: test?,
           authorization: response[:credit_card_trans_id],
           fraud_review: fraud_review?(response),
           avs_result: { code: avs_result(response) },
-          cvv_result: cvv_result(response))
+          cvv_result: cvv_result(response)
+        )
       end
 
       def success?(response)

data/lib/active_merchant/billing/gateways/quantum.rb

@@ -215,11 +215,15 @@ module ActiveMerchant #:nodoc:
           authorization = success ? authorization_for(response) : nil
         end
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test?,
           authorization: authorization,
           avs_result: { code: response[:AVSResponseCode] },
-          cvv_result: response[:CVV2ResponseCode])
+          cvv_result: response[:CVV2ResponseCode]
+        )
       end
 
       # Parse the SOAP response

data/lib/active_merchant/billing/gateways/quickbooks.rb

@@ -42,10 +42,10 @@ module ActiveMerchant #:nodoc:
         'PMT-5001' => STANDARD_ERROR_CODE[:card_declined],      # Merchant does not support given payment method
 
         # System Error
-        'PMT-6000' => STANDARD_ERROR_CODE[:processing_error], # A temporary Issue prevented this request from being processed.
+        'PMT-6000' => STANDARD_ERROR_CODE[:processing_error] # A temporary Issue prevented this request from being processed.
       }
 
-      FRAUD_WARNING_CODES = ['PMT-1000', 'PMT-1001', 'PMT-1002', 'PMT-1003']
+      FRAUD_WARNING_CODES = %w(PMT-1000 PMT-1001 PMT-1002 PMT-1003)
 
       def initialize(options = {})
         # Quickbooks is deprecating OAuth 1.0 on December 17, 2019.
@@ -128,8 +128,8 @@ module ActiveMerchant #:nodoc:
           gsub(%r((oauth_nonce=\")\w+), '\1[FILTERED]').
           gsub(%r((oauth_signature=\")[a-zA-Z%0-9]+), '\1[FILTERED]').
           gsub(%r((oauth_token=\")\w+), '\1[FILTERED]').
-          gsub(%r((number\D+)\d{16}), '\1[FILTERED]').
-          gsub(%r((cvc\D+)\d{3}), '\1[FILTERED]').
+          gsub(%r((number\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((cvc\\\":\\\")\d+), '\1[FILTERED]').
           gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
           gsub(%r((access_token\\?":\\?")[\w\-\.]+)i, '\1[FILTERED]').
           gsub(%r((refresh_token\\?":\\?")\w+), '\1[FILTERED]').
@@ -263,7 +263,7 @@ module ActiveMerchant #:nodoc:
         oauth_parameters[:oauth_signature] = CGI.escape(Base64.encode64(hmac_signature).chomp.delete("\n"))
 
         # prepare Authorization header string
-        oauth_parameters = Hash[oauth_parameters.sort_by { |k, _| k }]
+        oauth_parameters = oauth_parameters.sort_by { |k, _| k }.to_h
         oauth_headers = ["OAuth realm=\"#{@options[:realm]}\""]
         oauth_headers += oauth_parameters.map { |k, v| "#{k}=\"#{v}\"" }
 
@@ -358,6 +358,7 @@ module ActiveMerchant #:nodoc:
         rescue JSON::ParserError
           raise response_error
         end
+
         response_error.response.body
       end
 

data/lib/active_merchant/billing/gateways/quickpay/quickpay_v10.rb

@@ -153,9 +153,13 @@ module ActiveMerchant
           response = json_error(response)
         end
 
-        Response.new(success, message_from(success, response), response,
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
           test: test?,
-          authorization: authorization_from(response))
+          authorization: authorization_from(response)
+        )
       end
 
       def authorization_from(response)
@@ -251,7 +255,7 @@ module ActiveMerchant
 
         requires!(address, :name, :address1, :city, :zip, :country)
         country = Country.find(address[:country])
-        mapped = {
+        {
           name: address[:name],
           street: address[:address1],
           city: address[:city],
@@ -259,7 +263,6 @@ module ActiveMerchant
           zip_code: address[:zip],
           country_code: country.code(:alpha3).value
         }
-        mapped
       end
 
       def format_order_id(order_id)

data/lib/active_merchant/billing/gateways/quickpay/quickpay_v4to7.rb

@@ -164,9 +164,13 @@ module ActiveMerchant #:nodoc:
       def commit(action, params)
         response = parse(ssl_post(self.live_url, post_data(action, params)))
 
-        Response.new(successful?(response), message_from(response), response,
+        Response.new(
+          successful?(response),
+          message_from(response),
+          response,
           test: test?,
-          authorization: response[:transaction])
+          authorization: response[:transaction]
+        )
       end
 
       def successful?(response)

data/lib/active_merchant/billing/gateways/rapyd.rb

@@ -1,12 +1,17 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class RapydGateway < Gateway
+      class_attribute :payment_redirect_test, :payment_redirect_live
+
       self.test_url = 'https://sandboxapi.rapyd.net/v1/'
       self.live_url = 'https://api.rapyd.net/v1/'
 
+      self.payment_redirect_test = 'https://sandboxpayment-redirect.rapyd.net/v1/'
+      self.payment_redirect_live = 'https://payment-redirect.rapyd.net/v1/'
+
       self.supported_countries = %w(CA CL CO DO SV PE PT VI AU HK IN ID JP MY NZ PH SG KR TW TH VN AD AT BE BA BG HR CY CZ DK EE FI FR GE DE GI GR GL HU IS IE IL IT LV LI LT LU MK MT MD MC ME NL GB NO PL RO RU SM SK SI ZA ES SE CH TR VA)
       self.default_currency = 'USD'
-      self.supported_cardtypes = %i[visa master american_express discover]
+      self.supported_cardtypes = %i[visa master american_express discover verve]
 
       self.homepage_url = 'https://www.rapyd.net/'
       self.display_name = 'Rapyd Gateway'
@@ -63,11 +68,11 @@ module ActiveMerchant #:nodoc:
       def store(payment, options = {})
         post = {}
         add_payment(post, payment, options)
-        add_customer_object(post, payment, options)
+        add_customer_data(post, payment, options, 'store')
         add_metadata(post, options)
         add_ewallet(post, options)
         add_payment_fields(post, options)
-        add_payment_urls(post, options)
+        add_payment_urls(post, options, 'store')
         add_address(post, payment, options)
         commit(:post, 'customers', post)
       end
@@ -100,14 +105,18 @@ module ActiveMerchant #:nodoc:
       def add_auth_purchase(post, money, payment, options)
         add_invoice(post, money, options)
         add_payment(post, payment, options)
-        add_customer_object(post, payment, options)
+        add_customer_data(post, payment, options)
         add_3ds(post, payment, options)
         add_address(post, payment, options)
         add_metadata(post, options)
         add_ewallet(post, options)
         add_payment_fields(post, options)
         add_payment_urls(post, options)
-        add_customer_id(post, options)
+        add_idempotency(options)
+      end
+
+      def add_idempotency(options)
+        @options[:idempotency] = options[:idempotency_key] if options[:idempotency_key]
       end
 
       def add_address(post, creditcard, options)
@@ -128,6 +137,10 @@ module ActiveMerchant #:nodoc:
       def add_invoice(post, money, options)
         post[:amount] = money.zero? ? 0 : amount(money).to_f.to_s
         post[:currency] = (options[:currency] || currency(money))
+        post[:merchant_reference_id] = options[:merchant_reference_id] || options[:order_id]
+        post[:requested_currency] = options[:requested_currency] if options[:requested_currency].present?
+        post[:fixed_side] = options[:fixed_side] if options[:fixed_side].present?
+        post[:expiration] = (options[:expiration_days] || 7).to_i.days.from_now.to_i if options[:fixed_side].present?
       end
 
       def add_payment(post, payment, options)
@@ -136,15 +149,27 @@ module ActiveMerchant #:nodoc:
         elsif payment.is_a?(Check)
           add_ach(post, payment, options)
         else
-          add_token(post, payment, options)
+          add_tokens(post, payment, options)
         end
       end
 
       def add_stored_credential(post, options)
-        return unless stored_credential = options[:stored_credential]
+        add_network_reference_id(post, options)
+        add_initiation_type(post, options)
+      end
+
+      def add_network_reference_id(post, options)
+        return unless (options[:stored_credential] && options[:stored_credential][:reason_type] == 'recurring') || options[:network_transaction_id]
+
+        network_transaction_id = options[:network_transaction_id] || options[:stored_credential][:network_transaction_id]
+        post[:payment_method][:fields][:network_reference_id] = network_transaction_id unless network_transaction_id&.empty?
+      end
+
+      def add_initiation_type(post, options)
+        return unless options[:stored_credential] || options[:initiation_type]
 
-        post[:payment_method][:fields][:network_reference_id] = stored_credential[:network_transaction_id] if stored_credential[:network_transaction_id]
-        post[:initiation_type] = stored_credential[:reason_type] if stored_credential[:reason_type]
+        initiation_type = options[:initiation_type] || options[:stored_credential][:reason_type]
+        post[:initiation_type] = initiation_type if initiation_type
       end
 
       def add_creditcard(post, payment, options)
@@ -154,14 +179,23 @@ module ActiveMerchant #:nodoc:
 
         post[:payment_method][:type] = options[:pm_type]
         pm_fields[:number] = payment.number
-        pm_fields[:expiration_month] = payment.month.to_s
-        pm_fields[:expiration_year] = payment.year.to_s
+        pm_fields[:expiration_month] = format(payment.month, :two_digits).to_s
+        pm_fields[:expiration_year] = format(payment.year, :two_digits).to_s
         pm_fields[:name] = "#{payment.first_name} #{payment.last_name}"
-        pm_fields[:cvv] = payment.verification_value.to_s
-
+        pm_fields[:cvv] = payment.verification_value.to_s unless valid_network_transaction_id?(options) || payment.verification_value.blank?
+        pm_fields[:recurrence_type] = options[:recurrence_type] if options[:recurrence_type]
         add_stored_credential(post, options)
       end
 
+      def send_customer_object?(options)
+        options[:stored_credential] && options[:stored_credential][:reason_type] == 'recurring'
+      end
+
+      def valid_network_transaction_id?(options)
+        network_transaction_id = options[:network_tansaction_id] || options.dig(:stored_credential_options, :network_transaction_id) || options.dig(:stored_credential, :network_transaction_id)
+        return network_transaction_id.present?
+      end
+
       def add_ach(post, payment, options)
         post[:payment_method] = {}
         post[:payment_method][:fields] = {}
@@ -175,22 +209,27 @@ module ActiveMerchant #:nodoc:
         post[:payment_method][:fields][:payment_purpose] = options[:payment_purpose] if options[:payment_purpose]
       end
 
-      def add_token(post, payment, options)
-        return unless token = payment.split('|')[1]
+      def add_tokens(post, payment, options)
+        return unless payment.respond_to?(:split)
 
-        post[:payment_method] = token
+        customer_id, card_id = payment.split('|')
+
+        post[:customer] = customer_id unless send_customer_object?(options)
+        post[:payment_method] = card_id
       end
 
       def add_3ds(post, payment, options)
-        return unless three_d_secure = options[:three_d_secure]
-
-        post[:payment_method_options] = {}
-        post[:payment_method_options]['3d_required'] = three_d_secure[:required]
-        post[:payment_method_options]['3d_version'] = three_d_secure[:version]
-        post[:payment_method_options][:cavv] = three_d_secure[:cavv]
-        post[:payment_method_options][:eci] = three_d_secure[:eci]
-        post[:payment_method_options][:xid] = three_d_secure[:xid]
-        post[:payment_method_options][:ds_trans_id] = three_d_secure[:ds_transaction_id]
+        if options[:execute_threed] == true
+          post[:payment_method_options] = { '3d_required' => true } if options[:force_3d_secure].to_s == 'true'
+        elsif three_d_secure = options[:three_d_secure]
+          post[:payment_method_options] = {}
+          post[:payment_method_options]['3d_required'] = three_d_secure[:required]
+          post[:payment_method_options]['3d_version'] = three_d_secure[:version]
+          post[:payment_method_options][:cavv] = three_d_secure[:cavv]
+          post[:payment_method_options][:eci] = three_d_secure[:eci]
+          post[:payment_method_options][:xid] = three_d_secure[:xid]
+          post[:payment_method_options][:ds_trans_id] = three_d_secure[:ds_transaction_id]
+        end
       end
 
       def add_metadata(post, options)
@@ -198,27 +237,67 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_ewallet(post, options)
-        post[:ewallet_id] = options[:ewallet_id] if options[:ewallet_id]
+        post[:ewallet] = options[:ewallet_id] if options[:ewallet_id]
       end
 
       def add_payment_fields(post, options)
-        post[:payment] = {}
+        post[:description] = options[:description] if options[:description]
+        post[:statement_descriptor] = options[:statement_descriptor] if options[:statement_descriptor]
+        post[:save_payment_method] = options[:save_payment_method] if options[:save_payment_method]
+      end
+
+      def add_payment_urls(post, options, action = '')
+        if action == 'store'
+          url_location = post[:payment_method]
+        else
+          url_location = post
+        end
+
+        url_location[:complete_payment_url] = options[:complete_payment_url] if options[:complete_payment_url]
+        url_location[:error_payment_url] = options[:error_payment_url] if options[:error_payment_url]
+      end
+
+      def add_customer_data(post, payment, options, action = '')
+        phone_number = options.dig(:billing_address, :phone) || options.dig(:billing_address, :phone_number)
+        post[:phone_number] = phone_number.gsub(/\D/, '') unless phone_number.nil?
+        post[:receipt_email] = options[:email] if payment.is_a?(String) && options[:customer_id].present? && !send_customer_object?(options)
 
-        post[:payment][:description] = options[:description] if options[:description]
-        post[:payment][:statement_descriptor] = options[:statement_descriptor] if options[:statement_descriptor]
+        return if payment.is_a?(String)
+        return add_customer_id(post, options) if options[:customer_id]
+
+        if action == 'store'
+          post.merge!(customer_fields(payment, options))
+        else
+          post[:customer] = customer_fields(payment, options) unless send_customer_object?(options)
+        end
       end
 
-      def add_payment_urls(post, options)
-        post[:complete_payment_url] = options[:complete_payment_url] if options[:complete_payment_url]
-        post[:error_payment_url] = options[:error_payment_url] if options[:error_payment_url]
+      def customer_fields(payment, options)
+        return if options[:customer_id]
+
+        customer_address = address(options)
+        customer_data = {}
+        customer_data[:name] = "#{payment.first_name} #{payment.last_name}" unless payment.is_a?(String)
+        customer_data[:email] = options[:email] unless payment.is_a?(String) && options[:customer_id].blank?
+        customer_data[:addresses] = [customer_address] if customer_address
+        customer_data
       end
 
-      def add_customer_object(post, payment, options)
-        post[:name] = "#{payment.first_name} #{payment.last_name}" unless payment.is_a?(String)
-        phone = options.dig(:billing_address, :phone) .gsub(/\D/, '') unless options[:billing_address].nil?
-        post[:phone_number] = phone || options.dig(:customer, :phone_number)
-        post[:email] = options[:email] || options.dig(:customer, :email)
-        post[:addresses] = options.dig(:customer, :addresses) if USA_PAYMENT_METHODS.include?(options[:pm_type])
+      def address(options)
+        return unless address = options[:billing_address]
+
+        formatted_address = {}
+
+        formatted_address[:name] = address[:name] if address[:name]
+        formatted_address[:line_1] = address[:address1] if address[:address1]
+        formatted_address[:line_2] = address[:address2] if address[:address2]
+        formatted_address[:city] = address[:city] if address[:city]
+        formatted_address[:state] = address[:state] if address[:state]
+        formatted_address[:country] = address[:country] if address[:country]
+        formatted_address[:zip] = address[:zip] if address[:zip]
+        formatted_address[:phone_number] = address[:phone].gsub(/\D/, '') if address[:phone]
+
+        formatted_address
       end
 
       def add_customer_id(post, options)
@@ -228,13 +307,21 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         return {} if body.empty? || body.nil?
 
-        JSON.parse(body)
+        parsed = JSON.parse(body)
+        parsed.is_a?(Hash) ? parsed : { 'status' => { 'status' => parsed } }
+      end
+
+      def url(action, url_override = nil)
+        if url_override.to_s == 'payment_redirect' && action == 'payments'
+          (self.test? ? self.payment_redirect_test : self.payment_redirect_live) + action.to_s
+        else
+          (self.test? ? self.test_url : self.live_url) + action.to_s
+        end
       end
 
       def commit(method, action, parameters)
-        url = (test? ? test_url : live_url) + action.to_s
         rel_path = "#{method}/v1/#{action}"
-        response = api_request(method, url, rel_path, parameters)
+        response = api_request(method, url(action, @options[:url_override]), rel_path, parameters)
 
         Response.new(
           success_from(response),
@@ -246,10 +333,25 @@ module ActiveMerchant #:nodoc:
           test: test?,
           error_code: error_code_from(response)
         )
+      rescue ActiveMerchant::ResponseError => e
+        response = e.response.body.present? ? parse(e.response.body) : { 'status' => { 'response_code' => e.response.msg } }
+        message = response['status'].slice('message', 'response_code').values.select(&:present?).first || ''
+        Response.new(false, message, response, test: test?, error_code: error_code_from(response))
+      end
+
+      # We need to revert the work of ActiveSupport JSON encoder to prevent discrepancies
+      # Between the signature and the actual request body
+      def revert_json_html_encoding!(string)
+        {
+          '\\u003e' => '>',
+          '\\u003c' => '<',
+          '\\u0026' => '&'
+        }.each { |k, v| string.gsub! k, v }
       end
 
       def api_request(method, url, rel_path, params)
         params == {} ? body = '' : body = params.to_json
+        revert_json_html_encoding!(body) if defined?(ActiveSupport::JSON::Encoding) && ActiveSupport::JSON::Encoding.escape_html_entities_in_json
         parse(ssl_request(method, url, body, headers(rel_path, body)))
       end
 
@@ -261,14 +363,14 @@ module ActiveMerchant #:nodoc:
           'access_key' => @options[:access_key],
           'salt' => salt,
           'timestamp' => timestamp,
-          'signature' => generate_hmac(rel_path, salt, timestamp, payload)
-        }
+          'signature' => generate_hmac(rel_path, salt, timestamp, payload),
+          'idempotency' => @options[:idempotency]
+        }.delete_if { |_, value| value.nil? }
       end
 
       def generate_hmac(rel_path, salt, timestamp, payload)
         signature = "#{rel_path}#{salt}#{timestamp}#{@options[:access_key]}#{@options[:secret_key]}#{payload}"
-        hash = Base64.urlsafe_encode64(OpenSSL::HMAC.hexdigest('sha256', @options[:secret_key], signature))
-        hash
+        Base64.urlsafe_encode64(OpenSSL::HMAC.hexdigest('sha256', @options[:secret_key], signature))
       end
 
       def avs_result(response)
@@ -303,7 +405,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def error_code_from(response)
-        response.dig('status', 'error_code') unless success_from(response)
+        response.dig('status', 'error_code') || response.dig('status', 'response_code') || ''
       end
 
       def handle_response(response)