activemerchant 1.125.0 → 1.129.0

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

@@ -1,4 +1,5 @@
 require 'active_merchant/billing/gateways/braintree/braintree_common'
+require 'active_merchant/billing/gateways/braintree/token_nonce'
 require 'active_support/core_ext/array/extract_options'
 
 begin
@@ -46,6 +47,8 @@ module ActiveMerchant #:nodoc:
         cannot_refund_if_unsettled: 91506
       }
 
+      DIRECT_BANK_ERROR = 'Direct bank account transactions are not supported. Bank accounts must be successfully stored before use.'.freeze
+
       def initialize(options = {})
         requires!(options, :merchant_id, :public_key, :private_key)
         @merchant_account_id = options[:merchant_account_id]
@@ -72,14 +75,29 @@ module ActiveMerchant #:nodoc:
         @braintree_gateway = Braintree::Gateway.new(@configuration)
       end
 
+      def setup_purchase
+        commit do
+          Response.new(true, 'Client token created', { client_token: @braintree_gateway.client_token.generate })
+        end
+      end
+
       def authorize(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(:sale, money, credit_card_or_vault_id, options)
       end
 
       def capture(money, authorization, options = {})
-        commit do
-          result = @braintree_gateway.transaction.submit_for_settlement(authorization, localized_amount(money, options[:currency] || default_currency).to_s)
-          response_from_result(result)
+        if options[:partial_capture] == true
+          commit do
+            result = @braintree_gateway.transaction.submit_for_partial_settlement(authorization, localized_amount(money, options[:currency] || default_currency).to_s)
+            response_from_result(result)
+          end
+        else
+          commit do
+            result = @braintree_gateway.transaction.submit_for_settlement(authorization, localized_amount(money, options[:currency] || default_currency).to_s)
+            response_from_result(result)
+          end
         end
       end
 
@@ -148,21 +166,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def store(creditcard, options = {})
-        if options[:customer].present?
-          MultiResponse.new.tap do |r|
-            customer_exists_response = nil
-            r.process { customer_exists_response = check_customer_exists(options[:customer]) }
-            r.process do
-              if customer_exists_response.params['exists']
-                add_credit_card_to_customer(creditcard, options)
-              else
-                add_customer_with_credit_card(creditcard, options)
-              end
-            end
-          end
-        else
-          add_customer_with_credit_card(creditcard, options)
+      def store(payment_method, options = {})
+        return Response.new(false, bank_account_errors(payment_method, options)) if payment_method.is_a?(Check) && bank_account_errors(payment_method, options).present?
+
+        MultiResponse.run do |r|
+          r.process { check_customer_exists(options[:customer]) }
+          process_by = payment_method.is_a?(Check) ? :store_bank_account : :store_credit_card
+          send process_by, payment_method, options, r
         end
       end
 
@@ -227,6 +237,8 @@ module ActiveMerchant #:nodoc:
       private
 
       def check_customer_exists(customer_vault_id)
+        return Response.new true, 'Customer not found', { exists: false } if customer_vault_id.blank?
+
         commit do
           @braintree_gateway.customer.find(customer_vault_id)
           ActiveMerchant::Billing::Response.new(true, 'Customer found', { exists: true }, authorization: customer_vault_id)
@@ -468,16 +480,28 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def additional_processor_response_from_result(result)
+        result.transaction&.additional_processor_response
+      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?
           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)
+        @braintree_gateway.customer.update(
+          result.transaction.customer_details.id,
+          default_payment_method_token: result.transaction.paypal_details.implicitly_vaulted_payment_method_token
+        )
+      end
+
       def extract_refund_args(args)
         options = args.extract_options!
 
@@ -517,7 +541,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def transaction_hash(result)
-        return { 'processor_response_code' => response_code_from_result(result) } unless result.success?
+        unless result.success?
+          return { 'processor_response_code' => response_code_from_result(result),
+                   'additional_processor_response' => additional_processor_response_from_result(result) }
+        end
 
         transaction = result.transaction
         if transaction.vault_customer
@@ -577,19 +604,20 @@ module ActiveMerchant #:nodoc:
         end
 
         {
-          'order_id'                => transaction.order_id,
-          'amount'                  => transaction.amount.to_s,
-          'status'                  => transaction.status,
-          'credit_card_details'     => credit_card_details,
-          'customer_details'        => customer_details,
-          'billing_details'         => billing_details,
-          'shipping_details'        => shipping_details,
-          'vault_customer'          => vault_customer,
-          'merchant_account_id'     => transaction.merchant_account_id,
-          'risk_data'               => risk_data,
-          'network_transaction_id'  => transaction.network_transaction_id || nil,
-          'processor_response_code' => response_code_from_result(result),
-          'recurring'               => transaction.recurring
+          'order_id'                     => transaction.order_id,
+          'amount'                       => transaction.amount.to_s,
+          'status'                       => transaction.status,
+          'credit_card_details'          => credit_card_details,
+          'customer_details'             => customer_details,
+          'billing_details'              => billing_details,
+          'shipping_details'             => shipping_details,
+          'vault_customer'               => vault_customer,
+          'merchant_account_id'          => transaction.merchant_account_id,
+          'risk_data'                    => risk_data,
+          '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
         }
       end
 
