activemerchant 1.133.0 → 1.138.0

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

@@ -10,8 +10,8 @@ end
 
 raise 'Need braintree gem >= 2.0.0.' unless Braintree::Version::Major >= 2 && Braintree::Version::Minor >= 0
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # For more information on the Braintree Gateway please visit their
     # {Developer Portal}[https://www.braintreepayments.com/developers]
     #
@@ -43,6 +43,9 @@ module ActiveMerchant #:nodoc:
 
       self.display_name = 'Braintree (Blue Platform)'
 
+      version Braintree::Configuration::API_VERSION
+      version Braintree::Version::String, :gem
+
       ERROR_CODES = {
         cannot_refund_if_unsettled: 91506
       }
@@ -75,9 +78,12 @@ module ActiveMerchant #:nodoc:
         @braintree_gateway = Braintree::Gateway.new(@configuration)
       end
 
-      def setup_purchase
+      def setup_purchase(options = {})
+        post = {}
+        add_merchant_account_id(post, options)
+
         commit do
-          Response.new(true, 'Client token created', { client_token: @braintree_gateway.client_token.generate })
+          Response.new(true, 'Client token created', { client_token: @braintree_gateway.client_token.generate(post) })
         end
       end
 
@@ -106,6 +112,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, credit_card_or_vault_id, options = {})
+        return Response.new(false, DIRECT_BANK_ERROR) if credit_card_or_vault_id.is_a? Check
+
         create_transaction(:credit, money, credit_card_or_vault_id, options)
       end
 
@@ -139,16 +147,25 @@ module ActiveMerchant #:nodoc:
           exp_month = creditcard.month.to_s
           exp_year = creditcard.year.to_s
           expiration = "#{exp_month}/#{exp_year}"
+          zip = options[:billing_address].try(:[], :zip)
+          address1 = options[:billing_address].try(:[], :address1)
           payload = {
             credit_card: {
               number: creditcard.number,
               expiration_date: expiration,
-              cvv: creditcard.verification_value,
-              billing_address: {
-                postal_code: options[:billing_address][:zip]
-              }
+              cvv: creditcard.verification_value
             }
           }
+          if zip || address1
+            payload[:credit_card][:billing_address] = {}
+            payload[:credit_card][:billing_address][:postal_code] = zip if zip
+            payload[:credit_card][:billing_address][:street_address] = address1 if address1
+          end
+
+          if merchant_account_id = (options[:merchant_account_id] || @merchant_account_id)
+            payload[:options] = { merchant_account_id: }
+          end
+
           commit do
             result = @braintree_gateway.verification.create(payload)
             response = Response.new(result.success?, message_from_transaction_result(result), response_options(result))
@@ -193,15 +210,20 @@ module ActiveMerchant #:nodoc:
             }
           }, options)[:credit_card]
 
-          result = @braintree_gateway.customer.update(vault_id,
+          result = @braintree_gateway.customer.update(
+            vault_id,
             first_name: creditcard.first_name,
             last_name: creditcard.last_name,
             email: scrub_email(options[:email]),
             phone: phone_from(options),
-            credit_card: credit_card_params)
-          Response.new(result.success?, message_from_result(result),
+            credit_card: credit_card_params
+          )
+          Response.new(
+            result.success?,
+            message_from_result(result),
             braintree_customer: (customer_hash(@braintree_gateway.customer.find(vault_id), :include_credit_cards) if result.success?),
-            customer_vault_id: (result.customer.id if result.success?))
+            customer_vault_id: (result.customer.id if result.success?)
+          )
         end
       end
 
@@ -271,13 +293,16 @@ module ActiveMerchant #:nodoc:
             device_data: options[:device_data]
           }.merge credit_card_params
           result = @braintree_gateway.customer.create(merge_credit_card_options(parameters, options))
