activemerchant 1.123.0 → 1.126.0

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

@@ -83,6 +83,7 @@ module ActiveMerchant #:nodoc:
         options[:name] = credit_card.name if options[:name].blank? && credit_card
         request = build_recurring_request(options[:profile_id] ? :modify : :add, money, options) do |xml|
           add_credit_card(xml, credit_card, options) if credit_card
+          add_stored_credential(xml, options[:stored_credential])
         end
         commit(request, options.merge(request_type: :recurring))
       end
@@ -158,6 +159,7 @@ module ActiveMerchant #:nodoc:
                 xml.tag! 'ExtData', 'Name' => 'ORIGID', 'Value' => reference
               end
             end
+            add_stored_credential(xml, options[:stored_credential])
           end
           xml.tag! 'ExtData', 'Name' => 'BUTTONSOURCE', 'Value' => application_id unless application_id.blank?
         end
@@ -190,15 +192,43 @@ module ActiveMerchant #:nodoc:
               xml.tag! 'TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money)
             end
 
+            if %i(authorization purchase).include? action
+              add_mpi_3ds(xml, options[:three_d_secure]) if options[:three_d_secure]
+            end
+
             xml.tag! 'Tender' do
               add_credit_card(xml, credit_card, options)
             end
+            add_stored_credential(xml, options[:stored_credential])
           end
           xml.tag! 'ExtData', 'Name' => 'BUTTONSOURCE', 'Value' => application_id unless application_id.blank?
         end
         add_level_two_three_fields(xml.target!, options)
       end
 
+      def add_mpi_3ds(xml, three_d_secure_options)
+        # structure as per https://developer.paypal.com/api/nvp-soap/payflow/3d-secure-mpi/
+        authentication_id = three_d_secure_options[:authentication_id]
+        authentication_status = three_d_secure_options[:authentication_response_status]
+
+        eci = three_d_secure_options[:eci]
+        cavv = three_d_secure_options[:cavv]
+        xid = three_d_secure_options[:xid]
+        version = three_d_secure_options[:version]
+
+        # 3DS2 only
+        ds_transaction_id = three_d_secure_options[:ds_transaction_id] if version_2_or_newer?(three_d_secure_options)
+
+        xml.tag!('ExtData', 'Name' => 'AUTHENTICATION_ID', 'Value' => authentication_id) unless authentication_id.blank?
+        xml.tag!('ExtData', 'Name' => 'AUTHENTICATION_STATUS', 'Value' => authentication_status) unless authentication_status.blank?
+
+        xml.tag!('ExtData', 'Name' => 'CAVV', 'Value' => cavv) unless cavv.blank?
+        xml.tag!('ExtData', 'Name' => 'ECI', 'Value' => eci) unless eci.blank?
+        xml.tag!('ExtData', 'Name' => 'XID', 'Value' => xid) unless xid.blank?
+        xml.tag!('ExtData', 'Name' => 'THREEDSVERSION', 'Value' => version) unless version.blank?
+        xml.tag!('ExtData', 'Name' => 'DSTRANSACTIONID', 'Value' => ds_transaction_id) unless ds_transaction_id.blank?
+      end
+
       def add_level_two_three_fields(xml_string, options)
         if options[:level_two_fields] || options[:level_three_fields]
           xml_doc = Nokogiri::XML.parse(xml_string)
@@ -258,6 +288,7 @@ module ActiveMerchant #:nodoc:
                 xml.tag! 'ABA', check.routing_number
               end
             end
+            add_stored_credential(xml, options[:stored_credential])
           end
           xml.tag! 'ExtData', 'Name' => 'BUTTONSOURCE', 'Value' => application_id unless application_id.blank?
         end
@@ -278,6 +309,37 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_stored_credential(xml, stored_credential)
+        return unless stored_credential
+
+        xml.tag! 'CardOnFile', add_card_on_file_type(stored_credential)
+        xml.tag! 'TxnId', stored_credential[:network_transaction_id] if stored_credential[:network_transaction_id]
+      end
+
+      def card_on_file_initiator(initator)
+        case initator
+        when 'merchant'
+          'MIT'
+        when 'cardholder'
+          'CIT'
+        end
+      end
+
+      def card_on_file_reason(stored_credential)
+        return 'I' if stored_credential[:initial_transaction] && stored_credential[:reason_type] == 'unscheduled'
+
+        case stored_credential[:reason_type]
+        when 'recurring', 'installment'
+          'R'
+        when 'unscheduled'
+          'U'
+        end
+      end
+
+      def add_card_on_file_type(stored_credential)
+        card_on_file_initiator(stored_credential[:initiator]).to_s + card_on_file_reason(stored_credential).to_s
+      end
+
       def add_three_d_secure(options, xml)
         if options[:three_d_secure]
           three_d_secure = options[:three_d_secure]