@@ -617,6 +645,7 @@ module ActiveMerchant #:nodoc:
         add_account_type(parameters, options) if options[:account_type]
         add_skip_options(parameters, options)
         add_merchant_account_id(parameters, options)
+        add_profile_id(parameters, options)
 
         add_payment_method(parameters, credit_card_or_vault_id, options)
         add_stored_credential_data(parameters, credit_card_or_vault_id, options)
@@ -624,6 +653,7 @@ module ActiveMerchant #:nodoc:
 
         add_descriptor(parameters, options)
         add_risk_data(parameters, options)
+        add_paypal_options(parameters, options)
         add_travel_data(parameters, options) if options[:travel_data]
         add_lodging_data(parameters, options) if options[:lodging_data]
         add_channel(parameters, options)
@@ -659,6 +689,13 @@ module ActiveMerchant #:nodoc:
         parameters[:merchant_account_id] = merchant_account_id
       end
 
+      def add_profile_id(parameters, options)
+        return unless profile_id = options[:venmo_profile_id]
+
+        parameters[:options][:venmo] = {}
+        parameters[:options][:venmo][:profile_id] = profile_id
+      end
+
       def add_transaction_source(parameters, options)
         parameters[:transaction_source] = options[:transaction_source] if options[:transaction_source]
         parameters[:transaction_source] = 'recurring' if options[:recurring]
@@ -693,6 +730,15 @@ module ActiveMerchant #:nodoc:
         }
       end
 
+      def add_paypal_options(parameters, options)
+        return unless options[:paypal_custom_field] || options[:paypal_description]
+
+        parameters[:options][:paypal] = {
+          custom_field: options[:paypal_custom_field],
+          description: options[:paypal_description]
+        }
+      end
+
       def add_level_2_data(parameters, options)
         parameters[:tax_amount] = options[:tax_amount] if options[:tax_amount]
         parameters[:tax_exempt] = options[:tax_exempt] if options[:tax_exempt]
@@ -827,6 +873,79 @@ module ActiveMerchant #:nodoc:
           end
         end
       end
+
+      def bank_account_errors(payment_method, options)
+        if payment_method.validate.present?
+          payment_method.validate
+        elsif options[:billing_address].blank?
+          'billing_address is required parameter to store and verify Bank accounts.'
+        elsif options[:ach_mandate].blank?
+          'ach_mandate is a required parameter to process bank acccount transactions see (https://developer.paypal.com/braintree/docs/guides/ach/client-side#show-required-authorization-language)'
+        end
+      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
+        return Response.new(false, error_message) unless bank_account_nonce.present?
+
+        result = @braintree_gateway.payment_method.create(
+          customer_id: options[:customer],
+          payment_method_nonce: bank_account_nonce,
+          options: {
+            us_bank_account_verification_method: 'network_check'
+          }
+        )
+
+        verified = result.success? && result.payment_method&.verified
+        message = message_from_result(result)
+        message = not_verified_reason(result.payment_method) unless verified
+
+        Response.new(verified, message,
+          {
+            customer_vault_id: options[:customer],
+            bank_account_token: result.payment_method&.token,
+            verified: verified
+          },
+          authorization: result.payment_method&.token)
+      end
+
+      def not_verified_reason(bank_account)
+        return unless bank_account.verifications.present?
+
+        verification = bank_account.verifications.first
+        "verification_status: [#{verification.status}], processor_response: [#{verification.processor_response_code}-#{verification.processor_response_text}]"
+      end
+
+      def store_bank_account(payment_method, options, multi_response)
+        multi_response.process { create_customer_from_bank_account payment_method, options } unless multi_response.params['exists']
+        multi_response.process { add_bank_account_to_customer payment_method, options }
+      end
+
+      def store_credit_card(payment_method, options, multi_response)
+        process_by = multi_response.params['exists'] ? :add_credit_card_to_customer : :add_customer_with_credit_card
+        multi_response.process { send process_by, payment_method, options }
+      end
+
+      def create_customer_from_bank_account(payment_method, options)
+        parameters = {
+          id: options[:customer],
+          first_name: payment_method.first_name,
+          last_name: payment_method.last_name,
+          email: scrub_email(options[:email]),
+          phone: options[:phone] || options.dig(:billing_address, :phone),
+          device_data: options[:device_data]
+        }.compact
+
+        result = @braintree_gateway.customer.create(parameters)
+        customer_id = result.customer.id if result.success?
+        options[:customer] = customer_id
+
+        Response.new(
+          result.success?,
+          message_from_result(result),
+          { customer_vault_id: customer_id, 'exists': true }
+        )
+      end
     end
   end
 end

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