-          Response.new(result.success?, message_from_result(result),
+          Response.new(
+            result.success?,
+            message_from_result(result),
             {
               braintree_customer: (customer_hash(result.customer, :include_credit_cards) if result.success?),
               customer_vault_id: (result.customer.id if result.success?),
               credit_card_token: (result.customer.credit_cards[0].token if result.success?)
             },
-            authorization: (result.customer.id if result.success?))
+            authorization: (result.customer.id if result.success?)
+          )
         end
       end
 
@@ -371,8 +396,8 @@ module ActiveMerchant #:nodoc:
 
       def commit(&block)
         yield
-      rescue Braintree::BraintreeError => ex
-        Response.new(false, ex.class.to_s)
+      rescue Braintree::BraintreeError => e
+        Response.new(false, e.class.to_s)
       end
 
       def message_from_result(result)
@@ -422,6 +447,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def avs_code_from(transaction)
+        return unless transaction
+
         transaction.avs_error_response_code ||
           avs_mapping["street: #{transaction.avs_street_address_response_code}, zip: #{transaction.avs_postal_code_response_code}"]
       end
@@ -486,18 +513,70 @@ module ActiveMerchant #:nodoc:
         result.transaction&.additional_processor_response
       end
 
+      def payment_instrument_type(result)
+        result&.payment_instrument_type
+      end
+
+      def credit_card_details(result)
+        if result
+          {
+            'masked_number'       => result.credit_card_details&.masked_number,
+            'bin'                 => result.credit_card_details&.bin,
+            'last_4'              => result.credit_card_details&.last_4,
+            'card_type'           => result.credit_card_details&.card_type,
+            'token'               => result.credit_card_details&.token,
+            'debit'               => result.credit_card_details&.debit,
+            'prepaid'             => result.credit_card_details&.prepaid,
+            'issuing_bank'        => result.credit_card_details&.issuing_bank,
+            'country_of_issuance' => result.credit_card_details&.country_of_issuance
+          }
+        end
+      end
+
+      def network_token_details(result)
+        if result
+          {
+            'debit'               => result.network_token_details&.debit,
+            'prepaid'             => result.network_token_details&.prepaid,
+            'issuing_bank'        => result.network_token_details&.issuing_bank
+          }
+        end
+      end
+
+      def google_pay_details(result)
+        if result
+          {
+            'debit'               => result.google_pay_details&.debit,
+            'prepaid'             => result.google_pay_details&.prepaid
+          }
+        end
+      end
+
+      def apple_pay_details(result)
+        if result
+          {
+            'debit'               => result.apple_pay_details&.debit,
+            'prepaid'             => result.apple_pay_details&.prepaid,
+            'issuing_bank'        => result.apple_pay_details&.issuing_bank
+          }
+        end
+      end
+
       def create_transaction(transaction_type, money, credit_card_or_vault_id, options)
         transaction_params = create_transaction_parameters(money, credit_card_or_vault_id, options)
         commit do
           result = @braintree_gateway.transaction.send(transaction_type, transaction_params)
-          make_default_payment_method_token(result) if options.dig(:paypal, :paypal_flow_type) == 'checkout_with_vault' && result.success?
+          make_default_payment_method_token(result, options)
           response = Response.new(result.success?, message_from_transaction_result(result), response_params(result), response_options(result))
           response.cvv_result['message'] = ''
           response
         end
       end
 
-      def make_default_payment_method_token(result)
+      def make_default_payment_method_token(result, options)
+        return if options[:prevent_default_payment_method]
+        return unless options.dig(:paypal, :paypal_flow_type) == 'checkout_with_vault' && result.success?
+
         @braintree_gateway.customer.update(
           result.transaction.customer_details.id,
           default_payment_method_token: result.transaction.paypal_details.implicitly_vaulted_payment_method_token
@@ -545,7 +624,15 @@ module ActiveMerchant #:nodoc:
       def transaction_hash(result)
         unless result.success?
           return { 'processor_response_code' => response_code_from_result(result),
-                   'additional_processor_response' => additional_processor_response_from_result(result) }
+                   'additional_processor_response' => additional_processor_response_from_result(result),
+                   'payment_instrument_type' => payment_instrument_type(result.transaction),
+                   'credit_card_details' => credit_card_details(result.transaction),
+                   'network_token_details' => network_token_details(result.transaction),
+                   'google_pay_details' => google_pay_details(result.transaction),
+                   'apple_pay_details' => apple_pay_details(result.transaction),
+                   'avs_response_code' => avs_code_from(result.transaction),
+                   'cvv_response_code' => result.transaction&.cvv_response_code,
+                   'gateway_message' => result.message }
         end
 
         transaction = result.transaction
