activemerchant 1.123.0 → 1.125.0

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

@@ -0,0 +1,260 @@
+require 'json'
+require 'openssl'
+require 'digest'
+require 'base64'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MitGateway < Gateway
+      self.live_url = 'https://wpy.mitec.com.mx/ModuloUtilWS/activeCDP.htm'
+
+      self.supported_countries = ['MX']
+      self.default_currency = 'MXN'
+      self.supported_cardtypes = %i[visa master]
+
+      self.homepage_url = 'http://www.centrodepagos.com.mx/'
+      self.display_name = 'MIT Centro de pagos'
+
+      self.money_format = :dollars
+
+      def initialize(options = {})
+        requires!(options, :commerce_id, :user, :api_key, :key_session)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        MultiResponse.run do |r|
+          r.process { authorize(money, payment, options) }
+          r.process { capture(money, r.authorization, options) }
+        end
+      end
+
+      def cipher_key
+        @options[:key_session]
+      end
+
+      def decrypt(val, keyinhex)
+        # Splits the first 16 bytes (the IV bytes) in array format
+        unpacked = val.unpack('m')
+        iv_base64 = unpacked[0].bytes.slice(0, 16)
+        # Splits the second bytes (the encrypted text bytes) these would be the
+        # original message
+        full_data = unpacked[0].bytes.slice(16, unpacked[0].bytes.length)
+        # Creates the engine
+        engine = OpenSSL::Cipher::AES128.new(:CBC)
+        # Set engine as decrypt mode
+        engine.decrypt
+        # Converts the key from hex to bytes
+        engine.key = [keyinhex].pack('H*')
+        # Converts the ivBase64 array into bytes
+        engine.iv = iv_base64.pack('c*')
+        # Decrypts the texts and returns the original string
+        engine.update(full_data.pack('c*')) + engine.final
+      end
+
+      def encrypt(val, keyinhex)
+        # Creates the engine motor
+        engine = OpenSSL::Cipher::AES128.new(:CBC)
+        # Set engine as encrypt mode
+        engine.encrypt
+        # Converts the key from hex to bytes
+        engine.key = [keyinhex].pack('H*')
+        # Generates a random iv with this settings
+        iv_rand = engine.random_iv
+        # Packs IV as a Base64 string
+        iv_base64 = [iv_rand].pack('m')
+        # Converts the packed key into bytes
+        unpacked = iv_base64.unpack('m')
+        iv = unpacked[0]
+        # Sets the IV into the engine
+        engine.iv = iv
+        # Encrypts the texts and stores the bytes
+        encrypted_bytes = engine.update(val) + engine.final
+        # Concatenates the (a) IV bytes and (b) the encrypted bytes then returns a
+        # base64 representation
+        [iv << encrypted_bytes].pack('m')
+      end
+
+      def authorize(money, payment, options = {})
+        post = {
+          operation: 'Authorize',
+          commerce_id: @options[:commerce_id],
+          user: @options[:user],
+          apikey: @options[:api_key],
+          testMode: (test? ? 'YES' : 'NO')
+        }
+        add_invoice(post, money, options)
+        # Payments contains the card information
+        add_payment(post, payment)
+        add_customer_data(post, options)
+        post[:key_session] = @options[:key_session]
+
+        post_to_json = post.to_json
+        post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
+
+        final_post = '<authorization>' + post_to_json_encrypt + '</authorization><dataID>' + @options[:user] + '</dataID>'
+        json_post = {}
+        json_post[:payload] = final_post
+        commit('sale', json_post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {
+          operation: 'Capture',
+          commerce_id: @options[:commerce_id],
+          user: @options[:user],
+          apikey: @options[:api_key],
+          testMode: (test? ? 'YES' : 'NO'),
+          transaction_id: authorization,
+          amount: amount(money)
+        }
+        post[:key_session] = @options[:key_session]
+
+        post_to_json = post.to_json
+        post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
+
+        final_post = '<capture>' + post_to_json_encrypt + '</capture><dataID>' + @options[:user] + '</dataID>'
+        json_post = {}
+        json_post[:payload] = final_post
+        commit('capture', json_post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {
+          operation: 'Refund',
+          commerce_id: @options[:commerce_id],
+          user: @options[:user],
+          apikey: @options[:api_key],
+          testMode: (test? ? 'YES' : 'NO'),
+          transaction_id: authorization,
+          auth: authorization,
+          amount: amount(money)
+        }
+        post[:key_session] = @options[:key_session]
+
+        post_to_json = post.to_json
+        post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
+
+        final_post = '<refund>' + post_to_json_encrypt + '</refund><dataID>' + @options[:user] + '</dataID>'
+        json_post = {}
+        json_post[:payload] = final_post
+        commit('refund', json_post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        ret_transcript = transcript
+        auth_origin = ret_transcript[/<authorization>(.*?)<\/authorization>/, 1]
+        unless auth_origin.nil?
+          auth_decrypted = decrypt(auth_origin, @options[:key_session])
+          auth_json = JSON.parse(auth_decrypted)
+          auth_json['card'] = '[FILTERED]'
+          auth_json['cvv'] = '[FILTERED]'
+          auth_json['apikey'] = '[FILTERED]'
+          auth_json['key_session'] = '[FILTERED]'
+          auth_to_json = auth_json.to_json
+          auth_tagged = '<authorization>' + auth_to_json + '</authorization>'
+          ret_transcript = ret_transcript.gsub(/<authorization>(.*?)<\/authorization>/, auth_tagged)
+        end
+
+        cap_origin = ret_transcript[/<capture>(.*?)<\/capture>/, 1]
+        unless cap_origin.nil?
+          cap_decrypted = decrypt(cap_origin, @options[:key_session])
+          cap_json = JSON.parse(cap_decrypted)
+          cap_json['apikey'] = '[FILTERED]'
+          cap_json['key_session'] = '[FILTERED]'
+          cap_to_json = cap_json.to_json
+          cap_tagged = '<capture>' + cap_to_json + '</capture>'
+          ret_transcript = ret_transcript.gsub(/<capture>(.*?)<\/capture>/, cap_tagged)
+        end
+
+        ref_origin = ret_transcript[/<refund>(.*?)<\/refund>/, 1]
+        unless ref_origin.nil?
+          ref_decrypted = decrypt(ref_origin, @options[:key_session])
+          ref_json = JSON.parse(ref_decrypted)
+          ref_json['apikey'] = '[FILTERED]'
+          ref_json['key_session'] = '[FILTERED]'
+          ref_to_json = ref_json.to_json
+          ref_tagged = '<refund>' + ref_to_json + '</refund>'
+          ret_transcript = ret_transcript.gsub(/<refund>(.*?)<\/refund>/, ref_tagged)
+        end
+
+        res_origin = ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1]
+        loop do
+          break if res_origin.nil?
+
+          resp_origin = res_origin[/#{Regexp.escape('"')}(.*?)#{Regexp.escape('"')}/m, 1]
+          resp_decrypted = decrypt(resp_origin, @options[:key_session])
+          ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1] = resp_decrypted
+          ret_transcript = ret_transcript.sub('reading ', 'response: ')
+          res_origin = ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1]
+        end
+
+        ret_transcript
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] || 'nadie@mit.test'
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:reference] = options[:order_id]
+        post[:transaction_id] = options[:order_id]
+      end
+
+      def add_payment(post, payment)
+        post[:installments] = 1
+        post[:card] = payment.number
+        post[:expmonth] = payment.month
+        post[:expyear] = payment.year
+        post[:cvv] = payment.verification_value
+        post[:name_client] = [payment.first_name, payment.last_name].join(' ')
+      end
+
+      def commit(action, parameters)
+        json_str = JSON.generate(parameters)
+        cleaned_str = json_str.gsub('\n', '')
+        raw_response = ssl_post(live_url, cleaned_str, { 'Content-type' => 'application/json' })
+        response = JSON.parse(decrypt(raw_response, @options[:key_session]))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: response['some_avs_response_key']),
+          cvv_result: CVVResult.new(response['some_cvv_response_key']),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response['response'] == 'approved'
+      end
+
+      def message_from(response)
+        response['response']
+      end
+
+      def authorization_from(response)
+        response['reference']
+      end
+
+      def post_data(action, parameters = {})
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      def error_code_from(response)
+        response['message'].split(' -- ', 2)[0] unless success_from(response)
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class MokaGateway < Gateway
-      self.test_url = 'https://service.testmoka.com'
+      self.test_url = 'https://service.refmoka.com'
       self.live_url = 'https://service.moka.com'
 
       self.supported_countries = %w[GB TR US]