@@ -1,8 +1,8 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class CardConnectGateway < Gateway
-      self.test_url = 'https://fts.cardconnect.com:6443/cardconnect/rest/'
-      self.live_url = 'https://fts.cardconnect.com:8443/cardconnect/rest/'
+      self.test_url = 'https://fts-uat.cardconnect.com/cardconnect/rest/'
+      self.live_url = 'https://fts.cardconnect.com/cardconnect/rest/'
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
@@ -61,6 +61,8 @@ module ActiveMerchant #:nodoc:
         '60' => STANDARD_ERROR_CODE[:pickup_card]
       }
 
+      SCHEDULED_PAYMENT_TYPES = %w(recurring installment)
+
       def initialize(options = {})
         requires!(options, :merchant_id, :username, :password)
         require_valid_domain!(options, :domain)
@@ -87,8 +89,9 @@ module ActiveMerchant #:nodoc:
           add_currency(post, money, options)
           add_address(post, options)
           add_customer_data(post, options)
-          add_3DS(post, options)
+          add_three_ds_mpi_data(post, options)
           add_additional_data(post, options)
+          add_stored_credential(post, options)
           post[:capture] = 'Y'
           commit('auth', post)
         end
@@ -102,8 +105,9 @@ module ActiveMerchant #:nodoc:
         add_payment(post, payment)
         add_address(post, options)
         add_customer_data(post, options)
-        add_3DS(post, options)
+        add_three_ds_mpi_data(post, options)
         add_additional_data(post, options)
+        add_stored_credential(post, options)
         commit('auth', post)
       end
 
@@ -169,7 +173,7 @@ module ActiveMerchant #:nodoc:
       def add_address(post, options)
         if address = options[:billing_address] || options[:address]
           post[:address] = address[:address1] if address[:address1]
-          post[:address].concat(" #{address[:address2]}") if address[:address2]
+          post[:address2] = address[:address2] if address[:address2]
           post[:city] = address[:city] if address[:city]
           post[:region] = address[:state] if address[:state]
           post[:country] = address[:country] if address[:country]
@@ -188,7 +192,11 @@ module ActiveMerchant #:nodoc:
 
       def add_invoice(post, options)
         post[:orderid] = options[:order_id]
-        post[:ecomind] = (options[:recurring] ? 'R' : 'E')
+        post[:ecomind] = if options[:ecomind]
+                           options[:ecomind].capitalize
+                         else
+                           (options[:recurring] ? 'R' : 'E')
+                         end
       end
 
       def add_payment(post, payment)
@@ -241,10 +249,20 @@ module ActiveMerchant #:nodoc:
         post[:userfields] = options[:user_fields] if options[:user_fields]
       end
 
-      def add_3DS(post, options)
-        post[:secureflag] = options[:secure_flag] if options[:secure_flag]
-        post[:securevalue] = options[:secure_value] if options[:secure_value]
-        post[:securexid] = options[:secure_xid] if options[:secure_xid]
+      def add_three_ds_mpi_data(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:secureflag]  = three_d_secure[:eci]
+        post[:securevalue] = three_d_secure[:cavv]
+        post[:securedstid] = three_d_secure[:ds_transaction_id]
+      end
+
+      def add_stored_credential(post, options)
+        return unless stored_credential = options[:stored_credential]
+
+        post[:cof] = stored_credential[:initiator] == 'merchant' ? 'M' : 'C'
+        post[:cofscheduled] = SCHEDULED_PAYMENT_TYPES.include?(stored_credential[:reason_type]) ? 'Y' : 'N'
+        post[:cofpermission] = stored_credential[:initial_transaction] ? 'Y' : 'N'
       end
 
       def headers

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

@@ -222,6 +222,7 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_remote_address(post, options)
         add_country_code(post, options)
+        add_threeds_fields(post, options)
       end
 
       def add_amount(post, money, options)
@@ -283,6 +284,20 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :threeDSRequired, options[:threeds_required] || @threeds_required ? 'Y' : 'N')
       end
 
+      def add_threeds_fields(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        add_pair(post, :threeDSEnrolled, formatted_enrollment(three_d_secure[:enrolled]))
+        if three_d_secure[:enrolled] == 'true'
+          add_pair(post, :threeDSAuthenticated, three_d_secure[:authentication_response_status])
+          if three_d_secure[:authentication_response_status] == 'Y'
+            post[:threeDSECI]  = three_d_secure[:eci]
+            post[:threeDSCAVV] = three_d_secure[:cavv]
+            post[:threeDSXID] = three_d_secure[:xid] || three_d_secure[:ds_transaction_id]
+          end
+        end
+      end
+
       def add_remote_address(post, options = {})
         add_pair(post, :remoteAddress, options[:ip] || '1.1.1.1')
       end
@@ -366,6 +381,14 @@ module ActiveMerchant #:nodoc:
       def add_pair(post, key, value, options = {})
         post[key] = value if !value.blank? || options[:required]
       end
+
+      def formatted_enrollment(val)
+        case val
+        when 'Y', 'N', 'U' then val
+        when true, 'true' then 'Y'
+        when false, 'false' then 'N'
+        end
+      end
     end
   end
 end