activemerchant 1.130.0 → 1.137.0

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

@@ -85,11 +85,10 @@ module ActiveMerchant
       AVS_REASON_CODES = %w(27 45)
 
       TRACKS = {
-        1 => /^%(?<format_code>.)(?<pan>[\d]{1,19}+)\^(?<name>.{2,26})\^(?<expiration>[\d]{0,4}|\^)(?<service_code>[\d]{0,3}|\^)(?<discretionary_data>.*)\?\Z/,
-        2 => /\A;(?<pan>[\d]{1,19}+)=(?<expiration>[\d]{0,4}|=)(?<service_code>[\d]{0,3}|=)(?<discretionary_data>.*)\?\Z/
+        1 => /^%(?<format_code>.)(?<pan>\d{1,19}+)\^(?<name>.{2,26})\^(?<expiration>\d{0,4}|\^)(?<service_code>\d{0,3}|\^)(?<discretionary_data>.*)\?\Z/,
+        2 => /\A;(?<pan>\d{1,19}+)=(?<expiration>\d{0,4}|=)(?<service_code>\d{0,3}|=)(?<discretionary_data>.*)\?\Z/
       }.freeze
 
-      APPLE_PAY_DATA_DESCRIPTOR = 'COMMON.APPLE.INAPP.PAYMENT'
       PAYMENT_METHOD_NOT_SUPPORTED_ERROR = '155'
       INELIGIBLE_FOR_ISSUING_CREDIT_ERROR = '54'
 
@@ -165,7 +164,7 @@ module ActiveMerchant
             xml.transactionType('refundTransaction')
             xml.amount(amount(amount))
 
-            add_payment_source(xml, payment, options, :credit)
+            add_payment_method(xml, payment, options, :credit)
             xml.refTransId(transaction_id_from(options[:transaction_id])) if options[:transaction_id]
             add_invoice(xml, 'refundTransaction', options)
             add_customer_data(xml, payment, options)
@@ -262,7 +261,7 @@ module ActiveMerchant
         xml.transactionRequest do
           xml.transactionType(transaction_type)
           xml.amount(amount(amount))
-          add_payment_source(xml, payment, options)
+          add_payment_method(xml, payment, options)
           add_invoice(xml, transaction_type, options)
           add_tax_fields(xml, options)
           add_duty_fields(xml, options)
@@ -273,6 +272,7 @@ module ActiveMerchant
           add_market_type_device_type(xml, payment, options)
           add_settings(xml, payment, options)
           add_user_fields(xml, amount, options)
+          add_surcharge_fields(xml, options)
           add_ship_from_address(xml, options)
           add_processing_options(xml, options)
           add_subsequent_auth_information(xml, options)
@@ -287,8 +287,9 @@ module ActiveMerchant
             add_tax_fields(xml, options)
             add_shipping_fields(xml, options)
             add_duty_fields(xml, options)
-            add_payment_source(xml, payment, options)
+            add_payment_method(xml, payment, options)
             add_invoice(xml, transaction_type, options)
+            add_surcharge_fields(xml, options)
             add_tax_exempt_status(xml, options)
           end
         end
@@ -362,7 +363,7 @@ module ActiveMerchant
                   xml.accountType(options[:account_type])
                   xml.routingNumber(options[:routing_number])
                   xml.accountNumber(options[:account_number])
-                  xml.nameOnAccount("#{options[:first_name]} #{options[:last_name]}")
+                  xml.nameOnAccount(truncate("#{options[:first_name]} #{options[:last_name]}", 22))
                 end
               else
                 xml.creditCard do
@@ -407,20 +408,27 @@ module ActiveMerchant
         end
       end
 
-      def add_payment_source(xml, source, options, action = nil)
-        return unless source
+      def add_payment_method(xml, payment_method, options, action = nil)
+        return unless payment_method
 
-        if source.is_a?(String)
-          add_token_payment_method(xml, source, options)
-        elsif card_brand(source) == 'check'
-          add_check(xml, source)
-        elsif card_brand(source) == 'apple_pay'
-          add_apple_pay_payment_token(xml, source)
+        case payment_method
+        when String
+          add_token_payment_method(xml, payment_method, options)
+        when Check
+          add_check(xml, payment_method)
         else