@@ -289,20 +351,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'
@@ -34,12 +34,21 @@ module ActiveMerchant #:nodoc:
         28 => :card_declined
       }.freeze
 
+      SUCCESS_STATUS = ['success', 'pending', 1, 0]
+
       CARD_MAPPING = {
         'visa' => 'vi',
         '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 = {})
@@ -60,6 +69,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorize(money, payment, options = {})
+        return purchase(money, payment, options) if options[:otp_flow]
+
         post = {}
 
         add_invoice(post, money, options)
@@ -70,13 +81,21 @@ module ActiveMerchant #:nodoc:
         commit_transaction('authorize', post)
       end
 
-      def capture(money, authorization, _options = {})
+      def capture(money, authorization, options = {})
         post = {
           transaction: { id: authorization }
         }
-        post[:order] = { amount: amount(money).to_f } if money
+        verify_flow = options[:type] && options[:value]
+
+        if verify_flow
+          add_customer_data(post, options)
+          add_verify_value(post, options)
+        elsif money
+          post[:order] = { amount: amount(money).to_f }
+        end
 
-        commit_transaction('capture', post)
+        action = verify_flow ? 'verify' : 'capture'
+        commit_transaction(action, post)
       end
 
       def refund(money, authorization, options = {})
@@ -132,10 +151,10 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_customer_data(post, options)
-        requires!(options, :user_id, :email)
+        requires!(options, :user_id)
         post[:user] ||= {}
         post[:user][:id] = options[:user_id]
-        post[:user][:email] = options[:email]
+        post[:user][:email] = options[:email] if options[:email]
         post[:user][:ip_address] = options[:ip] if options[:ip]
         post[:user][:fiscal_number] = options[:fiscal_number] if options[:fiscal_number]
         if phone = options[:phone] || options.dig(:billing_address, :phone)
@@ -172,6 +191,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_verify_value(post, options)
+        post[:type] = options[:type] if options[:type]
+        post[:value] = options[:value] if options[:value]
+      end
+
       def add_extra_params(post, options)
         extra_params = {}
         extra_params.merge!(options[:extra_params]) if options[:extra_params]
@@ -255,7 +279,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response)
-        !response.include?('error') && (response['status'] || response['transaction']['status']) == 'success'
+        return false if response.include?('error')
+
+        SUCCESS_STATUS.include?(response['status'] || response['transaction']['status'])
       end
 
       def card_success_from(response)
@@ -271,7 +297,7 @@ module ActiveMerchant #:nodoc:
         if !success_from(response) && response['error']
           response['error'] && response['error']['type']
         else
-          response['transaction'] && response['transaction']['message']
+          (response['transaction'] && response['transaction']['message']) || (response['message'])
         end
       end
 

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

@@ -4,8 +4,7 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://api.test.paysafe.com'
       self.live_url = 'https://api.paysafe.com'
 
-      self.supported_countries = %w(FR)
-      self.default_currency = 'EUR'
+      self.supported_countries = %w(AL AT BE BA BG CA HR CY CZ DK EE FI FR DE GR HU IS IE IT LV LI LT LU MT ME NL MK NO PL PT RO RS SK SI ES SE CH TR GB US)
       self.supported_cardtypes = %i[visa master american_express discover]
 
       self.homepage_url = 'https://www.paysafe.com/'
@@ -22,8 +21,11 @@ module ActiveMerchant #:nodoc:
         add_payment(post, payment)
         add_billing_address(post, options)
         add_merchant_details(post, options)
+        add_airline_travel_details(post, options)
         add_customer_data(post, payment, options) unless payment.is_a?(String)
         add_three_d_secure(post, payment, options) if options[:three_d_secure]
+        add_stored_credential(post, options) if options[:stored_credential]
+        add_split_pay_details(post, options)
         post[:settleWithAuth] = true
 
         commit(:post, 'auths', post, options)
@@ -37,6 +39,7 @@ module ActiveMerchant #:nodoc:
         add_merchant_details(post, options)
         add_customer_data(post, payment, options) unless payment.is_a?(String)
         add_three_d_secure(post, payment, options) if options[:three_d_secure]
+        add_stored_credential(post, options) if options[:stored_credential]
 
         commit(:post, 'auths', post, options)
       end
@@ -91,8 +94,8 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'profiles', post, options)
       end
 