@@ -55,8 +55,10 @@ module ActiveMerchant #:nodoc:
         post[:PaymentDealerRequest] = {}
         options[:pre_auth] = 0
         add_auth_purchase(post, money, payment, options)
+        add_3ds_data(post, options) if options[:execute_threed]
 
-        commit('purchase', post)
+        action = options[:execute_threed] ? 'three_ds_purchase' : 'purchase'
+        commit(action, post)
       end
 
       def authorize(money, payment, options = {})
@@ -64,8 +66,10 @@ module ActiveMerchant #:nodoc:
         post[:PaymentDealerRequest] = {}
         options[:pre_auth] = 1
         add_auth_purchase(post, money, payment, options)
+        add_3ds_data(post, options) if options[:execute_threed]
 
-        commit('authorize', post)
+        action = options[:execute_threed] ? 'three_ds_authorize' : 'authorize'
+        commit(action, post)
       end
 
       def capture(money, authorization, options = {})
@@ -73,7 +77,7 @@ module ActiveMerchant #:nodoc:
         post[:PaymentDealerRequest] = {}
         add_payment_dealer_authentication(post)
         add_transaction_reference(post, authorization)
-        add_additional_transaction_data(post, options)
+        add_invoice(post, money, options)
 
         commit('capture', post)
       end