-          add_credit_card(xml, source, action)
+          if network_token?(payment_method, options, action)
+            add_network_token(xml, payment_method)
+          else
+            add_credit_card(xml, payment_method, action)
+          end
         end
       end
 
+      def network_token?(payment_method, options, action)
+        payment_method.instance_of?(NetworkTokenizationCreditCard) && action != :credit
+      end
+
       def camel_case_lower(key)
         String(key).split('_').inject([]) { |buffer, e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
       end
@@ -499,7 +507,6 @@ module ActiveMerchant
               xml.cardNumber(truncate(credit_card.number, 16))
               xml.expirationDate(format(credit_card.month, :two_digits) + '/' + format(credit_card.year, :four_digits))
               xml.cardCode(credit_card.verification_value) if credit_card.valid_card_verification_value?(credit_card.verification_value, credit_card.brand)
-              xml.cryptogram(credit_card.payment_cryptogram) if credit_card.is_a?(NetworkTokenizationCreditCard) && action != :credit
             end
           end
         end
@@ -526,17 +533,20 @@ module ActiveMerchant
         xml.customerPaymentProfileId(customer_payment_profile_id)
       end
 
-      def add_apple_pay_payment_token(xml, apple_pay_payment_token)
+      def add_network_token(xml, payment_method)
         xml.payment do
-          xml.opaqueData do
-            xml.dataDescriptor(APPLE_PAY_DATA_DESCRIPTOR)
-            xml.dataValue(Base64.strict_encode64(apple_pay_payment_token.payment_data.to_json))
+          xml.creditCard do
+            xml.cardNumber(truncate(payment_method.number, 16))
+            xml.expirationDate(format(payment_method.month, :two_digits) + '/' + format(payment_method.year, :four_digits))
+            xml.isPaymentToken(true)
+            xml.cryptogram(payment_method.payment_cryptogram)
           end
         end
       end
 
       def add_market_type_device_type(xml, payment, options)
-        return if payment.is_a?(String) || card_brand(payment) == 'check' || card_brand(payment) == 'apple_pay'
+        return unless payment.is_a?(CreditCard)
+        return if payment.is_a?(NetworkTokenizationCreditCard)
 
         if valid_track_data
           xml.retail do
@@ -701,6 +711,16 @@ module ActiveMerchant
         end
       end
 
+      def add_surcharge_fields(xml, options)
+        surcharge = options[:surcharge] if options[:surcharge]
+        if surcharge.is_a?(Hash)
+          xml.surcharge do
+            xml.amount(amount(surcharge[:amount].to_i)) if surcharge[:amount]
+            xml.description(surcharge[:description]) if surcharge[:description]
+          end
+        end
+      end
+
       def add_shipping_fields(xml, options)
         shipping = options[:shipping]
         if shipping.is_a?(Hash)
@@ -754,13 +774,7 @@ module ActiveMerchant
           xml.customerProfileId options[:customer_profile_id]
           xml.paymentProfile do
             add_billing_address(xml, credit_card, options)
-            xml.payment do
-              xml.creditCard do
-                xml.cardNumber(truncate(credit_card.number, 16))
-                xml.expirationDate(format(credit_card.year, :four_digits) + '-' + format(credit_card.month, :two_digits))
-                xml.cardCode(credit_card.verification_value) if credit_card.verification_value
-              end
-            end
+            add_credit_card(xml, credit_card, :cim_store_update)
           end
         end
       end
@@ -776,13 +790,7 @@ module ActiveMerchant
               xml.customerType('individual')
               add_billing_address(xml, credit_card, options)
               add_shipping_address(xml, options, 'shipToList')
-              xml.payment do
-                xml.creditCard do
-                  xml.cardNumber(truncate(credit_card.number, 16))
-                  xml.expirationDate(format(credit_card.year, :four_digits) + '-' + format(credit_card.month, :two_digits))
-                  xml.cardCode(credit_card.verification_value) if credit_card.verification_value
-                end
-              end
+              add_credit_card(xml, credit_card, :cim_store)
             end
           end
         end

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

@@ -208,9 +208,9 @@ module ActiveMerchant #:nodoc:
           # The amount to be billed to the customer
           # for each payment in the subscription
           xml.tag!('amount', amount(options[:amount])) if options[:amount]
-          if trial = options[:trial]
+          if trial = options[:trial] && (trial[:amount])
             # The amount to be charged for each payment during a trial period (conditional)
-            xml.tag!('trialAmount', amount(trial[:amount])) if trial[:amount]
+            xml.tag!('trialAmount', amount(trial[:amount]))
           end
           # Contains either the customer’s credit card
           # or bank account payment information
@@ -260,9 +260,9 @@ module ActiveMerchant #:nodoc:
           # Contains information about the interval of time between payments
           add_interval(xml, options)
           add_duration(xml, options)
-          if trial = options[:trial]
+          if trial = options[:trial] && (trial[:occurrences])
             # Number of billing occurrences or payments in the trial period (optional)
-            xml.tag!('trialOccurrences', trial[:occurrences]) if trial[:occurrences]
+            xml.tag!('trialOccurrences', trial[:occurrences])
           end
         end
       end
@@ -393,9 +393,13 @@ module ActiveMerchant #:nodoc:
         test_mode = test? || message =~ /Test Mode/
         success = response[:result_code] == 'Ok'
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test_mode,
-          authorization: response[:subscription_id])
+          authorization: response[:subscription_id]
+        )
       end
 
       def recurring_parse(action, xml)

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