-      def redact(pm_profile_id)
-        commit_for_redact(:delete, "profiles/#{pm_profile_id}", nil, nil)
+      def unstore(pm_profile_id)
+        commit(:delete, "profiles/#{get_id_from_store_auth(pm_profile_id)}", nil, nil)
       end
 
       def supports_scrubbing?
@@ -119,9 +122,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_billing_address(post, options)
-        return unless options[:billing_address] || options[:address]
+        return unless address = options[:billing_address] || options[:address]
 
-        address = options[:billing_address] || options[:address]
         post[:billingDetails] = {}
         post[:billingDetails][:street] = address[:address1]
         post[:billingDetails][:city] = address[:city]
@@ -134,21 +136,19 @@ module ActiveMerchant #:nodoc:
       # The add_address_for_vaulting method is applicable to the store method, as the APIs address
       # object is formatted differently from the standard transaction billing address
       def add_address_for_vaulting(post, options)
-        return unless options[:billing_address || options[:address]]
+        return unless address = options[:billing_address] || options[:address]
 
-        address = options[:billing_address] || options[:address]
-        post[:billingAddress] = {}
-        post[:billingAddress][:street] = address[:address1]
-        post[:billingAddress][:city] = address[:city]
-        post[:billingAddress][:zip] = address[:zip]
-        post[:billingAddress][:country] = address[:country]
-        post[:billingAddress][:state] = address[:state] if address[:state]
+        post[:card][:billingAddress] = {}
+        post[:card][:billingAddress][:street] = address[:address1]
+        post[:card][:billingAddress][:street2] = address[:address2]
+        post[:card][:billingAddress][:city] = address[:city]
+        post[:card][:billingAddress][:zip] = address[:zip]
+        post[:card][:billingAddress][:country] = address[:country]
+        post[:card][:billingAddress][:state] = address[:state] if address[:state]
       end
 
       # This data is specific to creating a profile at the gateway's vault level
       def add_profile_data(post, payment, options)
-        address = options[:billing_address] || options[:address]
-
         post[:firstName] = payment.first_name
         post[:lastName] = payment.last_name
         post[:dateOfBirth] = {}
@@ -156,8 +156,13 @@ module ActiveMerchant #:nodoc:
         post[:dateOfBirth][:month] = options[:date_of_birth][:month]
         post[:dateOfBirth][:day] = options[:date_of_birth][:day]
         post[:email] = options[:email] if options[:email]
-        post[:phone] = (address[:phone] || options[:phone]) if address[:phone] || options[:phone]
         post[:ip] = options[:ip] if options[:ip]
+
+        if options[:phone]
+          post[:phone] = options[:phone]
+        elsif address = options[:billing_address] || options[:address]
+          post[:phone] = address[:phone] if address[:phone]
+        end
       end
 
       def add_store_data(post, payment, options)
@@ -174,7 +179,7 @@ module ActiveMerchant #:nodoc:
       def add_payment(post, payment)
         if payment.is_a?(String)
           post[:card] = {}
-          post[:card][:paymentToken] = payment
+          post[:card][:paymentToken] = get_pm_from_store_auth(payment)
         else
           post[:card] = { cardExpiry: {} }
           post[:card][:cardNum] = payment.number
@@ -200,10 +205,124 @@ module ActiveMerchant #:nodoc:
         post[:authentication][:cavv] = three_d_secure[:cavv]
         post[:authentication][:xid] = three_d_secure[:xid] if three_d_secure[:xid]
         post[:authentication][:threeDSecureVersion] = three_d_secure[:version]