@@ -83,7 +87,6 @@ module ActiveMerchant #:nodoc:
         post[:PaymentDealerRequest] = {}
         add_payment_dealer_authentication(post)
         add_transaction_reference(post, authorization)
-        add_additional_transaction_data(post, options)
         add_void_refund_reason(post)
         add_amount(post, money)
 
@@ -95,7 +98,6 @@ module ActiveMerchant #:nodoc:
         post[:PaymentDealerRequest] = {}
         add_payment_dealer_authentication(post)
         add_transaction_reference(post, authorization)
-        add_additional_transaction_data(post, options)
         add_void_refund_reason(post)
 
         commit('void', post)
@@ -134,6 +136,12 @@ module ActiveMerchant #:nodoc:
         add_basket_product(post, options[:basket_product]) if options[:basket_product]
       end
 
+      def add_3ds_data(post, options)
+        post[:PaymentDealerRequest][:ReturnHash] = 1
+        post[:PaymentDealerRequest][:RedirectUrl] = options[:redirect_url] || ''
+        post[:PaymentDealerRequest][:RedirectType] = options[:redirect_type] || 0
+      end
+
       def add_payment_dealer_authentication(post)
         post[:PaymentDealerAuthentication] = {
           DealerCode: @options[:dealer_code],
@@ -156,18 +164,19 @@ module ActiveMerchant #:nodoc:
       def add_payment(post, card)
         post[:PaymentDealerRequest][:CardHolderFullName] = card.name
         post[:PaymentDealerRequest][:CardNumber] = card.number
-        post[:PaymentDealerRequest][:ExpMonth] = card.month
+        post[:PaymentDealerRequest][:ExpMonth] = card.month.to_s.rjust(2, '0')
         post[:PaymentDealerRequest][:ExpYear] = card.year
-        post[:PaymentDealerRequest][:CvcNumber] = card.verification_value
+        post[:PaymentDealerRequest][:CvcNumber] = card.verification_value || ''
       end
 
       def add_amount(post, money)
-        post[:PaymentDealerRequest][:Amount] = money || 0
+        post[:PaymentDealerRequest][:Amount] = amount(money) || 0
       end
 
       def add_additional_auth_purchase_data(post, options)
         post[:PaymentDealerRequest][:IsPreAuth] = options[:pre_auth]
-        post[:PaymentDealerRequest][:Description] = options[:order_id] if options[:order_id]
+        post[:PaymentDealerRequest][:Description] = options[:description] if options[:description]
+        post[:PaymentDealerRequest][:InstallmentNumber] = options[:installment_number].to_i if options[:installment_number]
         post[:SubMerchantName] = options[:sub_merchant_name] if options[:sub_merchant_name]
         post[:IsPoolPayment] = options[:is_pool_payment] || 0
       end
@@ -232,6 +241,8 @@ module ActiveMerchant #:nodoc:
 
       def endpoint(action)
         case action
+        when 'three_ds_authorize', 'three_ds_purchase'
+          'DoDirectPaymentThreeD'
         when 'purchase', 'authorize'
           'DoDirectPayment'
         when 'capture'
@@ -256,7 +267,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response)
-        response.dig('Data', 'IsSuccessful')
+        return response.dig('Data', 'IsSuccessful') if response.dig('Data', 'IsSuccessful').to_s.present?
+
+        response['ResultCode']&.casecmp('success') == 0
       end
 
       def message_from(response)

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