@@ -695,9 +695,7 @@ module ActiveMerchant #:nodoc:
               add_order(xml, transaction[:order]) if transaction[:order].present?
 
             end
-            if %i[auth_capture auth_only capture_only].include?(transaction[:type])
-              xml.tag!('recurringBilling', transaction[:recurring_billing]) if transaction.has_key?(:recurring_billing)
-            end
+            xml.tag!('recurringBilling', transaction[:recurring_billing]) if %i[auth_capture auth_only capture_only].include?(transaction[:type]) && transaction.has_key?(:recurring_billing)
             tag_unless_blank(xml, 'cardCode', transaction[:card_code]) unless %i[void refund prior_auth_capture].include?(transaction[:type])
           end
         end

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

@@ -71,9 +71,13 @@ module ActiveMerchant #:nodoc:
         message = "#{response[:reason]} - #{response[:return]}"
         authorization = response[:unique_id]
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           authorization: authorization,
-          test: (response[:mode] != 'LIVE'))
+          test: (response[:mode] != 'LIVE')
+        )
       end
 
       def parse(body)

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

@@ -89,11 +89,13 @@ module ActiveMerchant #:nodoc:
           response = json_error(raw_response)
         end
 
-        Response.new(success?(response),
+        Response.new(
+          success?(response),
           response['message'],
           response,
           test: test?,
-          authorization: response['code_auth'])
+          authorization: response['code_auth']
+        )
       end
 
       def success?(response)

data/lib/active_merchant/billing/gateways/beanstream/beanstream_core.rb

@@ -228,7 +228,7 @@ module ActiveMerchant #:nodoc:
 
         if billing_address = options[:billing_address] || options[:address]
           post[:ordName]          = billing_address[:name]
-          post[:ordPhoneNumber]   = billing_address[:phone]
+          post[:ordPhoneNumber]   = billing_address[:phone] || billing_address[:phone_number]
           post[:ordAddress1]      = billing_address[:address1]
           post[:ordAddress2]      = billing_address[:address2]
           post[:ordCity]          = billing_address[:city]
@@ -413,11 +413,15 @@ module ActiveMerchant #:nodoc:
       def post(data, use_profile_api = nil)
         response = parse(ssl_post((use_profile_api ? SECURE_PROFILE_URL : self.live_url), data))
         response[:customer_vault_id] = response[:customerCode] if response[:customerCode]
