activemerchant 1.133.0 → 1.138.0

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

@@ -1,10 +1,12 @@
 require 'active_merchant/billing/gateways/cyber_source/cyber_source_common'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CyberSourceRestGateway < Gateway
       include ActiveMerchant::Billing::CyberSourceCommon
 
+      version 'v2'
+
       self.test_url = 'https://apitest.cybersource.com'
       self.live_url = 'https://api.cybersource.com'
 
@@ -12,7 +14,7 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'USD'
       self.currencies_without_fractions = ActiveMerchant::Billing::CyberSourceGateway.currencies_without_fractions
 
-      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb maestro elo union_pay cartes_bancaires mada]
+      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb maestro elo union_pay cartes_bancaires mada patagonia_365 tarjeta_sol]
 
       self.homepage_url = 'http://www.cybersource.com'
       self.display_name = 'Cybersource REST'
@@ -28,14 +30,20 @@ module ActiveMerchant #:nodoc:
         maestro: '042',
         master: '002',
         unionpay: '062',
-        visa: '001'
+        visa: '001',
+        carnet: '002'
       }
 
-      PAYMENT_SOLUTION = {
+      WALLET_PAYMENT_SOLUTION = {
         apple_pay: '001',
         google_pay: '012'
       }
 
+      NT_PAYMENT_SOLUTION = {
+        'master' => '014',
+        'visa' => '015'
+      }
+
       def initialize(options = {})
         requires!(options, :merchant_id, :public_key, :private_key)
         super
@@ -72,7 +80,7 @@ module ActiveMerchant #:nodoc:
 
       def void(authorization, options = {})
         payment, amount = authorization.split('|')
-        post = build_void_request(amount)
+        post = build_void_request(options, amount)
         commit("payments/#{payment}/reversals", post)
       end
 
@@ -93,6 +101,7 @@ module ActiveMerchant #:nodoc:
           gsub(/(\\?"number\\?":\\?")\d+/, '\1[FILTERED]').
           gsub(/(\\?"routingNumber\\?":\\?")\d+/, '\1[FILTERED]').
           gsub(/(\\?"securityCode\\?":\\?")\d+/, '\1[FILTERED]').
+          gsub(/(\\?"cryptogram\\?":\\?")[^<]+/, '\1[FILTERED]').
           gsub(/(signature=")[^"]*/, '\1[FILTERED]').
           gsub(/(keyid=")[^"]*/, '\1[FILTERED]').
           gsub(/(Digest: SHA-256=)[\w\/\+=]*/, '\1[FILTERED]')
@@ -100,9 +109,51 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      def build_void_request(amount = nil)
+      def add_level_2_data(post, options)
+        return unless options[:purchase_order_number]
+
+        post[:orderInformation][:invoiceDetails] ||= {}
+        post[:orderInformation][:invoiceDetails][:purchaseOrderNumber] = options[:purchase_order_number]
+      end
+
+      def add_level_3_data(post, options)
+        return unless options[:line_items]
+
+        post[:orderInformation][:lineItems] = options[:line_items]
+        post[:processingInformation][:purchaseLevel] = '3'
+        post[:orderInformation][:shipping_details] = { shipFromPostalCode: options[:ships_from_postal_code] }
+        post[:orderInformation][:amountDetails] ||= {}
+        post[:orderInformation][:amountDetails][:discountAmount] = options[:discount_amount]
+      end
+
+      def add_three_ds(post, payment_method, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:consumerAuthenticationInformation] ||= {}
+        if payment_method.brand == 'master'
+          post[:consumerAuthenticationInformation][:ucafAuthenticationData] = three_d_secure[:cavv]
+          post[:consumerAuthenticationInformation][:ucafCollectionIndicator] = '2'
+        else
+          post[:consumerAuthenticationInformation][:cavv] = three_d_secure[:cavv]
+        end
+        post[:consumerAuthenticationInformation][:cavvAlgorithm] = three_d_secure[:cavv_algorithm] if three_d_secure[:cavv_algorithm]
+        post[:consumerAuthenticationInformation][:paSpecificationVersion] = three_d_secure[:version] if three_d_secure[:version]
+        post[:consumerAuthenticationInformation][:directoryServerTransactionID] = three_d_secure[:ds_transaction_id] if three_d_secure[:ds_transaction_id]
+        post[:consumerAuthenticationInformation][:eciRaw] = three_d_secure[:eci] if three_d_secure[:eci]
+        if three_d_secure[:xid].present?
+          post[:consumerAuthenticationInformation][:xid] = three_d_secure[:xid]
+        else
+          post[:consumerAuthenticationInformation][:xid] = three_d_secure[:cavv]
+        end
+        post[:consumerAuthenticationInformation][:veresEnrolled] = three_d_secure[:enrolled] if three_d_secure[:enrolled]
+        post[:consumerAuthenticationInformation][:paresStatus] = three_d_secure[:authentication_response_status] if three_d_secure[:authentication_response_status]
+        post
+      end
+
+      def build_void_request(options, amount = nil)
         { reversalInformation: { amountDetails: { totalAmount: nil } } }.tap do |post|
           add_reversal_amount(post, amount.to_i) if amount.present?
+          add_merchant_category_code(post, options)
         end.compact
       end
 
@@ -116,8 +167,12 @@ module ActiveMerchant #:nodoc:
           add_address(post, payment, options[:billing_address], options, :billTo)
           add_address(post, payment, options[:shipping_address], options, :shipTo)
           add_business_rules_data(post, payment, options)
+          add_merchant_category_code(post, options)
           add_partner_solution_id(post)
           add_stored_credentials(post, payment, options)
+          add_three_ds(post, payment, options)
+          add_level_2_data(post, options)
+          add_level_3_data(post, options)
         end.compact
       end
 
@@ -126,6 +181,7 @@ module ActiveMerchant #:nodoc:
           add_code(post, options)
           add_mdd_fields(post, options)
           add_amount(post, amount, options)
+          add_merchant_category_code(post, options)
           add_partner_solution_id(post)
         end.compact
       end
@@ -136,6 +192,7 @@ module ActiveMerchant #:nodoc:
           add_credit_card(post, payment)
           add_mdd_fields(post, options)
           add_amount(post, amount, options)
+          add_merchant_category_code(post, options)
           add_address(post, payment, options[:billing_address], options, :billTo)
           add_merchant_description(post, options)
         end.compact
@@ -165,7 +222,7 @@ module ActiveMerchant #:nodoc:
         currency = options[:currency] || currency(amount)
         post[:orderInformation][:amountDetails] = {
           totalAmount: localized_amount(amount, currency),
-          currency: currency
+          currency:
         }
       end
 
@@ -191,18 +248,40 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_network_tokenization_card(post, payment, options)
-        post[:processingInformation][:paymentSolution] = PAYMENT_SOLUTION[payment.source]
-        post[:processingInformation][:commerceIndicator] = 'internet' unless card_brand(payment) == 'jcb'
-
-        post[:paymentInformation][:tokenizedCard] = {
-          number: payment.number,
-          expirationMonth: payment.month,
-          expirationYear: payment.year,
-          cryptogram: payment.payment_cryptogram,
-          transactionType: '1',
-          type:  CREDIT_CARD_CODES[card_brand(payment).to_sym]
-        }
+        if options.dig(:stored_credential, :initiator) == 'merchant'
+          post[:paymentInformation][:tokenizedCard] = {
+            number: payment.number,
+            expirationMonth: payment.month,
+            expirationYear: payment.year,
+            type:  CREDIT_CARD_CODES[card_brand(payment).to_sym],
+            transactionType: payment.source == :network_token ? '3' : '1'
+          }
+        else
+          post[:paymentInformation][:tokenizedCard] = {
+            number: payment.number,
+            expirationMonth: payment.month,
+            expirationYear: payment.year,
+            cryptogram: payment.payment_cryptogram,
+            type:  CREDIT_CARD_CODES[card_brand(payment).to_sym],
+            transactionType: payment.source == :network_token ? '3' : '1'
+          }
+          add_apple_pay_google_pay_cryptogram(post, payment) unless payment.source == :network_token
+        end
+
+        post[:processingInformation][:commerceIndicator] = 'internet' unless options[:stored_credential] || card_brand(payment) == 'jcb'
+
+        add_payment_solution(post, payment)
+      end
+
+      def add_payment_solution(post, payment)
+        if payment.source == :network_token && NT_PAYMENT_SOLUTION[payment.brand]
+          post[:processingInformation][:paymentSolution] = NT_PAYMENT_SOLUTION[payment.brand]
+        else
+          post[:processingInformation][:paymentSolution] = WALLET_PAYMENT_SOLUTION[payment.source]
+        end
+      end
 
+      def add_apple_pay_google_pay_cryptogram(post, payment)
         if card_brand(payment) == 'master'
           post[:consumerAuthenticationInformation] = {
             ucafAuthenticationData: payment.payment_cryptogram,
@@ -257,57 +336,51 @@ module ActiveMerchant #:nodoc:
         merchant[:locality] = options[:merchant_descriptor_locality] if options[:merchant_descriptor_locality]
       end
 
+      def add_merchant_category_code(post, options)
+        return unless options[:merchant_category_code]
+
+        post[:merchantInformation] ||= {}
+        post[:merchantInformation][:categoryCode] = options[:merchant_category_code] if options[:merchant_category_code]
+      end
+
       def add_stored_credentials(post, payment, options)
-        return unless stored_credential = options[:stored_credential]
+        return unless options[:stored_credential]
 
-        options = stored_credential_options(stored_credential, options.fetch(:reason_code, ''))
-        post[:processingInformation][:commerceIndicator] = options.fetch(:transaction_type, 'internet')
-        stored_credential[:initial_transaction] ? initial_transaction(post, options) : subsequent_transaction(post, options)
+        post[:processingInformation][:commerceIndicator] = commerce_indicator(options.dig(:stored_credential, :reason_type))
+        add_authorization_options(post, payment, options)
       end
 
-      def stored_credential_options(options, reason_code)
-        transaction_type = options[:reason_type]
-        transaction_type = 'install' if transaction_type == 'installment'
-        initiator = options[:initiator] if  options[:initiator]
-        initiator = 'customer' if initiator == 'cardholder'
-        stored_on_file = options[:reason_type] == 'recurring'
-        options.merge({
-          transaction_type: transaction_type,
-          initiator: initiator,
-          reason_code: reason_code,
-          stored_on_file: stored_on_file
-        })
+      def commerce_indicator(reason_type)
+        case reason_type
+        when 'recurring'
+          'recurring'
+        when 'installment'
+          'install'
+        else
+          'internet'
+        end
       end
 
-      def add_processing_information(initiator, merchant_initiated_transaction_hash = {})
-        {
+      def add_authorization_options(post, payment, options)
+        initiator = options.dig(:stored_credential, :initiator) == 'cardholder' ? 'customer' : 'merchant'
+        authorization_options = {
           authorizationOptions: {
             initiator: {
-              type: initiator,
-              merchantInitiatedTransaction: merchant_initiated_transaction_hash,
-              storedCredentialUsed: true
+              type: initiator
             }
           }
         }.compact
-      end
 
-      def initial_transaction(post, options)
-        processing_information = add_processing_information(options[:initiator], {
-          reason: options[:reason_code]
-        })
-
-        post[:processingInformation].merge!(processing_information)
-      end
-
-      def subsequent_transaction(post, options)
-        network_transaction_id = options[:network_transaction_id] || options.dig(:stored_credential, :network_transaction_id) || ''
-        processing_information = add_processing_information(options[:initiator], {
-          originalAuthorizedAmount: post.dig(:orderInformation, :amountDetails, :totalAmount),
-          previousTransactionID: network_transaction_id,
-          reason: options[:reason_code],
-          storedCredentialUsed: options[:stored_on_file]
-        })
-        post[:processingInformation].merge!(processing_information)
+        authorization_options[:authorizationOptions][:initiator][:storedCredentialUsed] = true if initiator == 'merchant'
+        authorization_options[:authorizationOptions][:initiator][:credentialStoredOnFile] = true if options.dig(:stored_credential, :initial_transaction)
+        authorization_options[:authorizationOptions][:initiator][:merchantInitiatedTransaction] ||= {}
+        unless options.dig(:stored_credential, :initial_transaction)
+          network_transaction_id = options[:network_transaction_id] || options.dig(:stored_credential, :network_transaction_id) || ''
+          authorization_options[:authorizationOptions][:initiator][:merchantInitiatedTransaction][:previousTransactionID] = network_transaction_id
+          authorization_options[:authorizationOptions][:initiator][:merchantInitiatedTransaction][:originalAuthorizedAmount] = post.dig(:orderInformation, :amountDetails, :totalAmount) if card_brand(payment) == 'discover'
+        end
+        authorization_options[:authorizationOptions][:initiator][:merchantInitiatedTransaction][:reason] = options[:reason_code] if options[:reason_code]
+        post[:processingInformation].merge!(authorization_options)
       end
 
       def network_transaction_id_from(response)
@@ -315,7 +388,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def url(action)
-        "#{(test? ? test_url : live_url)}/pts/v2/#{action}"
+        "#{test? ? test_url : live_url}/pts/#{fetch_version}/#{action}"
       end
 
       def host
@@ -330,7 +403,7 @@ module ActiveMerchant #:nodoc:
         add_reconciliation_id(post, options)
         add_sec_code(post, options)
         add_invoice_number(post, options)
-        response = parse(ssl_post(url(action), post.to_json, auth_headers(action, post)))
+        response = parse(ssl_post(url(action), post.to_json, auth_headers(action, options, post)))
         Response.new(
           success_from(response),
           message_from(response),
@@ -355,38 +428,35 @@ module ActiveMerchant #:nodoc:
       def message_from(response)
         return response['status'] if success_from(response)
 
-        response['errorInformation']['message'] || response['message']
+        response.dig('errorInformation', 'message') || response['message']
       end
 
       def authorization_from(response)
         id = response['id']
-        has_amount = response['orderInformation'] && response['orderInformation']['amountDetails'] && response['orderInformation']['amountDetails']['authorizedAmount']
-        amount = response['orderInformation']['amountDetails']['authorizedAmount'].delete('.') if has_amount
-
-        return id if amount.blank?
+        amount = response.dig('orderInformation', 'amountDetails', 'authorizedAmount')&.delete('.')
 
-        [id, amount].join('|')
+        amount.present? ? [id, amount].join('|') : id
       end
 
       def error_code_from(response)
-        response['errorInformation']['reason'] unless success_from(response)
+        response.dig('errorInformation', 'reason') unless success_from(response)
       end
 
       # This implementation follows the Cybersource guide on how create the request signature, see:
       # https://developer.cybersource.com/docs/cybs/en-us/payments/developer/all/rest/payments/GenerateHeader/httpSignatureAuthentication.html
       def get_http_signature(resource, digest, http_method = 'post', gmtdatetime = Time.now.httpdate)
         string_to_sign = {
-          host: host,
+          host:,
           date: gmtdatetime,
-          "(request-target)": "#{http_method} /pts/v2/#{resource}",
-          digest: digest,
-          "v-c-merchant-id": @options[:merchant_id]
+          'request-target': "#{http_method} /pts/#{fetch_version}/#{resource}",
+          digest:,
+          'v-c-merchant-id': @options[:merchant_id]
         }.map { |k, v| "#{k}: #{v}" }.join("\n").force_encoding(Encoding::UTF_8)
 
         {
           keyid: @options[:public_key],
           algorithm: 'HmacSHA256',
-          headers: "host date (request-target)#{digest.present? ? ' digest' : ''} v-c-merchant-id",
+          headers: "host date request-target#{digest.present? ? ' digest' : ''} v-c-merchant-id",
           signature: sign_payload(string_to_sign)
         }.map { |k, v| %{#{k}="#{v}"} }.join(', ')
       end
@@ -396,14 +466,14 @@ module ActiveMerchant #:nodoc:
         Base64.strict_encode64(OpenSSL::HMAC.digest('sha256', decoded_key, payload))
       end
 
-      def auth_headers(action, post, http_method = 'post')
+      def auth_headers(action, options, post, http_method = 'post')
         digest = "SHA-256=#{Digest::SHA256.base64digest(post.to_json)}" if post.present?
         date = Time.now.httpdate
 
         {
           'Accept' => 'application/hal+json;charset=utf-8',
           'Content-Type' => 'application/json;charset=utf-8',
-          'V-C-Merchant-Id' => @options[:merchant_id],
+          'V-C-Merchant-Id' => options[:merchant_id] || @options[:merchant_id],
           'Date' => date,
           'Host' => host,
           'Signature' => get_http_signature(action, digest, http_method, date),
@@ -422,7 +492,7 @@ module ActiveMerchant #:nodoc:
         return unless mdd_fields.present?
 
         post[:merchantDefinedInformation] = mdd_fields.map do |key, value|
-          { key: key, value: value }
+          { key:, value: }
         end
       end
 
@@ -441,7 +511,8 @@ module ActiveMerchant #:nodoc:
       def add_invoice_number(post, options)
         return unless options[:invoice_number].present?
 
-        post[:orderInformation][:invoiceDetails] = { invoiceNumber: options[:invoice_number] }
+        post[:orderInformation][:invoiceDetails] ||= {}
+        post[:orderInformation][:invoiceDetails][:invoiceNumber] = options[:invoice_number]
       end
 
       def add_partner_solution_id(post)

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

@@ -1,12 +1,12 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class DLocalGateway < Gateway
       self.test_url = 'https://sandbox.dlocal.com'
       self.live_url = 'https://api.dlocal.com'
 
       self.supported_countries = %w[AR BD BO BR CL CM CN CO CR DO EC EG GH GT IN ID JP KE MY MX MA NG PA PY PE PH SN SV TH TR TZ UG UY VN ZA]
       self.default_currency = 'USD'
-      self.supported_cardtypes = %i[visa master american_express discover jcb diners_club maestro naranja cabal elo alia carnet]
+      self.supported_cardtypes = %i[visa master american_express discover jcb diners_club maestro naranja cabal elo alia carnet patagonia_365 tarjeta_sol]
 
       self.homepage_url = 'https://dlocal.com/'
       self.display_name = 'dLocal'
@@ -42,6 +42,7 @@ module ActiveMerchant #:nodoc:
 
       def refund(money, authorization, options = {})
         post = {}
+        add_description(post, options)
         post[:payment_id] = authorization
         post[:notification_url] = options[:notification_url]
         add_invoice(post, money, options) if money
@@ -90,9 +91,9 @@ module ActiveMerchant #:nodoc:
         add_payer(post, card, options)
         add_card(post, card, action, options)
         add_additional_data(post, options)
+        add_description(post, options)
         post[:order_id] = options[:order_id] || generate_unique_id
         post[:original_order_id] = options[:original_order_id] if options[:original_order_id]
-        post[:description] = options[:description] if options[:description]
       end
 
       def add_invoice(post, money, options)
@@ -100,14 +101,19 @@ module ActiveMerchant #:nodoc:
         post[:currency] = (options[:currency] || currency(money))
       end
 
+      def add_description(post, options)
+        post[:description] = options[:description] if options[:description]
+      end
+
       def add_additional_data(post, options)
         post[:additional_risk_data] = options[:additional_data]
       end
 
       def add_country(post, card, options)
-        return unless address = options[:billing_address] || options[:address]
+        return unless (address = options[:billing_address] || options[:address]) || options[:country]
 
-        post[:country] = lookup_country_code(address[:country])
+        country = options[:country] ? lookup_country_code(options[:country]) : lookup_country_code(address[:country])
+        post[:country] = country
       end
 
       def lookup_country_code(country_field)
@@ -118,16 +124,18 @@ module ActiveMerchant #:nodoc:
 
       def add_payer(post, card, options)
         address = options[:billing_address] || options[:address]
+        phone_number = address[:phone] || address[:phone_number] if address
+
         post[:payer] = {}
         post[:payer][:name] = card.name
         post[:payer][:email] = options[:email] if options[:email]
         post[:payer][:birth_date] = options[:birth_date] if options[:birth_date]
-        post[:payer][:phone] = address[:phone] if address && address[:phone]
+        post[:payer][:phone] = phone_number if phone_number
         post[:payer][:document] = options[:document] if options[:document]
         post[:payer][:document2] = options[:document2] if options[:document2]
         post[:payer][:user_reference] = options[:user_reference] if options[:user_reference]
         post[:payer][:event_uuid] = options[:device_id] if options[:device_id]
-        post[:payer][:onboarding_ip_address] = options[:ip] if options[:ip]
+        post[:payer][:ip] = options[:ip] if options[:ip]
         post[:payer][:address] = add_address(post, card, options)
       end
 
@@ -163,23 +171,20 @@ module ActiveMerchant #:nodoc:
           post[:card][:network_token] = card.number
           post[:card][:cryptogram] = card.payment_cryptogram
           post[:card][:eci] = card.eci
-          # used case of Network Token: 'CARD_ON_FILE', 'SUBSCRIPTION', 'UNSCHEDULED_CARD_ON_FILE'
-          if options.dig(:stored_credential, :reason_type) == 'unscheduled'
-            if options.dig(:stored_credential, :initiator) == 'merchant'
-              post[:card][:stored_credential_type] = 'UNSCHEDULED_CARD_ON_FILE'
-            else
-              post[:card][:stored_credential_type] = 'CARD_ON_FILE'
-            end
-          else
-            post[:card][:stored_credential_type] = 'SUBSCRIPTION'
-          end
-          # required for MC debit recurrent in BR 'USED'(subsecuence Payments) . 'FIRST' an inital payment
-          post[:card][:stored_credential_usage] = (options[:stored_credential][:initial_transaction] ? 'FIRST' : 'USED') if options[:stored_credential]
+          post[:card][:bin] = options[:issuer_identification_number] if options[:issuer_identification_number]
         else
           post[:card][:number] = card.number
           post[:card][:cvv] = card.verification_value
         end
 
+        if options[:stored_credential]
+          # required for MC debit recurrent in BR 'USED'(subsecuence Payments) . 'FIRST' an inital payment
+          post[:card][:stored_credential_usage] = (options[:stored_credential][:initial_transaction] ? 'FIRST' : 'USED')
+          post[:card][:network_payment_reference] = options[:stored_credential][:network_transaction_id] if options[:stored_credential][:network_transaction_id]
+          # used case of Network Token: 'CARD_ON_FILE', 'SUBSCRIPTION', 'UNSCHEDULED_CARD_ON_FILE'
+          post[:card][:stored_credential_type] = fetch_stored_credential_type(options[:stored_credential])
+        end
+
         post[:card][:holder_name] = card.name
         post[:card][:expiration_month] = card.month
         post[:card][:expiration_year] = card.year
@@ -191,6 +196,14 @@ module ActiveMerchant #:nodoc:
         post[:card][:save] = options[:save] if options[:save]
       end
 
+      def fetch_stored_credential_type(stored_credential)
+        if stored_credential[:reason_type] == 'unscheduled'
+          stored_credential[:initiator] == 'merchant' ? 'UNSCHEDULED_CARD_ON_FILE' : 'CARD_ON_FILE'
+        else
+          'SUBSCRIPTION'
+        end
+      end
+
       def parse(body)
         JSON.parse(body)
       end
@@ -218,6 +231,7 @@ module ActiveMerchant #:nodoc:
           message_from(action, response),
           response,
           authorization: authorization_from(response),
+          network_transaction_id: network_transaction_id_from(response),
           avs_result: AVSResult.new(code: response['some_avs_response_key']),
           cvv_result: CVVResult.new(response['some_cvv_response_key']),
           test: test?,
@@ -231,7 +245,11 @@ module ActiveMerchant #:nodoc:
       def success_from(action, response)
         return false unless response['status_code']
 
-        %w[100 200 400 600 700].include? response['status_code'].to_s
+        if action == 'void'
+          response['status_code'].to_s == '400' && response['status'] == 'CANCELLED'
+        else
+          %w[100 200 400 600 700].include? response['status_code'].to_s
+        end
       end
 
       def message_from(action, response)
@@ -242,6 +260,10 @@ module ActiveMerchant #:nodoc:
         response['id']
       end
 
+      def network_transaction_id_from(response)
+        response.dig('card', 'network_tx_reference')
+      end
+
       def error_code_from(action, response)
         return if success_from(action, response)
 
@@ -250,7 +272,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def url(action, parameters, options = {})
-        "#{(test? ? test_url : live_url)}/#{endpoint(action, parameters, options)}/"
+        "#{test? ? test_url : live_url}/#{endpoint(action, parameters, options)}/"
       end
 
       def endpoint(action, parameters, options)
@@ -283,6 +305,7 @@ module ActiveMerchant #:nodoc:
           'Authorization' => signature(post, timestamp)
         }
         headers['X-Idempotency-Key'] = options[:idempotency_key] if options[:idempotency_key]
+        headers['X-Dlocal-Payment-Source'] = application_id if application_id
         headers
       end
 

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

@@ -235,23 +235,23 @@ module ActiveMerchant
             # a predefined one
             xml.tag! :ExtendedPolicy do
               xml.tag! :cv2_policy,
-                notprovided: POLICY_REJECT,
-                notchecked: POLICY_REJECT,
-                matched: POLICY_ACCEPT,
-                notmatched: POLICY_REJECT,
-                partialmatch: POLICY_REJECT
+                       notprovided: POLICY_REJECT,
+                       notchecked: POLICY_REJECT,
+                       matched: POLICY_ACCEPT,
+                       notmatched: POLICY_REJECT,
+                       partialmatch: POLICY_REJECT
               xml.tag! :postcode_policy,
-                notprovided: POLICY_ACCEPT,
-                notchecked: POLICY_ACCEPT,
-                matched: POLICY_ACCEPT,
-                notmatched: POLICY_REJECT,
-                partialmatch: POLICY_ACCEPT
+                       notprovided: POLICY_ACCEPT,
+                       notchecked: POLICY_ACCEPT,
+                       matched: POLICY_ACCEPT,
+                       notmatched: POLICY_REJECT,
+                       partialmatch: POLICY_ACCEPT
               xml.tag! :address_policy,
-                notprovided: POLICY_ACCEPT,
-                notchecked: POLICY_ACCEPT,
-                matched: POLICY_ACCEPT,
-                notmatched: POLICY_REJECT,
-                partialmatch: POLICY_ACCEPT
+                       notprovided: POLICY_ACCEPT,
+                       notchecked: POLICY_ACCEPT,
+                       matched: POLICY_ACCEPT,
+                       notmatched: POLICY_REJECT,
+                       partialmatch: POLICY_ACCEPT
             end
           end
         end
@@ -260,9 +260,13 @@ module ActiveMerchant
       def commit(request)
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request))
 
-        Response.new(response[:status] == '1', response[:reason], response,
+        Response.new(
+          response[:status] == '1',
+          response[:reason],
+          response,
           test: test?,
-          authorization: "#{response[:datacash_reference]};#{response[:authcode]};#{response[:ca_reference]}")
+          authorization: "#{response[:datacash_reference]};#{response[:authcode]};#{response[:ca_reference]}"
+        )
       end
 
       def format_date(month, year)
@@ -295,7 +299,7 @@ module ActiveMerchant
 
       def parse_authorization_string(authorization)
         reference, auth_code, ca_reference = authorization.to_s.split(';')
-        { reference: reference, auth_code: auth_code, ca_reference: ca_reference }
+        { reference:, auth_code:, ca_reference: }
       end
     end
   end