activemerchant 1.121.0 → 1.123.0

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

@@ -386,7 +386,7 @@ module ActiveMerchant
 
       def parse(response)
         return bad_authentication_response if response.code.to_i == 401
-        return forbidden_response(response.body) if response.code.to_i == 403
+        return generic_error_response(response.body) if [403, 429].include?(response.code.to_i)
 
         parsed = {}
         doc = Nokogiri::XML(response.body)
@@ -564,7 +564,7 @@ module ActiveMerchant
         { 'description' => 'Unable to authenticate.  Please check your credentials.' }
       end
 
-      def forbidden_response(body)
+      def generic_error_response(body)
         { 'description' => body }
       end
     end

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

@@ -135,8 +135,8 @@ module ActiveMerchant #:nodoc:
             result = @braintree_gateway.verification.create(payload)
             response = Response.new(result.success?, message_from_transaction_result(result), response_options(result))
             response.cvv_result['message'] = ''
-            response.cvv_result['code'] = response.params['cvv_result']
-            response.avs_result['code'] = response.params['avs_result'][:code]
+            response.cvv_result['code'] = response.params['cvv_result'] if response.params['cvv_result']
+            response.avs_result['code'] = response.params['avs_result'][:code] if response.params.dig('avs_result', :code)
             response
           end
 
@@ -588,7 +588,8 @@ module ActiveMerchant #:nodoc:
           '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_response_code' => response_code_from_result(result),
+          'recurring'               => transaction.recurring
         }
       end
 
@@ -770,6 +771,8 @@ module ActiveMerchant #:nodoc:
           else
             parameters[:transaction_source] = stored_credential[:reason_type]
           end
+        elsif %w(recurring_first moto).include?(stored_credential[:reason_type])
+          parameters[:transaction_source] = stored_credential[:reason_type]
         else
           parameters[:transaction_source] = ''
         end

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

@@ -20,8 +20,9 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://assigned-subdomain.credorax.net/crax_gate/service/gateway'
 
       self.supported_countries = %w(AD AT BE BG HR CY CZ DK EE FR DE GI GR GG HU IS IE IM IT JE LV LI LT LU MT MC NO PL PT RO SM SK ES SE CH GB)
+
       self.default_currency = 'EUR'
-      self.currencies_without_fractions = %w(BIF CLP DJF GNF JPY KMF KRW PYG RWF VND VUV XAF XOF XPF)
+      self.currencies_without_fractions = %w(BIF CLP DJF GNF ISK JPY KMF KRW PYG RWF VND VUV XAF XOF XPF)
       self.currencies_with_three_decimal_places = %w(BHD IQD JOD KWD LYD OMR TND)
 
       self.money_format = :cents

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

@@ -153,6 +153,10 @@ module ActiveMerchant #:nodoc:
         commit(build_refund_request(money, identification, options), :refund, money, options)
       end
 
+      def adjust(money, authorization, options = {})
+        commit(build_adjust_request(money, authorization, options), :adjust, money, options)
+      end
+
       def verify(payment, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, payment, options) }
@@ -285,6 +289,7 @@ module ActiveMerchant #:nodoc:
 
       def build_auth_request(money, creditcard_or_reference, options)
         xml = Builder::XmlMarkup.new indent: 2
+        add_customer_id(xml, options)
         add_payment_method_or_subscription(xml, money, creditcard_or_reference, options)
         add_threeds_2_ucaf_data(xml, creditcard_or_reference, options)
         add_decision_manager_fields(xml, options)
@@ -300,7 +305,15 @@ module ActiveMerchant #:nodoc:
         add_merchant_description(xml, options)
         add_sales_slip_number(xml, options)
         add_airline_data(xml, options)
+        xml.target!
+      end
 
+      def build_adjust_request(money, authorization, options)
+        _, request_id = authorization.split(';')
+
+        xml = Builder::XmlMarkup.new indent: 2
+        add_purchase_data(xml, money, true, options)
+        add_incremental_auth_service(xml, request_id, options)
         xml.target!
       end
 
@@ -334,6 +347,7 @@ module ActiveMerchant #:nodoc:
 
       def build_purchase_request(money, payment_method_or_reference, options)
         xml = Builder::XmlMarkup.new indent: 2
