activemerchant 1.112.0 → 1.118.0

data/lib/active_merchant/billing/gateways/quickpay/quickpay_v10.rb

@@ -68,7 +68,7 @@ module ActiveMerchant
         commit(synchronized_path("/payments/#{identification}/refund"), post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -155,8 +155,7 @@ module ActiveMerchant
 
         Response.new(success, message_from(success, response), response,
           test: test?,
-          authorization: authorization_from(response)
-        )
+          authorization: authorization_from(response))
       end
 
       def authorization_from(response)
@@ -264,7 +263,7 @@ module ActiveMerchant
       end
 
       def format_order_id(order_id)
-        truncate(order_id.to_s.gsub(/#/, ''), 20)
+        truncate(order_id.to_s.delete('#'), 20)
       end
 
       def headers

data/lib/active_merchant/billing/gateways/quickpay/quickpay_v4to7.rb

@@ -166,8 +166,7 @@ module ActiveMerchant #:nodoc:
 
         Response.new(successful?(response), message_from(response), response,
           test: test?,
-          authorization: response[:transaction]
-        )
+          authorization: response[:transaction])
       end
 
       def successful?(response)

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

@@ -16,12 +16,12 @@ module ActiveMerchant #:nodoc:
         'S' => 'D'
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :username, :password, :merchant, :pem, :pem_password)
         super
       end
 
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_order_number(post, options)
@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
         commit('capture', post)
       end
 
-      def authorize(amount, payment_method, options={})
+      def authorize(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_order_number(post, options)
@@ -47,7 +47,7 @@ module ActiveMerchant #:nodoc:
         commit('preauth', post)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization, options)
@@ -57,7 +57,7 @@ module ActiveMerchant #:nodoc:
         commit('captureWithoutAuth', post)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization, options)
@@ -69,7 +69,7 @@ module ActiveMerchant #:nodoc:
       end
 
       # Credit requires the merchant account to be enabled for "Adhoc Refunds"
