activemerchant 1.130.0 → 1.137.0

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

@@ -75,9 +75,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 +109,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 +144,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: 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 +207,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 +290,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 +393,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 +444,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,6 +510,55 @@ 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
@@ -545,7 +618,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 +642,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 +675,10 @@ 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
         }
 
         if transaction.risk_data
@@ -605,11 +692,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 +718,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 +766,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]
@@ -803,78 +906,125 @@ 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)
+            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)
+        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
+
+      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 +1036,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(
@@ -901,13 +1051,16 @@ module ActiveMerchant #:nodoc:
         message = message_from_result(result)
         message = not_verified_reason(result.payment_method) unless verified
 
-        Response.new(verified, message,
+        Response.new(
+          verified,
+          message,
           {
             customer_vault_id: options[:customer],
             bank_account_token: result.payment_method&.token,
             verified: verified
           },
-          authorization: result.payment_method&.token)
+          authorization: result.payment_method&.token
+        )
       end
 
       def not_verified_reason(bank_account)
@@ -944,7 +1097,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,4 +1,4 @@
-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:

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

@@ -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_stream.rb

@@ -248,12 +248,10 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :orderRef, options[:description] || options[:order_id], required: true)
         add_pair(post, :statementNarrative1, options[:merchant_name]) if options[:merchant_name]
         add_pair(post, :statementNarrative2, options[:dynamic_descriptor]) if options[:dynamic_descriptor]
-        if credit_card_or_reference.respond_to?(:number)
-          if %w[american_express diners_club].include?(card_brand(credit_card_or_reference).to_s)
-            add_pair(post, :item1Quantity, 1)
-            add_pair(post, :item1Description, (options[:description] || options[:order_id]).slice(0, 15))
-            add_pair(post, :item1GrossValue, localized_amount(money, options[:currency] || currency(money)))
-          end
+        if credit_card_or_reference.respond_to?(:number) && %w[american_express diners_club].include?(card_brand(credit_card_or_reference).to_s)
+          add_pair(post, :item1Quantity, 1)
+          add_pair(post, :item1Description, (options[:description] || options[:order_id]).slice(0, 15))
+          add_pair(post, :item1GrossValue, localized_amount(money, options[:currency] || currency(money)))
         end
 
         add_pair(post, :type, options[:type] || '1')

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

@@ -150,7 +150,7 @@ module ActiveMerchant #:nodoc:
         match = body.match(/<cngateway>(.*)<\/cngateway>/)
         return nil unless match
 
-        Hash[CGI::parse(match[1]).map { |k, v| [k.to_sym, v.first] }]
+        CGI::parse(match[1]).map { |k, v| [k.to_sym, v.first] }.to_h
       end
 
       def handle_response(response)

data/lib/active_merchant/billing/gateways/cecabank/cecabank_common.rb

@@ -0,0 +1,36 @@
+module CecabankCommon
+  #### CECA's MAGIC NUMBERS
+  CECA_ENCRIPTION = 'SHA2'
+  CECA_CURRENCIES_DICTIONARY = { 'EUR' => 978, 'USD' => 840, 'GBP' => 826 }
+
+  def self.included(base)
+    base.supported_countries = ['ES']
+    base.supported_cardtypes = %i[visa master american_express]
+    base.homepage_url = 'http://www.ceca.es/es/'
+    base.display_name = 'Cecabank'
+    base.default_currency = 'EUR'
+    base.money_format = :cents
+  end
+
+  # Creates a new CecabankGateway
+  #
+  # The gateway requires four values for connection to be passed
+  # in the +options+ hash.
+  #
+  # ==== Options
+  #
+  # * <tt>:merchant_id</tt>  -- Cecabank's merchant_id (REQUIRED)
+  # * <tt>:acquirer_bin</tt> -- Cecabank's acquirer_bin (REQUIRED)
+  # * <tt>:terminal_id</tt>  -- Cecabank's terminal_id (REQUIRED)
+  # * <tt>:cypher_key</tt>   -- Cecabank's cypher key (REQUIRED)
+  # * <tt>:test</tt>         -- +true+ or +false+. If true, perform transactions against the test server.
+  #   Otherwise, perform transactions against the production server.
+  def initialize(options = {})
+    requires!(options, :merchant_id, :acquirer_bin, :terminal_id, :cypher_key)
+    super
+  end
+
+  def supports_scrubbing?
+    true
+  end
+end