+        add_customer_id(xml, options)
         add_payment_method_or_subscription(xml, money, payment_method_or_reference, options)
         add_threeds_2_ucaf_data(xml, payment_method_or_reference, options)
         add_decision_manager_fields(xml, options)
@@ -472,8 +486,8 @@ module ActiveMerchant #:nodoc:
 
         unless network_tokenization?(payment_method)
           xml.tag! 'businessRules' do
-            xml.tag!('ignoreAVSResult', 'true') if extract_option(prioritized_options, :ignore_avs)
-            xml.tag!('ignoreCVResult', 'true') if extract_option(prioritized_options, :ignore_cvv)
+            xml.tag!('ignoreAVSResult', 'true') if extract_option(prioritized_options, :ignore_avs).to_s == 'true'
+            xml.tag!('ignoreCVResult', 'true') if extract_option(prioritized_options, :ignore_cvv).to_s == 'true'
           end
         end
       end
@@ -515,6 +529,12 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_customer_id(xml, options)
+        return unless options[:customer_id]
+
+        xml.tag! 'customerID', options[:customer_id]
+      end
+
       def add_merchant_description(xml, options)
         return unless options[:merchant_descriptor_name] || options[:merchant_descriptor_address1] || options[:merchant_descriptor_locality]
 
@@ -585,7 +605,7 @@ module ActiveMerchant #:nodoc:
           xml.tag! 'accountNumber', creditcard.number
           xml.tag! 'expirationMonth', format(creditcard.month, :two_digits)
           xml.tag! 'expirationYear', format(creditcard.year, :four_digits)
-          xml.tag!('cvNumber', creditcard.verification_value) unless @options[:ignore_cvv] || creditcard.verification_value.blank?
+          xml.tag!('cvNumber', creditcard.verification_value) unless @options[:ignore_cvv].to_s == 'true' || creditcard.verification_value.blank?
           xml.tag! 'cardType', @@credit_card_codes[card_brand(creditcard).to_sym]
         end
       end
@@ -658,6 +678,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_incremental_auth_service(xml, authorization, options)
+        xml.tag! 'ccIncrementalAuthService', { 'run' => 'true' } do
+          xml.tag! 'authRequestID', authorization
+        end
+        xml.tag! 'subsequentAuthReason', options[:auth_reason]
+      end
+
       def add_normalized_threeds_2_data(xml, payment_method, options)
         threeds_2_options = options[:three_d_secure]
         cc_brand = card_brand(payment_method).to_sym

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

@@ -282,7 +282,13 @@ module ActiveMerchant #:nodoc:
         if error = response.dig('status_details', 'error')
           message = "#{error.dig('reason', 'description')} | #{error['type']}"
         elsif response['error_type']
-          message = response['validation_errors'].map { |errors| "#{errors['code']}: #{errors['param']}" }.join(', ') if response['validation_errors']
+          if response['validation_errors'].is_a?(Array)
+            message = response['validation_errors'].map { |errors| "#{errors['code']}: #{errors['param']}" }.join(', ')
+          elsif response['validation_errors'].is_a?(Hash)
+            errors = response['validation_errors'].map { |k, v| "#{k}: #{v}" }.join(', ')
+            message = "#{response['error_type']} - #{errors}"
+          end
+
           message ||= response['error_type']
         end
 

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

@@ -201,8 +201,8 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_invoice(xml, options)
-        xml.ssl_invoice_number    truncate((options[:order_id] || options[:invoice]), 25)
-        xml.ssl_description       truncate(options[:description], 255)
+        xml.ssl_invoice_number    url_encode_truncate((options[:order_id] || options[:invoice]), 25)
+        xml.ssl_description       url_encode_truncate(options[:description], 255)
       end
 
       def add_approval_code(xml, authorization)
@@ -219,8 +219,8 @@ module ActiveMerchant #:nodoc:
 
         add_verification_value(xml, creditcard) if creditcard.verification_value?
 
-        xml.ssl_first_name    truncate(creditcard.first_name, 20)
-        xml.ssl_last_name     truncate(creditcard.last_name, 30)
+        xml.ssl_first_name    url_encode_truncate(creditcard.first_name, 20)
+        xml.ssl_last_name     url_encode_truncate(creditcard.last_name, 30)
       end
 
       def add_currency(xml, money, options)