-      def credit(amount, payment_method, options={})
+      def credit(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_order_number(post, options)
@@ -80,7 +80,7 @@ module ActiveMerchant #:nodoc:
         commit('refund', post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_reference(post, authorization, options)
         add_customer_data(post, options)
@@ -110,7 +110,7 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      CURRENCY_CODES = Hash.new { |h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
+      CURRENCY_CODES = Hash.new { |_h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
       CURRENCY_CODES['AUD'] = 'AUD'
       CURRENCY_CODES['INR'] = 'INR'
 
@@ -280,7 +280,7 @@ module ActiveMerchant #:nodoc:
         '12' => STANDARD_ERROR_CODE[:card_declined],
         '06' => STANDARD_ERROR_CODE[:processing_error],
         '01' => STANDARD_ERROR_CODE[:call_issuer],
-        '04' => STANDARD_ERROR_CODE[:pickup_card],
+        '04' => STANDARD_ERROR_CODE[:pickup_card]
       }
 
       def error_code_from(succeeded, response)

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

@@ -300,7 +300,7 @@ module ActiveMerchant
         end
         xml.tag! 'supplementarydata' do
           xml.tag! 'item', 'type' => 'mobile' do
-            xml.tag! 'field01', payment.source.to_s.gsub('_', '-')
+            xml.tag! 'field01', payment.source.to_s.tr('_', '-')
           end
         end
       end

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

@@ -170,6 +170,10 @@ module ActiveMerchant #:nodoc:
         9914 => 'KO Confirmation'
       }
 
+      # Expected values as per documentation
+      THREE_DS_V1 = '1.0.2'
+      THREE_DS_V2 = '2.1.0'
+
       # Creates a new instance
       #
       # Redsys requires a login and secret_key, and optionally also accepts a
@@ -197,7 +201,9 @@ module ActiveMerchant #:nodoc:
         add_amount(data, money, options)
         add_order(data, options[:order_id])
         add_payment(data, payment)
+        add_external_mpi_fields(data, options)
         add_threeds(data, options) if options[:execute_threed]
+        add_stored_credential_options(data, options)
         data[:description] = options[:description]
         data[:store_in_vault] = options[:store]
         data[:sca_exemption] = options[:sca_exemption]
@@ -213,7 +219,9 @@ module ActiveMerchant #:nodoc:
         add_amount(data, money, options)
         add_order(data, options[:order_id])
         add_payment(data, payment)
+        add_external_mpi_fields(data, options)
         add_threeds(data, options) if options[:execute_threed]
+        add_stored_credential_options(data, options)
         data[:description] = options[:description]
         data[:store_in_vault] = options[:store]
         data[:sca_exemption] = options[:sca_exemption]
@@ -321,8 +329,48 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_external_mpi_fields(data, options)
+        return unless options[:three_d_secure]
+
+        if options[:three_d_secure][:version] == THREE_DS_V2
+          data[:threeDSServerTransID] = options[:three_d_secure][:three_ds_server_trans_id] if options[:three_d_secure][:three_ds_server_trans_id]
+          data[:dsTransID] = options[:three_d_secure][:ds_transaction_id] if options[:three_d_secure][:ds_transaction_id]
+          data[:authenticacionValue] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
+          data[:protocolVersion] = options[:three_d_secure][:version] if options[:three_d_secure][:version]
+          data[:authenticacionMethod] = options[:authentication_method] if options[:authentication_method]
+          data[:authenticacionType] = options[:authentication_type] if options[:authentication_type]
+          data[:authenticacionFlow] = options[:authentication_flow] if options[:authentication_flow]
+          data[:eci_v2] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+        elsif options[:three_d_secure][:version] == THREE_DS_V1
+          data[:txid] = options[:three_d_secure][:xid] if options[:three_d_secure][:xid]
+          data[:cavv] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
+          data[:eci_v1] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+        end
+      end
+
+      def add_stored_credential_options(data, options)
+        return unless options[:stored_credential]
+
+        case options[:stored_credential][:initial_transaction]
+        when true
+          data[:DS_MERCHANT_COF_INI] = 'S'
+        when false
+          data[:DS_MERCHANT_COF_INI] = 'N'
+          data[:DS_MERCHANT_COF_TXNID] = options[:stored_credential][:network_transaction_id] if options[:stored_credential][:network_transaction_id]
+        end
+
+        case options[:stored_credential][:reason_type]
+        when 'recurring'
+          data[:DS_MERCHANT_COF_TYPE] = 'R'
+        when 'installment'
+          data[:DS_MERCHANT_COF_TYPE] = 'I'
+        when 'unscheduled'
+          return
+        end
+      end
+
       def add_threeds(data, options)
-        data[:threeds] = {threeDSInfo: 'CardData'} if options[:execute_threed] == true
+        data[:threeds] = { threeDSInfo: 'CardData' } if options[:execute_threed] == true
       end
 
       def determine_3ds_action(threeds_hash)
@@ -334,7 +382,7 @@ module ActiveMerchant #:nodoc:
       def commit(data, options = {})
         if data[:threeds]
           action = determine_3ds_action(data[:threeds])
-          request = <<-EOS
+          request = <<-REQUEST
             <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:apachesoap="http://xml.apache.org/xml-soap" xmlns:impl="http://webservice.sis.sermepa.es" xmlns:intf="http://webservice.sis.sermepa.es" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
             <soapenv:Header/>
             <soapenv:Body>
@@ -345,14 +393,14 @@ module ActiveMerchant #:nodoc:
               </intf:#{action}>
             </soapenv:Body>
           </soapenv:Envelope>
-          EOS
+          REQUEST
           parse(ssl_post(threeds_url, request, headers(action)), action)
         else
           parse(ssl_post(url, "entrada=#{CGI.escape(xml_request_from(data, options))}", headers), action)
         end
       end
 
-      def headers(action=nil)
+      def headers(action = nil)
         if action
           {
             'Content-Type' => 'text/xml',
@@ -419,6 +467,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_merchant_data(xml, data, options = {})
+        # See https://sis-t.redsys.es:25443/sis/services/SerClsWSEntradaV2/wsdl/SerClsWSEntradaV2.wsdl
+        # (which results from calling #threeds_url + '?WSDL', https://sis-t.redsys.es:25443/sis/services/SerClsWSEntradaV2?WSDL)
         xml.DATOSENTRADA do
           # Basic elements
           xml.DS_Version 0.1
@@ -447,6 +497,9 @@ module ActiveMerchant #:nodoc:
             xml.DS_MERCHANT_EXPIRYDATE data[:card][:date]
             xml.DS_MERCHANT_CVV2       data[:card][:cvv]
             xml.DS_MERCHANT_IDENTIFIER 'REQUIRED' if data[:store_in_vault]
+
+            build_merchant_mpi_external(xml, data)
+
           elsif data[:credit_card_token]
             xml.DS_MERCHANT_IDENTIFIER data[:credit_card_token]
             xml.DS_MERCHANT_DIRECTPAYMENT 'true'
@@ -457,9 +510,36 @@ module ActiveMerchant #:nodoc:
           xml.DS_MERCHANT_DIRECTPAYMENT 'moto' if options.dig(:moto) && options.dig(:metadata, :manual_entry)
 
           xml.DS_MERCHANT_EMV3DS data[:threeds].to_json if data[:threeds]
+
+          if options[:stored_credential]
+            xml.DS_MERCHANT_COF_INI data[:DS_MERCHANT_COF_INI]
+            xml.DS_MERCHANT_COF_TYPE data[:DS_MERCHANT_COF_TYPE]
+            xml.DS_MERCHANT_COF_TXNID data[:DS_MERCHANT_COF_TXNID] if data[:DS_MERCHANT_COF_TXNID]
+          end
         end
       end
 
+      def build_merchant_mpi_external(xml, data)
+        return unless data[:txid] || data[:threeDSServerTransID]
+
+        ds_merchant_mpi_external = {}
+        ds_merchant_mpi_external[:TXID] = data[:txid] if data[:txid]
+        ds_merchant_mpi_external[:CAVV] = data[:cavv] if data[:cavv]
+        ds_merchant_mpi_external[:ECI] = data[:eci_v1] if data[:eci_v1]
+
+        ds_merchant_mpi_external[:threeDSServerTransID] = data[:threeDSServerTransID] if data[:threeDSServerTransID]
+        ds_merchant_mpi_external[:dsTransID] = data[:dsTransID] if data[:dsTransID]
+        ds_merchant_mpi_external[:authenticacionValue] = data[:authenticacionValue] if data[:authenticacionValue]
+        ds_merchant_mpi_external[:protocolVersion] = data[:protocolVersion] if data[:protocolVersion]
+        ds_merchant_mpi_external[:Eci] = data[:eci_v2] if data[:eci_v2]
+        ds_merchant_mpi_external[:authenticacionMethod] = data[:authenticacionMethod] if data[:authenticacionMethod]
+        ds_merchant_mpi_external[:authenticacionType] = data[:authenticacionType] if data[:authenticacionType]
+        ds_merchant_mpi_external[:authenticacionFlow] = data[:authenticacionFlow] if data[:authenticacionFlow]
+
+        xml.DS_MERCHANT_MPIEXTERNAL ds_merchant_mpi_external.to_json unless ds_merchant_mpi_external.empty?
+        xml.target!
+      end
+
       def parse(data, action)
         params  = {}
         success = false
@@ -476,7 +556,7 @@ module ActiveMerchant #:nodoc:
           if validate_signature(params)
             message = response_text(params[:ds_response])
             options[:authorization] = build_authorization(params)
-            success = is_success_response?(params[:ds_response])
+            success = success_response?(params[:ds_response])
           else
             message = 'Response failed validation check'
           end
@@ -490,7 +570,7 @@ module ActiveMerchant #:nodoc:
           end
           message = response_text_3ds(xml, params)
           options[:authorization] = build_authorization(params)
-          success = params.size > 0 && is_success_response?(params[:ds_response])
+          success = params.size > 0 && success_response?(params[:ds_response])
         else
           # Some kind of programmer error with the request!
           message = "#{code} ERROR"
@@ -559,7 +639,7 @@ module ActiveMerchant #:nodoc:
         message
       end
 
-      def is_success_response?(code)
+      def success_response?(code)
         (code.to_i < 100) || [400, 481, 500, 900].include?(code.to_i)
       end
 

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

@@ -22,12 +22,12 @@ module ActiveMerchant #:nodoc:
         'store'     => 'CC.RG'
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :sender, :channel, :login, :password)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         request = build_xml_request do |xml|
           add_identification(xml, options)
           add_payment(xml, money, 'sale', options)
@@ -39,7 +39,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         request = build_xml_request do |xml|
           add_identification(xml, options, authorization)
           add_payment(xml, money, 'refund', options)
@@ -48,7 +48,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         request = build_xml_request do |xml|
           add_identification(xml, options)
           add_payment(xml, money, 'authonly', options)
@@ -60,7 +60,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         request = build_xml_request do |xml|
           add_identification(xml, options, authorization)
           add_payment(xml, money, 'capture', options)
@@ -69,7 +69,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         request = build_xml_request do |xml|
           add_identification(xml, options, authorization)
           add_payment(xml, nil, 'void', options)
@@ -89,7 +89,7 @@ module ActiveMerchant #:nodoc:
         commit(request)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }

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

@@ -15,15 +15,26 @@ module ActiveMerchant #:nodoc:
 
       VERSION = '4.1.0'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :client_login_id, :client_password)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