@@ -276,14 +276,14 @@ module ActiveMerchant #:nodoc:
                    end
 
         Response.new(
-          success_from(response),
+          success_from(response, action),
           message_from(response),
           response,
           authorization: authorization_from(response, action),
           avs_result: AVSResult.new(code: response['some_avs_response_key']),
           cvv_result: CVVResult.new(response['some_cvv_response_key']),
           test: test?,
-          error_code: error_code_from(response)
+          error_code: error_code_from(response, action)
         )
       rescue ResponseError => e
         message = get_error_messages(e)
@@ -297,8 +297,10 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def success_from(response)
-        %w[pending paid processing canceled active].include? response['status']
+      def success_from(response, action)
+        success = response.try(:[], 'last_transaction').try(:[], 'success') unless action == 'store'
+        success = !response.try(:[], 'id').nil? if action == 'store'
+        success
       end
 
       def message_from(response)
@@ -350,8 +352,8 @@ module ActiveMerchant #:nodoc:
         parameters.to_json
       end
 
-      def error_code_from(response)
-        return if success_from(response)
+      def error_code_from(response, action)
+        return if success_from(response, action)
         return response['last_transaction']['acquirer_return_code'] if response['last_transaction']
 
         STANDARD_ERROR_CODE[:processing_error]

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

@@ -206,7 +206,8 @@ module ActiveMerchant #:nodoc:
           post[:stored_credential_indicator] = 'stored'
         else
           post[:stored_credential_indicator] = 'used'
-          post[:initial_transaction_id] = stored_credential[:network_transaction_id]
+          # should only send :initial_transaction_id if it is a MIT
+          post[:initial_transaction_id] = stored_credential[:network_transaction_id] if post[:initiated_by] == 'merchant'
         end
       end
 
@@ -236,6 +237,19 @@ module ActiveMerchant #:nodoc:
           post[:shipping_zip] = shipping_address[:zip]
           post[:shipping_phone] = shipping_address[:phone]
         end
+
+        if (descriptor = options[:descriptors])
+          post[:descriptor] = descriptor[:descriptor]
+          post[:descriptor_phone] = descriptor[:descriptor_phone]
+          post[:descriptor_address] = descriptor[:descriptor_address]
+          post[:descriptor_city] = descriptor[:descriptor_city]
+          post[:descriptor_state] = descriptor[:descriptor_state]
+          post[:descriptor_postal] = descriptor[:descriptor_postal]
+          post[:descriptor_country] = descriptor[:descriptor_country]
+          post[:descriptor_mcc] = descriptor[:descriptor_mcc]
+          post[:descriptor_merchant_id] = descriptor[:descriptor_merchant_id]
+          post[:descriptor_url] = descriptor[:descriptor_url]
+        end
       end
 
       def add_vendor_data(post, options)

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

@@ -220,8 +220,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def verify(creditcard, options = {})
+        amount = allow_0_auth?(creditcard) ? 0 : 100
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, creditcard, options) }
+          r.process { authorize(amount, creditcard, options) }
           r.process(:ignore_result) { void(r.authorization) }
         end
       end