@@ -561,6 +648,14 @@ module ActiveMerchant #:nodoc:
           vault_customer = nil
         end
 
+        credit_card_details = credit_card_details(transaction)
+
+        network_token_details = network_token_details(transaction)
+
+        google_pay_details = google_pay_details(transaction)
+
+        apple_pay_details = apple_pay_details(transaction)
+
         customer_details = {
           'id' => transaction.customer_details.id,
           'email' => transaction.customer_details.email,
@@ -586,12 +681,11 @@ module ActiveMerchant #:nodoc:
           'postal_code'      => transaction.shipping_details.postal_code,
           'country_name'     => transaction.shipping_details.country_name
         }
-        credit_card_details = {
-          'masked_number'       => transaction.credit_card_details.masked_number,
-          'bin'                 => transaction.credit_card_details.bin,
-          'last_4'              => transaction.credit_card_details.last_4,
-          'card_type'           => transaction.credit_card_details.card_type,
-          'token'               => transaction.credit_card_details.token
+
+        paypal_details = {
+          'payer_id'            => transaction.paypal_details.payer_id,
+          'payer_email'         => transaction.paypal_details.payer_email,
+          'paypal_payment_token' => transaction.paypal_details.implicitly_vaulted_payment_method_token || transaction.paypal_details.token
         }
 
         if transaction.risk_data
@@ -605,11 +699,23 @@ module ActiveMerchant #:nodoc:
           risk_data = nil
         end
 
+        if transaction.payment_receipt
+          payment_receipt = {
+            'global_id' => transaction.payment_receipt.global_id
+          }
+        else
+          payment_receipt = nil
+        end
+
         {
           'order_id'                     => transaction.order_id,
           'amount'                       => transaction.amount.to_s,
           'status'                       => transaction.status,
           'credit_card_details'          => credit_card_details,
+          'network_token_details'        => network_token_details,
+          'apple_pay_details'            => apple_pay_details,
+          'google_pay_details'           => google_pay_details,
+          'paypal_details'               => paypal_details,
           'customer_details'             => customer_details,
           'billing_details'              => billing_details,
           'shipping_details'             => shipping_details,
@@ -619,7 +725,9 @@ module ActiveMerchant #:nodoc:
           'network_transaction_id'       => transaction.network_transaction_id || nil,
           'processor_response_code'      => response_code_from_result(result),
           'processor_authorization_code' => transaction.processor_authorization_code,
-          'recurring'                    => transaction.recurring
+          'recurring'                    => transaction.recurring,
+          'payment_receipt'              => payment_receipt,
+          'payment_instrument_type'      => payment_instrument_type(transaction)
         }
       end
 
@@ -665,6 +773,8 @@ module ActiveMerchant #:nodoc:
 
         add_3ds_info(parameters, options[:three_d_secure])
 
+        parameters[:sca_exemption] = options[:three_ds_exemption_type] if options[:three_ds_exemption_type]
+
         if options[:payment_method_nonce].is_a?(String)
           parameters.delete(:customer)
           parameters[:payment_method_nonce] = options[:payment_method_nonce]
@@ -708,7 +818,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_channel(parameters, options)
-        channel = @options[:channel] || application_id
+        channel = options[:override_application_id] || @options[:channel] || application_id
         parameters[:channel] = channel if channel
       end
 
@@ -803,78 +913,135 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_stored_credential_data(parameters, credit_card_or_vault_id, options)
+        # Braintree has informed us that the stored_credential mapping may be incorrect
+        # In order to prevent possible breaking changes we will only apply the new logic if
+        # specifically requested. This will be the default behavior in a future release.
         return unless (stored_credential = options[:stored_credential])
 
-        parameters[:external_vault] = {}
-        if stored_credential[:initial_transaction]
-          parameters[:external_vault][:status] = 'will_vault'
-        else
-          parameters[:external_vault][:status] = 'vaulted'
-          parameters[:external_vault][:previous_network_transaction_id] = stored_credential[:network_transaction_id]
-        end
-        if stored_credential[:initiator] == 'merchant'
-          if stored_credential[:reason_type] == 'installment'
-            parameters[:transaction_source] = 'recurring'
+        add_external_vault(parameters, options)
+        stored_credentials(parameters, stored_credential)
+      end
+
+      def stored_credentials(parameters, stored_credential)
+        case stored_credential[:reason_type]
+        when 'recurring', 'installment'
+          if stored_credential[:initial_transaction]
+            parameters[:transaction_source] = "#{stored_credential[:reason_type]}_first"
           else
             parameters[:transaction_source] = stored_credential[:reason_type]
           end
-        elsif %w(recurring_first moto).include?(stored_credential[:reason_type])
+        when 'recurring_first', 'moto'
           parameters[:transaction_source] = stored_credential[:reason_type]
+        when 'unscheduled'
+          parameters[:transaction_source] = stored_credential[:initiator] == 'merchant' ? stored_credential[:reason_type] : ''
         else
           parameters[:transaction_source] = ''
         end
       end
 
+      def add_external_vault(parameters, options = {})
+        stored_credential = options[:stored_credential]
+        parameters[:external_vault] = {}
+        if stored_credential[:initial_transaction]
+          parameters[:external_vault][:status] = 'will_vault'
+        else
+          parameters[:external_vault][:status] = 'vaulted'
+          parameters[:external_vault][:previous_network_transaction_id] = options[:network_transaction_id] || stored_credential[:network_transaction_id]
+        end
+      end
+
       def add_payment_method(parameters, credit_card_or_vault_id, options)
         if credit_card_or_vault_id.is_a?(String) || credit_card_or_vault_id.is_a?(Integer)
-          if options[:payment_method_token]
-            parameters[:payment_method_token] = credit_card_or_vault_id
-            options.delete(:billing_address)
-          elsif options[:payment_method_nonce]
-            parameters[:payment_method_nonce] = credit_card_or_vault_id
-          else
-            parameters[:customer_id] = credit_card_or_vault_id
-          end
+          add_third_party_token(parameters, credit_card_or_vault_id, options)
         else
           parameters[:customer].merge!(
             first_name: credit_card_or_vault_id.first_name,
             last_name: credit_card_or_vault_id.last_name
           )
           if credit_card_or_vault_id.is_a?(NetworkTokenizationCreditCard)
-            if credit_card_or_vault_id.source == :apple_pay
-              parameters[:apple_pay_card] = {
-                number: credit_card_or_vault_id.number,
-                expiration_month: credit_card_or_vault_id.month.to_s.rjust(2, '0'),
-                expiration_year: credit_card_or_vault_id.year.to_s,
-                cardholder_name: credit_card_or_vault_id.name,
-                cryptogram: credit_card_or_vault_id.payment_cryptogram,
-                eci_indicator: credit_card_or_vault_id.eci
-              }
-            elsif credit_card_or_vault_id.source == :android_pay || credit_card_or_vault_id.source == :google_pay
-              Braintree::Version::Major < 3 ? pay_card = :android_pay_card : pay_card = :google_pay_card
-              parameters[pay_card] = {
-                number: credit_card_or_vault_id.number,
-                cryptogram: credit_card_or_vault_id.payment_cryptogram,
-                expiration_month: credit_card_or_vault_id.month.to_s.rjust(2, '0'),
-                expiration_year: credit_card_or_vault_id.year.to_s,
-                google_transaction_id: credit_card_or_vault_id.transaction_id,
-                source_card_type: credit_card_or_vault_id.brand,
-                source_card_last_four: credit_card_or_vault_id.last_digits,
-                eci_indicator: credit_card_or_vault_id.eci
-              }
+            case credit_card_or_vault_id.source
+            when :apple_pay
+              add_apple_pay(parameters, credit_card_or_vault_id, options)
+            when :google_pay
+              add_google_pay(parameters, credit_card_or_vault_id)
+            else
+              add_network_tokenization_card(parameters, credit_card_or_vault_id)
             end
           else
-            parameters[:credit_card] = {
-              number: credit_card_or_vault_id.number,
-              cvv: credit_card_or_vault_id.verification_value,
-              expiration_month: credit_card_or_vault_id.month.to_s.rjust(2, '0'),
-              expiration_year: credit_card_or_vault_id.year.to_s,
-              cardholder_name: credit_card_or_vault_id.name
-            }
+            add_credit_card(parameters, credit_card_or_vault_id)
           end
         end
       end
 
+      def add_third_party_token(parameters, payment_method, options)
+        if options[:payment_method_token]
+          parameters[:payment_method_token] = payment_method
+          options.delete(:billing_address)
+        elsif options[:payment_method_nonce]
+          parameters[:payment_method_nonce] = payment_method
+        else
+          parameters[:customer_id] = payment_method
+        end
+      end
+
+      def add_credit_card(parameters, payment_method)
+        parameters[:credit_card] = {
+          number: payment_method.number,
+          cvv: payment_method.verification_value,
+          expiration_month: payment_method.month.to_s.rjust(2, '0'),
+          expiration_year: payment_method.year.to_s,
+          cardholder_name: payment_method.name
+        }
+      end
+
+      def add_apple_pay(parameters, payment_method, options)
+        if options.dig(:stored_credential, :initiator) == 'merchant'
+          parameters[:apple_pay_card] = {
+            number: payment_method.number,
+            expiration_month: payment_method.month.to_s.rjust(2, '0'),
+            expiration_year: payment_method.year.to_s,
+            cardholder_name: payment_method.name,
+            cryptogram: 'cryptogram'
+          }
+        else
+          parameters[:apple_pay_card] = {
+            number: payment_method.number,
+            expiration_month: payment_method.month.to_s.rjust(2, '0'),
+            expiration_year: payment_method.year.to_s,
+            cardholder_name: payment_method.name,
+            cryptogram: payment_method.payment_cryptogram,
+            eci_indicator: payment_method.eci
+          }
+        end
+      end
+
+      def add_google_pay(parameters, payment_method)
+        Braintree::Version::Major < 3 ? pay_card = :android_pay_card : pay_card = :google_pay_card
+        parameters[pay_card] = {
+          number: payment_method.number,
+          cryptogram: payment_method.payment_cryptogram,
+          expiration_month: payment_method.month.to_s.rjust(2, '0'),
+          expiration_year: payment_method.year.to_s,
+          google_transaction_id: payment_method.transaction_id,
+          source_card_type: payment_method.brand,
+          source_card_last_four: payment_method.last_digits,
+          eci_indicator: payment_method.eci
+        }
+      end
+
+      def add_network_tokenization_card(parameters, payment_method)
+        parameters[:credit_card] = {
+          number: payment_method.number,
+          expiration_month: payment_method.month.to_s.rjust(2, '0'),
+          expiration_year: payment_method.year.to_s,
+          cardholder_name: payment_method.name,
+          network_tokenization_attributes: {
+            cryptogram: payment_method.payment_cryptogram,
+            ecommerce_indicator: payment_method.eci
+          }
+        }
+      end
+
       def bank_account_errors(payment_method, options)
         if payment_method.validate.present?
           payment_method.validate
@@ -886,7 +1053,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_bank_account_to_customer(payment_method, options)
-        bank_account_nonce, error_message = TokenNonce.new(@braintree_gateway, options).create_token_nonce_for_payment_method payment_method
+        bank_account_nonce, error_message = TokenNonce.new(@braintree_gateway, options).create_token_nonce_for_payment_method(payment_method, options)
         return Response.new(false, error_message) unless bank_account_nonce.present?
 
         result = @braintree_gateway.payment_method.create(
@@ -897,23 +1064,33 @@ module ActiveMerchant #:nodoc:
           }
         )
 