-        post[:sg_APIType] = 1 if options[:three_d_secure]
-        trans_type = options[:three_d_secure] ? 'Sale3D' : 'Sale'
+
+        # Determine if 3DS is requested, or there is standard external MPI data
+        if options[:three_d_secure]
+          if options[:three_d_secure].is_a?(Hash)
+            add_external_mpi_data(post, options)
+          else
+            post[:sg_APIType] = 1
+            trans_type = 'Sale3D'
+          end
+        end
+
+        trans_type ||= 'Sale'
+
         add_transaction_data(trans_type, post, money, options)
         add_payment(post, payment, options)
         add_customer_details(post, payment, options)
@@ -31,8 +42,10 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
+
+        add_external_mpi_data(post, options) if options[:three_d_secure]&.is_a?(Hash)
         add_transaction_data('Auth', post, money, options)
         add_payment(post, payment, options)
         add_customer_details(post, payment, options)
@@ -40,10 +53,10 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         auth, transaction_id, token, exp_month, exp_year, _, original_currency = authorization.split('|')
-        add_transaction_data('Settle', post, money, options.merge!({currency: original_currency}))
+        add_transaction_data('Settle', post, money, options.merge!({ currency: original_currency }))
         post[:sg_AuthCode] = auth
         post[:sg_TransactionID] = transaction_id
         post[:sg_CCToken] = token