@@ -276,6 +277,11 @@ module ActiveMerchant #:nodoc:
         commit(order, :void, options[:retry_logic], options[:trace_number])
       end
 
+      def allow_0_auth?(credit_card)
+        # Discover does not support a $0.00 authorization instead use $1.00
+        %w(visa master american_express diners_club jcb).include?(credit_card.brand)
+      end
+
       # ==== Customer Profiles
       # :customer_ref_num should be set unless you're happy with Orbital providing one
       #
@@ -337,7 +343,8 @@ module ActiveMerchant #:nodoc:
           gsub(%r((<CustomerMerchantID>).+(</CustomerMerchantID>)), '\1[FILTERED]\2').
           gsub(%r((<CustomerProfileMessage>).+(</CustomerProfileMessage>)), '\1[FILTERED]\2').
           gsub(%r((<CheckDDA>).+(</CheckDDA>)), '\1[FILTERED]\2').
-          gsub(%r((<BCRtNum>).+(</BCRtNum>)), '\1[FILTERED]\2')
+          gsub(%r((<BCRtNum>).+(</BCRtNum>)), '\1[FILTERED]\2').
+          gsub(%r((<DigitalTokenCryptogram>).+(</DigitalTokenCryptogram>)), '\1[FILTERED]\2')
       end
 
       private
@@ -569,7 +576,7 @@ module ActiveMerchant #:nodoc:
         # - http://download.chasepaymentech.com/docs/orbital/orbital_gateway_xml_specification.pdf
         unless creditcard.nil?
           if creditcard.verification_value?
-            xml.tag! :CardSecValInd, '1' if %w(visa discover).include?(creditcard.brand)
+            xml.tag! :CardSecValInd, '1' if %w(visa master discover).include?(creditcard.brand)
             xml.tag! :CardSecVal, creditcard.verification_value
           end
         end
@@ -631,6 +638,14 @@ module ActiveMerchant #:nodoc:
         xml.tag!(:SCARecurringPayment, parameters[:sca_recurring]) if valid_eci
       end
 
+      def add_mc_sca_merchant_initiated(xml, creditcard, parameters, three_d_secure)
+        return unless parameters && parameters[:sca_merchant_initiated] && creditcard.brand == 'master'
+
+        valid_eci = three_d_secure && three_d_secure[:eci] && three_d_secure[:eci] == '7'
+
+        xml.tag!(:SCAMerchantInitiatedTransaction, parameters[:sca_merchant_initiated]) if valid_eci
+      end
+
       def add_dpanind(xml, creditcard)
         return unless creditcard.is_a?(NetworkTokenizationCreditCard)
 
@@ -899,6 +914,7 @@ module ActiveMerchant #:nodoc:
             add_card_indicators(xml, parameters)
             add_stored_credentials(xml, parameters)
             add_pymt_brand_program_code(xml, payment_source, three_d_secure)
+            add_mc_sca_merchant_initiated(xml, payment_source, parameters, three_d_secure)
             add_mc_scarecurring(xml, payment_source, parameters, three_d_secure)
             add_mc_program_protocol(xml, payment_source, three_d_secure)
             add_mc_directory_trans_id(xml, payment_source, three_d_secure)

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

@@ -286,16 +286,18 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_address(post, options)
-        post['address_line1'] = options[:billing_address][:address1]
-        post['address_line2'] = options[:billing_address][:address2]
-        post['city'] = options[:billing_address][:city]
-        post['state'] = options[:billing_address][:state]
-        post['zip'] = options[:billing_address][:zip]
-        post['country'] = options[:billing_address][:country]
+        return unless billing_address = options[:billing_address]
+
+        post['address_line1'] = billing_address[:address1]
+        post['address_line2'] = billing_address[:address2]
+        post['city'] = billing_address[:city]
+        post['state'] = billing_address[:state]
+        post['zip'] = billing_address[:zip]
+        post['country'] = billing_address[:country]
       end
 
       def add_phone(post, options)