@@ -240,7 +240,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_customer_email(xml, options)
-        xml.ssl_email truncate(options[:email], 100) unless empty?(options[:email])
+        xml.ssl_email url_encode_truncate(options[:email], 100) unless empty?(options[:email])
       end
 
       def add_salestax(xml, options)
@@ -253,27 +253,27 @@ module ActiveMerchant #:nodoc:
         billing_address = options[:billing_address] || options[:address]
 
         if billing_address
-          xml.ssl_avs_address     truncate(billing_address[:address1], 30)
-          xml.ssl_address2        truncate(billing_address[:address2], 30)
-          xml.ssl_avs_zip         truncate(billing_address[:zip].to_s.gsub(/[^a-zA-Z0-9]/, ''), 9)
-          xml.ssl_city            truncate(billing_address[:city], 30)
-          xml.ssl_state           truncate(billing_address[:state], 10)
-          xml.ssl_company         truncate(billing_address[:company], 50)
-          xml.ssl_phone           truncate(billing_address[:phone], 20)
-          xml.ssl_country         truncate(billing_address[:country], 50)
+          xml.ssl_avs_address     url_encode_truncate(billing_address[:address1], 30)
+          xml.ssl_address2        url_encode_truncate(billing_address[:address2], 30)
+          xml.ssl_avs_zip         url_encode_truncate(billing_address[:zip].to_s.gsub(/[^a-zA-Z0-9]/, ''), 9)
+          xml.ssl_city            url_encode_truncate(billing_address[:city], 30)
+          xml.ssl_state           url_encode_truncate(billing_address[:state], 10)
+          xml.ssl_company         url_encode_truncate(billing_address[:company], 50)
+          xml.ssl_phone           url_encode_truncate(billing_address[:phone], 20)
+          xml.ssl_country         url_encode_truncate(billing_address[:country], 50)
         end
 
         if shipping_address = options[:shipping_address]
-          xml.ssl_ship_to_address1    truncate(shipping_address[:address1], 30)
-          xml.ssl_ship_to_address2    truncate(shipping_address[:address2], 30)
-          xml.ssl_ship_to_city        truncate(shipping_address[:city], 30)
-          xml.ssl_ship_to_company     truncate(shipping_address[:company], 50)
-          xml.ssl_ship_to_country     truncate(shipping_address[:country], 50)
-          xml.ssl_ship_to_first_name  truncate(shipping_address[:first_name], 20)
-          xml.ssl_ship_to_last_name   truncate(shipping_address[:last_name], 30)
-          xml.ssl_ship_to_phone       truncate(shipping_address[:phone], 10)
-          xml.ssl_ship_to_state       truncate(shipping_address[:state], 2)
-          xml.ssl_ship_to_zip         truncate(shipping_address[:zip], 10)
+          xml.ssl_ship_to_address1    url_encode_truncate(shipping_address[:address1], 30)
+          xml.ssl_ship_to_address2    url_encode_truncate(shipping_address[:address2], 30)
+          xml.ssl_ship_to_city        url_encode_truncate(shipping_address[:city], 30)
+          xml.ssl_ship_to_company     url_encode_truncate(shipping_address[:company], 50)
+          xml.ssl_ship_to_country     url_encode_truncate(shipping_address[:country], 50)
+          xml.ssl_ship_to_first_name  url_encode_truncate(shipping_address[:first_name], 20)
+          xml.ssl_ship_to_last_name   url_encode_truncate(shipping_address[:last_name], 30)
+          xml.ssl_ship_to_phone       url_encode_truncate(shipping_address[:phone], 10)
+          xml.ssl_ship_to_state       url_encode_truncate(shipping_address[:state], 2)
+          xml.ssl_ship_to_zip         url_encode_truncate(shipping_address[:zip], 10)
         end
       end
 
@@ -293,9 +293,12 @@ module ActiveMerchant #:nodoc:
         xml.ssl_cardholder_ip options[:ip] if options.has_key?(:ip)
       end
 
+      # add_recurring_token is a field that can be sent in to obtain a token from Elavon for use with their tokenization program
       def add_auth_purchase_params(xml, options)
         xml.ssl_dynamic_dba                     options[:dba] if options.has_key?(:dba)
         xml.ssl_merchant_initiated_unscheduled  merchant_initiated_unscheduled(options) if merchant_initiated_unscheduled(options)