-        build_response(success?(response), message_from(response), response,
+        build_response(
+          success?(response),
+          message_from(response),
+          response,
           test: test? || response[:authCode] == 'TEST',
           authorization: authorization_from(response),
           cvv_result: CVD_CODES[response[:cvdId]],
-          avs_result: { code: AVS_CODES.include?(response[:avsId]) ? AVS_CODES[response[:avsId]] : response[:avsId] })
+          avs_result: { code: AVS_CODES.include?(response[:avsId]) ? AVS_CODES[response[:avsId]] : response[:avsId] }
+        )
       end
 
       def recurring_post(data)

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

@@ -344,14 +344,18 @@ module ActiveMerchant #:nodoc:
         success = parsed[:status] != 'error'
         message = parsed[:status]
 
-        Response.new(success, message, parsed,
+        Response.new(
+          success,
+          message,
+          parsed,
           test: test?,
-          authorization: parsed[:rebill_id])
+          authorization: parsed[:rebill_id]
+        )
       end
 
       def parse(body)
         # The bp20api has max one value per form field.
-        response_fields = Hash[CGI::parse(body).map { |k, v| [k.upcase, v.first] }]
+        response_fields = CGI::parse(body).map { |k, v| [k.upcase, v.first] }.to_h
 
         return parse_recurring(response_fields) if response_fields.include? 'REBILL_ID'
 
@@ -364,11 +368,15 @@ module ActiveMerchant #:nodoc:
         # normalize message
         message = message_from(parsed)
         success = parsed[:response_code] == '1'
-        Response.new(success, message, parsed,
+        Response.new(
+          success,
+          message,
+          parsed,
           test: test?,
           authorization: (parsed[:rebid] && parsed[:rebid] != '' ? parsed[:rebid] : parsed[:transaction_id]),
           avs_result: { code: parsed[:avs_result_code] },
-          cvv_result: parsed[:card_code])
+          cvv_result: parsed[:card_code]
+        )
       end
 
       def message_from(parsed)

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

@@ -446,10 +446,10 @@ module ActiveMerchant
       end
 
       def parse_element(parsed, node)
-        if !node.elements.empty?
-          node.elements.each { |e| parse_element(parsed, e) }
-        else
+        if node.elements.empty?
           parsed[node.name.downcase] = node.text
+        else
+          node.elements.each { |e| parse_element(parsed, e) }
         end
       end
 
@@ -459,8 +459,8 @@ module ActiveMerchant
         e.response
       end
 
-      def commit(action, options, verb = :post, payment_method_details = PaymentMethodDetails.new())
-        request = build_xml_request(action, payment_method_details) { |doc| yield(doc) }
+      def commit(action, options, verb = :post, payment_method_details = PaymentMethodDetails.new(), &block)
+        request = build_xml_request(action, payment_method_details, &block)
         response = api_request(action, request, verb, payment_method_details, options)
         parsed = parse(response)
 

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

@@ -172,7 +172,7 @@ module ActiveMerchant #:nodoc:
           success,
           message_from(success, pairs),
           pairs,
-          authorization: authorization_from(pairs),
+          authorization: authorization_from(pairs, options),
           test: test?
         )
       end
@@ -185,12 +185,12 @@ module ActiveMerchant #:nodoc:
         if succeeded
           'Succeeded'
         else
-          response[:message] || "Error with ActionCode=#{response[:actioncode]}"
+          response[:message] || response[:status_errormessage] || "Error with ActionCode=#{response[:actioncode]}"
         end
       end
 