-        verified = result.success? && result.payment_method&.verified
-        message = message_from_result(result)
-        message = not_verified_reason(result.payment_method) unless verified
+        success = bank_account_verified?(result)
+        resp_body = if result.respond_to?(:payment_method)
+                      {
+                        customer_vault_id: options[:customer],
+                        bank_account_token: result.payment_method&.token,
+                        verified: success
+                      }
+                    end
+        Response.new(
+          success,
+          message_from_bank_account_result(success, result),
+          resp_body || {},
+          authorization: (result.payment_method&.token if result.respond_to?(:payment_method))
+        )
+      end
 
-        Response.new(verified, message,
-          {
-            customer_vault_id: options[:customer],
-            bank_account_token: result.payment_method&.token,
-            verified: verified
-          },
-          authorization: result.payment_method&.token)
+      def bank_account_verified?(result)
+        return false unless result.respond_to?(:payment_method)
+
+        result.success? && result.payment_method&.verified
       end
 
-      def not_verified_reason(bank_account)
-        return unless bank_account.verifications.present?
+      def message_from_bank_account_result(success, response)
+        return message_from_result(response) if !response.respond_to?(:payment_method) || success
+        return unless response.payment_method.verifications.present?
 
-        verification = bank_account.verifications.first
+        verification = response.payment_method.verifications.first
         "verification_status: [#{verification.status}], processor_response: [#{verification.processor_response_code}-#{verification.processor_response_text}]"
       end
 