+        xml.ssl_add_token                       options[:add_recurring_token] if options.has_key?(:add_recurring_token)
+        xml.ssl_token                           options[:ssl_token] if options.has_key?(:ssl_token)
         xml.ssl_customer_code                   options[:customer] if options.has_key?(:customer)
         xml.ssl_customer_number                 options[:customer_number] if options.has_key?(:customer_number)
         xml.ssl_entry_mode                      entry_mode(options) if entry_mode(options)
@@ -367,7 +370,7 @@ module ActiveMerchant #:nodoc:
 
       def merchant_initiated_unscheduled(options)
         return options[:merchant_initiated_unscheduled] if options[:merchant_initiated_unscheduled]
-        return 'Y' if options.dig(:stored_credential, :initiator) == 'merchant' && options.dig(:stored_credential, :reason_type) == 'unscheduled'
+        return 'Y' if options.dig(:stored_credential, :initiator) == 'merchant' && options.dig(:stored_credential, :reason_type) == 'unscheduled' || options.dig(:stored_credential, :reason_type) == 'recurring'
       end
 
       def entry_mode(options)
@@ -392,6 +395,7 @@ module ActiveMerchant #:nodoc:
         request = "xmldata=#{request}".delete('&')
 
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
+        response = hash_html_decode(response)
 
         Response.new(
           response[:result] == '0',
@@ -413,7 +417,7 @@ module ActiveMerchant #:nodoc:
       def headers
         {
           'Accept' => 'application/xml',
-          'Content-type' => 'application/x-www-form-urlencoded'
+          'Content-type' => 'application/x-www-form-urlencoded;charset=utf8'
         }
       end
 
@@ -428,12 +432,40 @@ module ActiveMerchant #:nodoc:
         [response[:approval_code], response[:txn_id]].join(';')
       end
 
-      def truncate(value, size)
+      def url_encode_truncate(value, size)
         return nil unless value
 
-        difference = value.force_encoding('iso-8859-1').length - value.length
+        encoded = url_encode(value)
 
-        return value.delete('&"<>').to_s[0, (size - difference)]
+        while encoded.length > size
+          value.chop!
+          encoded = url_encode(value)
+        end
+        encoded
+      end
+
+      def url_encode(value)
+        if value.is_a?(String)
+          encoded = CGI.escape(value)
+          encoded = encoded.tr('+', ' ') # don't encode spaces
+          encoded = encoded.gsub('%26', '%26amp;') # account for Elavon's weird '&' handling
+          encoded
+        else
+          value.to_s
+        end
+      end
+
+      def hash_html_decode(hash)
+        hash.each do |k, v|
+          if v.is_a?(String)
+            # decode all string params
+            v = v.gsub('&amp;amp;', '&amp;') # account for Elavon's weird '&' handling
+            hash[k] = CGI.unescape_html(v)
+          elsif v.is_a?(Hash)
+            hash_html_decode(v)
+          end
+        end
+        hash
       end
     end
   end

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

@@ -192,6 +192,8 @@ module ActiveMerchant #:nodoc:
           xml.PaymentType options[:payment_type] if options[:payment_type]
           xml.SubmissionType options[:submission_type] if options[:submission_type]
           xml.DuplicateCheckDisableFlag options[:duplicate_check_disable_flag].to_s == 'true' ? 'True' : 'False' unless options[:duplicate_check_disable_flag].nil?
+          xml.DuplicateOverrideFlag options[:duplicate_override_flag].to_s == 'true' ? 'True' : 'False' unless options[:duplicate_override_flag].nil?
+          xml.MerchantDescriptor options[:merchant_descriptor] if options[:merchant_descriptor]
         end
       end
 

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

@@ -33,7 +33,7 @@ module ActiveMerchant #:nodoc:
         add_creator_info(post, options)
         add_fraud_fields(post, options)
         add_external_cardholder_authentication_data(post, options)
-        commit(:authorize, post)
+        commit(:authorize, post, options: options)
       end
 
       def capture(money, authorization, options = {})
@@ -41,7 +41,7 @@ module ActiveMerchant #:nodoc:
         add_order(post, money, options, capture: true)
         add_customer_data(post, options)
         add_creator_info(post, options)
-        commit(:capture, post, authorization)
+        commit(:capture, post, authorization: authorization)
       end
 
       def refund(money, authorization, options = {})
@@ -49,13 +49,13 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money, options)
         add_refund_customer_data(post, options)
         add_creator_info(post, options)