-      def authorization_from(response)
-        [
+      def authorization_from(response, options)
+        authorization = [
           response[:dateandtime],
           response[:batch],
           response[:transaction],
@@ -200,6 +200,8 @@ module ActiveMerchant #:nodoc:
           response[:tramount],
           response[:trcurrency]
         ].join('|')
+
+        authorization == '|||||||' ? nil : authorization
       end
 
       def split_authorization(authorization)

data/lib/active_merchant/billing/gateways/braintree/token_nonce.rb

@@ -18,10 +18,10 @@ module ActiveMerchant #:nodoc:
         "https://payments#{'.sandbox' if sandbox}.braintree-api.com/graphql"
       end
 
-      def create_token_nonce_for_payment_method(payment_method)
+      def create_token_nonce_for_payment_method(payment_method, options = {})
         headers = {
           'Accept' => 'application/json',
-          'Authorization' => "Bearer #{client_token}",
+          'Authorization' => "Bearer #{client_token(options)['authorizationFingerprint']}",
           'Content-Type' => 'application/json',
           'Braintree-Version' => '2018-05-10'
         }
@@ -29,19 +29,19 @@ module ActiveMerchant #:nodoc:
         json_response = JSON.parse(resp)
 
         message = json_response['errors'].map { |err| err['message'] }.join("\n") if json_response['errors'].present?
-        token = json_response.dig('data', 'tokenizeUsBankAccount', 'paymentMethod', 'id')
+        token = token_from(payment_method, json_response)
 
         return token, message
       end
 
-      def client_token
-        base64_token = @braintree_gateway.client_token.generate
-        JSON.parse(Base64.decode64(base64_token))['authorizationFingerprint']
+      def client_token(options = {})
+        base64_token = @braintree_gateway.client_token.generate({ merchant_account_id: options[:merchant_account_id] || @options[:merchant_account_id] }.compact)
+        JSON.parse(Base64.decode64(base64_token))
       end
 
       private
 
-      def graphql_query
+      def graphql_bank_query
         <<-GRAPHQL
         mutation TokenizeUsBankAccount($input: TokenizeUsBankAccountInput!) {
           tokenizeUsBankAccount(input: $input) {
@@ -58,6 +58,23 @@ module ActiveMerchant #:nodoc:
         GRAPHQL
       end
 
+      def graphql_credit_query
+        <<-GRAPHQL
+        mutation TokenizeCreditCard($input: TokenizeCreditCardInput!) {
+          tokenizeCreditCard(input: $input) {
+            paymentMethod {
+              id
+              details {
+                ... on CreditCardDetails {
+                  last4
+                }
+              }
+            }
+          }
+        }
+        GRAPHQL
+      end
+
       def billing_address_from_options
         return nil if options[:billing_address].blank?
 
@@ -72,7 +89,42 @@ module ActiveMerchant #:nodoc:
         }.compact
       end
 
+      def build_nonce_credit_card_request(payment_method)
+        billing_address = billing_address_from_options
+        key_replacements = { city: :locality, state: :region, zipCode: :postalCode }
+        billing_address&.transform_keys! { |key| key_replacements[key] || key }
+        {
+          creditCard: {
+            number: payment_method.number,
+            expirationYear: payment_method.year.to_s,
+            expirationMonth: payment_method.month.to_s.rjust(2, '0'),
+            cvv: payment_method.verification_value,
+            cardholderName: payment_method.name,
+            billingAddress: billing_address
+          }
+        }
+      end
+
       def build_nonce_request(payment_method)
+        input = payment_method.is_a?(Check) ? build_nonce_bank_request(payment_method) : build_nonce_credit_card_request(payment_method)
+        graphql_query = payment_method.is_a?(Check) ? graphql_bank_query : graphql_credit_query
+
+        {
+          clientSdkMetadata: {
+            platform: 'web',
+            source: 'client',
+            integration: 'custom',
+            sessionId: SecureRandom.uuid,
+            version: '3.83.0'
+          },
+           query: graphql_query,
+           variables: {
+             input: input
+           }
+        }.to_json
+      end
+
+      def build_nonce_bank_request(payment_method)
         input = {
           usBankAccount: {
             achMandate: options[:ach_mandate],
@@ -94,19 +146,12 @@ module ActiveMerchant #:nodoc:
           }
         end
 
-        {
-          clientSdkMetadata: {
-            platform: 'web',
-            source: 'client',
-            integration: 'custom',
-            sessionId: SecureRandom.uuid,
-            version: '3.83.0'
-          },
-          query: graphql_query,
-          variables: {
-            input: input
-          }
-        }.to_json
+        input
+      end
+
+      def token_from(payment_method, response)
+        tokenized_field = payment_method.is_a?(Check) ? 'tokenizeUsBankAccount' : 'tokenizeCreditCard'
+        response.dig('data', tokenized_field, 'paymentMethod', 'id')
       end
     end
   end