@@ -944,7 +1121,7 @@ module ActiveMerchant #:nodoc:
         Response.new(
           result.success?,
           message_from_result(result),
-          { customer_vault_id: customer_id, 'exists': true }
+          { customer_vault_id: customer_id, exists: true }
         )
       end
     end

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

@@ -1,8 +1,8 @@
-require 'active_merchant/billing/gateways/smart_ps.rb'
+require 'active_merchant/billing/gateways/smart_ps'
 require 'active_merchant/billing/gateways/braintree/braintree_common'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class BraintreeOrangeGateway < SmartPs
       include BraintreeCommon
 

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class BridgePayGateway < Gateway
       self.display_name = 'BridgePay'
       self.homepage_url = 'http://www.bridgepaynetwork.com/'

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CamsGateway < Gateway
       self.live_url = 'https://secure.centralams.com/gw/api/transact.php'
 

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CardConnectGateway < Gateway
       self.test_url = 'https://fts-uat.cardconnect.com/cardconnect/rest/'
       self.live_url = 'https://fts.cardconnect.com/cardconnect/rest/'
@@ -146,9 +146,12 @@ module ActiveMerchant #:nodoc:
 
       def unstore(authorization, options = {})
         account_id, profile_id = authorization.split('|')
-        commit('profile', {},
+        commit(
+          'profile',
+          {},
           verb: :delete,
-          path: "/#{profile_id}/#{account_id}/#{@options[:merchant_id]}")
+          path: "/#{profile_id}/#{account_id}/#{@options[:merchant_id]}"
+        )
       end
 
       def supports_scrubbing?

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CardSaveGateway < IridiumGateway
       # CardSave lets you handle failovers on payments by providing 3 gateways in case one happens to be down
       # URLS = ['https://gw1.cardsaveonlinepayments.com:4430/','https://gw2.cardsaveonlinepayments.com:4430/','https://gw3.cardsaveonlinepayments.com:4430/']