-        post[:authentication][:directoryServerTransactionId] = three_d_secure[:ds_transaction_id] unless payment.is_a?(String) || payment.brand != 'mastercard'
+        post[:authentication][:directoryServerTransactionId] = three_d_secure[:ds_transaction_id] unless payment.is_a?(String) || !mastercard?(payment)
+      end
+
+      def add_airline_travel_details(post, options)
+        return unless options[:airline_travel_details]
+
+        post[:airlineTravelDetails] = {}
+        post[:airlineTravelDetails][:passengerName] = options[:airline_travel_details][:passenger_name] if options[:airline_travel_details][:passenger_name]
+        post[:airlineTravelDetails][:departureDate] = options[:airline_travel_details][:departure_date] if options[:airline_travel_details][:departure_date]
+        post[:airlineTravelDetails][:origin] = options[:airline_travel_details][:origin] if options[:airline_travel_details][:origin]
+        post[:airlineTravelDetails][:computerizedReservationSystem] = options[:airline_travel_details][:computerized_reservation_system] if options[:airline_travel_details][:computerized_reservation_system]
+        post[:airlineTravelDetails][:customerReferenceNumber] = options[:airline_travel_details][:customer_reference_number] if options[:airline_travel_details][:customer_reference_number]
+
+        add_ticket_details(post, options)
+        add_travel_agency_details(post, options)
+        add_trip_legs(post, options)
+      end
+
+      def add_ticket_details(post, options)
+        return unless ticket = options[:airline_travel_details][:ticket]
+
+        post[:airlineTravelDetails][:ticket] = {}
+        post[:airlineTravelDetails][:ticket][:ticketNumber] = ticket[:ticket_number] if ticket[:ticket_number]
+        post[:airlineTravelDetails][:ticket][:isRestrictedTicket] = ticket[:is_restricted_ticket] if ticket[:is_restricted_ticket]
+      end
+
+      def add_travel_agency_details(post, options)
+        return unless agency = options[:airline_travel_details][:travel_agency]
+
+        post[:airlineTravelDetails][:travelAgency] = {}
+        post[:airlineTravelDetails][:travelAgency][:name] = agency[:name] if agency[:name]
+        post[:airlineTravelDetails][:travelAgency][:code] = agency[:code] if agency[:code]
+      end
+
+      def add_trip_legs(post, options)
+        return unless trip_legs = options[:airline_travel_details][:trip_legs]
+
+        trip_legs_hash = {}
+        trip_legs.each.with_index(1) do |leg, i|
+          my_leg = "leg#{i}".to_sym
+          details = add_leg_details(my_leg, leg[1])
+
+          trip_legs_hash[my_leg] = details
+        end
+        post[:airlineTravelDetails][:tripLegs] = trip_legs_hash
+      end
+
+      def add_leg_details(obj, leg)
+        details = {}
+        add_flight_details(details, obj, leg)
+        details[:serviceClass] = leg[:service_class] if leg[:service_class]
+        details[:isStopOverAllowed] = leg[:is_stop_over_allowed] if leg[:is_stop_over_allowed]
+        details[:destination] = leg[:destination] if leg[:destination]
+        details[:fareBasis] = leg[:fare_basis] if leg[:fare_basis]
+        details[:departureDate] = leg[:departure_date] if leg[:departure_date]
+
+        details
+      end
+
+      def add_flight_details(details, obj, leg)
+        details[:flight] = {}
+        details[:flight][:carrierCode] = leg[:flight][:carrier_code] if leg[:flight][:carrier_code]
+        details[:flight][:flightNumber] = leg[:flight][:flight_number] if leg[:flight][:flight_number]
+      end
+
+      def add_split_pay_details(post, options)
+        return unless options[:split_pay]
+
+        split_pay = []
+        options[:split_pay].each do |pmnt|
+          split = {}
+
+          split[:linkedAccount] = pmnt[:linked_account]
+          split[:amount] = pmnt[:amount].to_i if pmnt[:amount]
+          split[:percent] = pmnt[:percent].to_i if pmnt[:percent]
+
+          split_pay << split
+        end
+        post[:splitpay] = split_pay
+      end
+
+      def add_stored_credential(post, options)
+        return unless options[:stored_credential]
+
+        post[:storedCredential] = {}
+
+        case options[:stored_credential][:initial_transaction]
+        when true
+          post[:storedCredential][:occurrence] = 'INITIAL'
+        when false
+          post[:storedCredential][:occurrence] = 'SUBSEQUENT'
+        end
+
+        case options[:stored_credential][:reason_type]
+        when 'recurring', 'installment'
+          post[:storedCredential][:type] = 'RECURRING'
+        when 'unscheduled'
+          if options[:stored_credential][:initiator] == 'merchant'
+            post[:storedCredential][:type] = 'TOPUP'
+          elsif options[:stored_credential][:initiator] == 'cardholder'
+            post[:storedCredential][:type] = 'ADHOC'
+          else
+            return
+          end
+        end
+
+        post[:storedCredential][:initialTransactionId] = options[:stored_credential][:network_transaction_id] if options[:stored_credential][:network_transaction_id]
+      end
+
+      def mastercard?(payment)
+        return false unless payment.respond_to?(:brand)
+
+        payment.brand == 'master'
       end
 
       def parse(body)
+        return {} if body.empty?
+
         JSON.parse(body)
       end
 
@@ -217,7 +336,7 @@ module ActiveMerchant #:nodoc:
           success,
           message_from(success, response),
           response,
-          authorization: authorization_from(response),
+          authorization: authorization_from(action, response),
           avs_result: AVSResult.new(code: response['avsResponse']),
           cvv_result: CVVResult.new(response['cvvVerification']),
           test: test?,