@@ -53,10 +66,10 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         auth, transaction_id, token, exp_month, exp_year, _, original_currency = authorization.split('|')
-        add_transaction_data('Credit', post, money, options.merge!({currency: original_currency}))
+        add_transaction_data('Credit', post, money, options.merge!({ currency: original_currency }))
         post[:sg_CreditType] = 2
         post[:sg_AuthCode] = auth
         post[:sg_TransactionID] = transaction_id
@@ -67,19 +80,21 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-      def credit(money, payment, options={})
+      def credit(money, payment, options = {})
         post = {}
+
         add_payment(post, payment, options)
         add_transaction_data('Credit', post, money, options)
+
         post[:sg_CreditType] = 1
 
         commit(post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         auth, transaction_id, token, exp_month, exp_year, original_amount, original_currency = authorization.split('|')
-        add_transaction_data('Void', post, (original_amount.to_f * 100), options.merge!({currency: original_currency}))
+        add_transaction_data('Void', post, (original_amount.to_f * 100), options.merge!({ currency: original_currency }))
         post[:sg_CreditType] = 2
         post[:sg_AuthCode] = auth
         post[:sg_TransactionID] = transaction_id
@@ -90,7 +105,7 @@ module ActiveMerchant #:nodoc:
         commit(post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -130,7 +145,7 @@ module ActiveMerchant #:nodoc:
         post[:sg_MerchantName] = options[:merchant_name] if options[:merchant_name]
       end
 
-      def add_payment(post, payment, options={})
+      def add_payment(post, payment, options = {})
         post[:sg_NameOnCard] = payment.name
         post[:sg_CardNumber] = payment.number
         post[:sg_ExpMonth] = format(payment.month, :two_digits)
@@ -154,6 +169,17 @@ module ActiveMerchant #:nodoc:
         post[:sg_Email] = options[:email]
       end
 
+      def add_external_mpi_data(post, options)
+        version = options[:three_d_secure][:ds_transaction_id] ? '2' : '1'
+
+        post[:sg_eci] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+        post[:sg_cavv] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
+        post[:sg_dsTransID] = options[:three_d_secure][:ds_transaction_id] if version == '2'
+        post[:sg_threeDSProtocolVersion] = version
+        post[:sg_xid] = options[:three_d_secure][:xid] if version == '1'
+        post[:sg_IsExternalMPI] = 1
+      end
+
       def parse(xml)
         response = {}