-        commit(:refund, post, authorization)
+        commit(:refund, post, authorization: authorization)
       end
 
       def void(authorization, options = {})
         post = nestable_hash
         add_creator_info(post, options)
-        commit(:void, post, authorization)
+        commit(:void, post, authorization: authorization)
       end
 
       def verify(payment, options = {})
@@ -277,9 +277,13 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def commit(action, post, authorization = nil)
+      def idempotency_key_for_signature(options)
+        "x-gcs-idempotence-key:#{options[:idempotency_key]}" if options[:idempotency_key]
+      end
+
+      def commit(action, post, authorization: nil, options: {})
         begin
-          raw_response = ssl_post(url(action, authorization), post.to_json, headers(action, post, authorization))
+          raw_response = ssl_post(url(action, authorization), post.to_json, headers(action, post, authorization, options))
           response = parse(raw_response)
         rescue ResponseError => e
           response = parse(e.response.body) if e.response.code.to_i >= 400
@@ -306,21 +310,26 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def headers(action, post, authorization = nil)
-        {
+      def headers(action, post, authorization = nil, options = {})
+        headers = {
           'Content-Type' => content_type,
-          'Authorization' => auth_digest(action, post, authorization),
+          'Authorization' => auth_digest(action, post, authorization, options),
           'Date' => date
         }
+
+        headers['X-GCS-Idempotence-Key'] = options[:idempotency_key] if options[:idempotency_key]
+        headers
       end
 
-      def auth_digest(action, post, authorization = nil)
+      def auth_digest(action, post, authorization = nil, options = {})
         data = <<~REQUEST
           POST
           #{content_type}
           #{date}
+          #{idempotency_key_for_signature(options)}
           #{uri(action, authorization)}
         REQUEST
+        data = data.each_line.reject { |line| line.strip == '' }.join
         digest = OpenSSL::Digest.new('sha256')
         key = @options[:secret_api_key]
         "GCS v1HMAC:#{@options[:api_key_id]}:#{Base64.strict_encode64(OpenSSL::HMAC.digest(digest, key, data))}"

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

@@ -37,6 +37,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         post[:ticketNumber] = authorization
         add_invoice(action, post, amount, options)
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -46,6 +47,7 @@ module ActiveMerchant #:nodoc:
 
         post = {}
         post[:ticketNumber] = authorization
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -55,6 +57,7 @@ module ActiveMerchant #:nodoc:
 
         post = {}
         post[:ticketNumber] = authorization
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -78,6 +81,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_invoice(action, post, amount, options)
         add_payment_method(post, payment_method, options)
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -88,6 +92,8 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_reference(post, authorization, options)
         add_invoice(action, post, amount, options)
+        add_contact_details(post, options[:contact_details]) if options[:contact_details]
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -98,6 +104,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_reference(post, authorization, options)
         add_invoice(action, post, amount, options)
+        add_full_response(post, options)
 
         commit(action, post)
       end
@@ -154,6 +161,22 @@ module ActiveMerchant #:nodoc:
         post[:token] = authorization
       end
 
+      def add_contact_details(post, contact_details_options)
+        contact_details = {}
+        contact_details[:documentType] = contact_details_options[:document_type] if contact_details_options[:document_type]
+        contact_details[:documentNumber] = contact_details_options[:document_number] if contact_details_options[:document_number]
+        contact_details[:email] = contact_details_options[:email] if contact_details_options[:email]
+        contact_details[:firstName] = contact_details_options[:first_name] if contact_details_options[:first_name]
+        contact_details[:lastName] = contact_details_options[:last_name] if contact_details_options[:last_name]
+        contact_details[:secondLastName] = contact_details_options[:second_last_name] if contact_details_options[:second_last_name]
+        contact_details[:phoneNumber] = contact_details_options[:phone_number] if contact_details_options[:phone_number]
+        post[:contactDetails] = contact_details
+      end
+
+      def add_full_response(post, options)
+        post[:fullResponse] = options[:full_response].to_s.casecmp('true').zero? if options[:full_response]
+      end
+
       ENDPOINT = {
         'tokenize' => 'tokens',
         'charge' => 'charges',