activemerchant 1.133.0 → 1.137.0

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/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