@@ -225,21 +344,10 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def commit_for_redact(method, action, parameters, options)
-        url = url(action)
-        response = raw_ssl_request(method, url, post_data(parameters, options), headers)
-        success = true if response.code == '200'
-
-        Response.new(
-          success,
-          message: response.message
-        )
-      end
-
       def headers
         {
           'Content-Type' => 'application/json',
-          'Authorization' => "Basic #{Base64.strict_encode64(@options[:api_key].to_s)}"
+          'Authorization' => 'Basic ' + Base64.strict_encode64("#{@options[:username]}:#{@options[:password]}")
         }
       end
 
@@ -265,8 +373,21 @@ module ActiveMerchant #:nodoc:
         "Error(s)- code:#{response['error']['code']}, message:#{response['error']['message']}"
       end
 
-      def authorization_from(response)
-        response['id']
+      def authorization_from(action, response)
+        if action == 'profiles'
+          pm = response['cards'].first['paymentToken']
+          "#{pm}|#{response['id']}"
+        else
+          response['id']
+        end
+      end
+
+      def get_pm_from_store_auth(authorization)
+        authorization.split('|')[0]
+      end
+
+      def get_id_from_store_auth(authorization)
+        authorization.split('|')[1]
       end
 
       def post_data(parameters = {}, options = {})

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

@@ -17,6 +17,7 @@ module ActiveMerchant #:nodoc:
       BRAND_MAP = {
         'visa' => 'VISA',
         'master' => 'MASTERCARD',
+        'maestro' => 'MASTERCARD',
         'american_express' => 'AMEX',
         'diners_club' => 'DINERS',
         'naranja' => 'NARANJA',
@@ -278,6 +279,10 @@ module ActiveMerchant #:nodoc:
         Digest::MD5.hexdigest(signature_string)
       end
 
+      def codensa_bin?(number)
+        number.start_with?('590712')
+      end
+
       def add_payment_method(post, payment_method, options)
         if payment_method.is_a?(String)
           brand, token = split_authorization(payment_method)
@@ -295,7 +300,7 @@ module ActiveMerchant #:nodoc:
           credit_card[:name] = payment_method.name.strip
           credit_card[:processWithoutCvv2] = true if add_process_without_cvv2(payment_method, options)
           post[:transaction][:creditCard] = credit_card
-          post[:transaction][:paymentMethod] = BRAND_MAP[payment_method.brand.to_s]
+          post[:transaction][:paymentMethod] = codensa_bin?(payment_method.number) ? 'CODENSA' : BRAND_MAP[payment_method.brand.to_s]
         end
       end
 
@@ -387,26 +392,36 @@ module ActiveMerchant #:nodoc:
       def message_from(action, success, response)
         case action
         when 'store'
-          return response['code'] if success
-
-          error_description = response['creditCardToken']['errorDescription'] if response['creditCardToken']
-          response['error'] || error_description || 'FAILED'
+          message_from_store(success, response)
         when 'verify_credentials'
-          return 'VERIFIED' if success
-
-          'FAILED'
+          message_from_verify_credentials(success)
         else
-          if response['transactionResponse']
-            response_message = response['transactionResponse']['responseMessage']
+          message_from_transaction_response(success, response)
+        end
+      end
 
-            response_code = response['transactionResponse']['responseCode'] || response['transactionResponse']['pendingReason']
+      def message_from_store(success, response)
+        return response['code'] if success
 
-            response_message = response_code + ' | ' + response['transactionResponse']['paymentNetworkResponseErrorMessage'] unless response['transactionResponse']['paymentNetworkResponseErrorMessage'].nil?
-          end
-          return response_code if success
+        error_description = response['creditCardToken']['errorDescription'] if response['creditCardToken']
+        response['error'] || error_description || 'FAILED'
+      end
 
-          response_message || response['error'] || response_code || 'FAILED'
-        end
+      def message_from_verify_credentials(success)
+        return 'VERIFIED' if success
+
+        'FAILED'
+      end
+
+      def message_from_transaction_response(success, response)
+        response_code = response.dig('transactionResponse', 'responseCode') || response.dig('transactionResponse', 'pendingReason')
+        return response_code if success
+        return response_code + ' | ' + response.dig('transactionResponse', 'paymentNetworkResponseErrorMessage') if response.dig('transactionResponse', 'paymentNetworkResponseErrorMessage')
+        return response.dig('transactionResponse', 'responseMessage') if response.dig('transactionResponse', 'responseMessage')
+        return response['error'] if response['error']
+        return response_code if response_code
+
+        'FAILED'
       end
 
       def authorization_from(action, response)