-        post['receipt_phone'] = options[:billing_address][:phone] if options[:billing_address][:phone]
+        post['phone_number'] = options[:billing_address][:phone] if options.dig(:billing_address, :phone)
       end
 
       def add_money(post, money, options)

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

@@ -79,7 +79,9 @@ module ActiveMerchant #:nodoc:
         force_utf8(transcript).
           gsub(%r((api_accesskey=)\w+), '\1[FILTERED]').
           gsub(%r((card_number=)\w+), '\1[FILTERED]').
-          gsub(%r((card_verification=)\w+), '\1[FILTERED]')
+          gsub(%r((card_verification=)\w+), '\1[FILTERED]').
+          gsub(%r((bank_account_number=)\w+), '\1[FILTERED]').
+          gsub(%r((bank_routing_number=)\w+), '\1[FILTERED]')
       end
 
       private

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

@@ -118,7 +118,7 @@ module ActiveMerchant #:nodoc:
         check_token_response(response, ENDPOINTS[:store], post, options)
       end
 
-      def redact(customer_id)
+      def unstore(customer_id)
         post = {}
         post[:customer_id] = customer_id
         response = commit(ENDPOINTS[:redact], post)

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

@@ -289,20 +289,28 @@ module ActiveMerchant #:nodoc:
             xml.tag! 'ECI', three_d_secure[:eci] unless three_d_secure[:eci].blank?
             xml.tag! 'CAVV', three_d_secure[:cavv] unless three_d_secure[:cavv].blank?
             xml.tag! 'XID', three_d_secure[:xid] unless three_d_secure[:xid].blank?
-            xml.tag! 'THREEDSVERSION', three_d_secure[:version] unless three_d_secure[:version].blank?
-            xml.tag! 'DSTRANSACTIONID', three_d_secure[:ds_transaction_id] unless three_d_secure[:ds_transaction_id].blank?
+            xml.tag! 'ThreeDSVersion', three_d_secure[:version] unless three_d_secure[:version].blank?
+            xml.tag! 'DSTransactionID', three_d_secure[:ds_transaction_id] unless three_d_secure[:ds_transaction_id].blank?
           end
         end
       end
 
       def authentication_status(three_d_secure, xml)
-        if three_d_secure[:authentication_response_status].present?
-          xml.tag! 'Status', three_d_secure[:authentication_response_status]
-        elsif three_d_secure[:directory_response_status].present?
-          xml.tag! 'Status', three_d_secure[:directory_response_status]
+        status = if three_d_secure[:authentication_response_status].present?
+                   three_d_secure[:authentication_response_status]
+                 elsif three_d_secure[:directory_response_status].present?
+                   three_d_secure[:directory_response_status]
+                 end
+        if status.present?
+          xml.tag! 'Status', status
+          xml.tag! 'AuthenticationStatus', status if version_2_or_newer?(three_d_secure)
         end
       end
 
+      def version_2_or_newer?(three_d_secure)
+        three_d_secure[:version]&.start_with?('2')
+      end
+
       def credit_card_type(credit_card)
         return '' if card_brand(credit_card).blank?
 

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

@@ -9,7 +9,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = %w[MX EC CO BR CL PE]
       self.default_currency = 'USD'
-      self.supported_cardtypes = %i[visa master american_express diners_club elo alia olimpica]
+      self.supported_cardtypes = %i[visa master american_express diners_club elo alia olimpica discover maestro sodexo carnet unionpay jcb]
 
       self.homepage_url = 'https://secure.paymentez.com/'
       self.display_name = 'Paymentez'
@@ -39,7 +39,14 @@ module ActiveMerchant #:nodoc:
         'master' => 'mc',
         'american_express' => 'ax',
         'diners_club' => 'di',
-        'elo' => 'el'
+        'elo' => 'el',
+        'discover' => 'dc',
+        'maestro' => 'ms',
+        'sodexo' => 'sx',
+        'olimpica' => 'ol',
+        'carnet' => 'ct',
+        'unionpay' => 'up',
+        'jcb' => 'jc'
       }.freeze
 
       def initialize(options = {})