activemerchant 1.130.0 → 1.137.0

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

@@ -0,0 +1,587 @@
+require 'nokogiri'
+require 'securerandom'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VantivExpressGateway < Gateway
+      self.test_url = 'https://certtransaction.elementexpress.com'
+      self.live_url = 'https://transaction.elementexpress.com'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb]
+
+      self.homepage_url = 'http://www.elementps.com'
+      self.display_name = 'Element'
+
+      SERVICE_TEST_URL = 'https://certservices.elementexpress.com'
+      SERVICE_LIVE_URL = 'https://services.elementexpress.com'
+
+      NETWORK_TOKEN_TYPE = {
+        apple_pay: 2,
+        google_pay: 1
+      }
+
+      CARD_PRESENT_CODE = {
+        'Unknown' => 1,
+        'Present' => 2,
+        'NotPresent' => 3
+      }
+
+      MARKET_CODE = {
+        'AutoRental' => 1,
+        'DirectMarketing' => 2,
+        'ECommerce' => 3,
+        'FoodRestaurant' => 4,
+        'HotelLodging' => 5,
+        'Petroleum' => 6,
+        'Retail' => 7,
+        'QSR' => 8,
+        'Grocery' => 9
+      }
+
+      PAYMENT_TYPE = {
+        'NotUsed' => 0,
+        'Recurring' => 1,
+        'Installment' => 2,
+        'CardHolderInitiated' => 3,
+        'CredentialOnFile' => 4
+      }
+
+      REVERSAL_TYPE = {
+        'System' => 0,
+        'Full' => 1,
+        'Partial' => 2
+      }
+
+      SUBMISSION_TYPE = {
+        'NotUsed' => 0,
+        'Initial' => 1,
+        'Subsequent' => 2,
+        'Resubmission' => 3,
+        'ReAuthorization' => 4,
+        'DelayedCharges' => 5,
+        'NoShow' => 6
+      }
+
+      LODGING_PPC = {
+        'NonParticipant' => 0,
+        'DollarLimit500' => 1,
+        'DollarLimit1000' => 2,
+        'DollarLimit1500' => 3
+      }
+
+      LODGING_SPC = {
+        'Default' => 0,
+        'Sale' => 1,
+        'NoShow' => 2,
+        'AdvanceDeposit' => 3
+      }
+
+      LODGING_CHARGE_TYPE = {
+        'Default' => 0,
+        'Restaurant' => 1,
+        'GiftShop' => 2
+      }
+
+      TERMINAL_TYPE = {
+        'Unknown' => 0,
+        'PointOfSale' => 1,
+        'ECommerce' => 2,
+        'MOTO' => 3,
+        'FuelPump' => 4,
+        'ATM' => 5,
+        'Voice' => 6,
+        'Mobile' => 7,
+        'WebSiteGiftCard' => 8
+      }
+
+      CARD_HOLDER_PRESENT_CODE = {
+        'Default' => 0,
+        'Unknown' => 1,
+        'Present' => 2,
+        'NotPresent' => 3,
+        'MailOrder' => 4,
+        'PhoneOrder' => 5,
+        'StandingAuth' => 6,
+        'ECommerce' => 7
+      }
+
+      CARD_INPUT_CODE = {
+        'Default' => 0,
+        'Unknown' => 1,
+        'MagstripeRead' => 2,
+        'ContactlessMagstripeRead' => 3,
+        'ManualKeyed' => 4,
+        'ManualKeyedMagstripeFailure' => 5,
+        'ChipRead' => 6,
+        'ContactlessChipRead' => 7,
+        'ManualKeyedChipReadFailure' => 8,
+        'MagstripeReadChipReadFailure' => 9,
+        'MagstripeReadNonTechnicalFallback' => 10
+      }
+
+      CVV_PRESENCE_CODE = {
+        'UseDefault' => 0,
+        'NotProvided' => 1,
+        'Provided' => 2,
+        'Illegible' => 3,
+        'CustomerIllegible' => 4
+      }
+
+      TERMINAL_CAPABILITY_CODE = {
+        'Default' => 0,
+        'Unknown' => 1,
+        'NoTerminal' => 2,
+        'MagstripeReader' => 3,
+        'ContactlessMagstripeReader' => 4,
+        'KeyEntered' => 5,
+        'ChipReader' => 6,
+        'ContactlessChipReader' => 7
+      }
+
+      TERMINAL_ENVIRONMENT_CODE = {
+        'Default' => 0,
+        'NoTerminal' => 1,
+        'LocalAttended' => 2,
+        'LocalUnattended' => 3,
+        'RemoteAttended' => 4,
+        'RemoteUnattended' => 5,
+        'ECommerce' => 6
+      }
+
+      def initialize(options = {})
+        requires!(options, :account_id, :account_token, :application_id, :acceptor_id, :application_name, :application_version)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        action = payment.is_a?(Check) ? 'CheckSale' : 'CreditCardSale'
+        eci = parse_eci(payment)
+
+        request = build_xml_request do |xml|
+          xml.send(action, xmlns: live_url) do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, money, options, eci)
+            add_terminal(xml, options, eci)
+            add_address(xml, options)
+            add_lodging(xml, options)
+          end
+        end
+
+        commit(request, money, payment)
+      end
+
+      def authorize(money, payment, options = {})
+        eci = parse_eci(payment)
+
+        request = build_xml_request do |xml|
+          xml.CreditCardAuthorization(xmlns: live_url) do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, money, options, eci)
+            add_terminal(xml, options, eci)
+            add_address(xml, options)
+            add_lodging(xml, options)
+          end
+        end
+
+        commit(request, money, payment)
+      end
+
+      def capture(money, authorization, options = {})
+        trans_id, _, eci = authorization.split('|')
+        options[:trans_id] = trans_id
+
+        request = build_xml_request do |xml|
+          xml.CreditCardAuthorizationCompletion(xmlns: live_url) do
+            add_credentials(xml)
+            add_transaction(xml, money, options, eci)
+            add_terminal(xml, options, eci)
+          end
+        end
+
+        commit(request, money)
+      end
+
+      def refund(money, authorization, options = {})
+        trans_id, _, eci = authorization.split('|')
+        options[:trans_id] = trans_id
+
+        request = build_xml_request do |xml|
+          xml.CreditCardReturn(xmlns: live_url) do
+            add_credentials(xml)
+            add_transaction(xml, money, options, eci)
+            add_terminal(xml, options, eci)
+          end
+        end
+
+        commit(request, money)
+      end
+
+      def credit(money, payment, options = {})
+        eci = parse_eci(payment)
+
+        request = build_xml_request do |xml|
+          xml.CreditCardCredit(xmlns: live_url) do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, money, options, eci)
+            add_terminal(xml, options, eci)
+          end
+        end
+
+        commit(request, money, payment)
+      end
+
+      def void(authorization, options = {})
+        trans_id, trans_amount, eci = authorization.split('|')
+        options.merge!({ trans_id: trans_id, trans_amount: trans_amount, reversal_type: 1 })
+
+        request = build_xml_request do |xml|
+          xml.CreditCardReversal(xmlns: live_url) do
+            add_credentials(xml)
+            add_transaction(xml, trans_amount, options, eci)
+            add_terminal(xml, options, eci)
+          end
+        end
+
+        commit(request, trans_amount)
+      end
+
+      def store(payment, options = {})
+        request = build_xml_request do |xml|
+          xml.PaymentAccountCreate(xmlns: SERVICE_LIVE_URL) do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_payment_account(xml, payment, options[:payment_account_reference_number] || SecureRandom.hex(20))
+            add_address(xml, options)
+          end
+        end
+
+        commit(request, payment, nil, :store)
+      end
+
+      def verify(payment, options = {})
+        eci = parse_eci(payment)
+
+        request = build_xml_request do |xml|
+          xml.CreditCardAVSOnly(xmlns: live_url) do
+            add_credentials(xml)
+            add_payment_method(xml, payment)
+            add_transaction(xml, 0, options, eci)
+            add_terminal(xml, options, eci)
+            add_address(xml, options)
+          end
+        end
+
+        commit(request)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<AccountToken>).+?(</AccountToken>))i, '\1[FILTERED]\2').
+          gsub(%r((<CardNumber>).+?(</CardNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<CVV>).+?(</CVV>))i, '\1[FILTERED]\2').
+          gsub(%r((<AccountNumber>).+?(</AccountNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<RoutingNumber>).+?(</RoutingNumber>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_credentials(xml)
+        xml.Credentials do
+          xml.AccountID @options[:account_id]
+          xml.AccountToken @options[:account_token]
+          xml.AcceptorID @options[:acceptor_id]
+        end
+        xml.Application do
+          xml.ApplicationID @options[:application_id]
+          xml.ApplicationName @options[:application_name]
+          xml.ApplicationVersion @options[:application_version]
+        end
+      end
+
+      def add_payment_method(xml, payment)
+        if payment.is_a?(String)
+          add_payment_account_id(xml, payment)
+        elsif payment.is_a?(Check)
+          add_echeck(xml, payment)
+        elsif payment.is_a?(NetworkTokenizationCreditCard)
+          add_network_tokenization_card(xml, payment)
+        else
+          add_credit_card(xml, payment)
+        end
+      end
+
+      def add_payment_account(xml, payment, payment_account_reference_number)
+        xml.PaymentAccount do
+          xml.PaymentAccountType payment_account_type(payment)
+          xml.PaymentAccountReferenceNumber payment_account_reference_number
+        end
+      end
+
+      def add_payment_account_id(xml, payment)
+        xml.PaymentAccount do
+          xml.PaymentAccountID payment
+        end
+      end
+
+      def add_transaction(xml, money, options = {}, network_token_eci = nil)
+        xml.Transaction do
+          xml.ReversalType REVERSAL_TYPE[options[:reversal_type]] || options[:reversal_type] if options[:reversal_type]
+          xml.TransactionID options[:trans_id] if options[:trans_id]
+          xml.TransactionAmount amount(money.to_i) if money
+          xml.MarketCode market_code(money, options, network_token_eci) if options[:market_code] || money
+          xml.ReferenceNumber options[:order_id].present? ? options[:order_id][0, 50] : SecureRandom.hex(20)
+          xml.TicketNumber options[:ticket_number] || rand(1..999999)
+          xml.MerchantSuppliedTransactionID options[:merchant_supplied_transaction_id] if options[:merchant_supplied_transaction_id]
+          xml.PaymentType PAYMENT_TYPE[options[:payment_type]] || options[:payment_type] if options[:payment_type]
+          xml.SubmissionType SUBMISSION_TYPE[options[:submission_type]] || options[:submission_type] if options[:submission_type]
+          xml.DuplicateCheckDisableFlag 1 if options[:duplicate_check_disable_flag].to_s == 'true' || options[:duplicate_override_flag].to_s == 'true'
+        end
+      end
+
+      def parse_eci(payment)
+        return nil unless payment.is_a?(NetworkTokenizationCreditCard)
+
+        if (eci = payment.eci)
+          eci = eci[0] == '0' ? eci.sub!(/^0/, '') : eci
+          return eci
+        else
+          payment.brand == 'american_express' ? '9' : '6'
+        end
+      end
+
+      def market_code(money, options, network_token_eci)
+        return 3 if network_token_eci
+
+        MARKET_CODE[options[:market_code]] || options[:market_code] || 0
+      end
+
+      def add_lodging(xml, options)
+        if options[:lodging]
+          lodging = parse_lodging(options[:lodging])
+          xml.ExtendedParameters do
+            xml.Lodging do
+              xml.LodgingAgreementNumber lodging[:agreement_number] if lodging[:agreement_number]
+              xml.LodgingCheckInDate lodging[:check_in_date] if lodging[:check_in_date]
+              xml.LodgingCheckOutDate lodging[:check_out_date] if lodging[:check_out_date]
+              xml.LodgingRoomAmount lodging[:room_amount] if lodging[:room_amount]
+              xml.LodgingRoomTax lodging[:room_tax] if lodging[:room_tax]
+              xml.LodgingNoShowIndicator lodging[:no_show_indicator] if lodging[:no_show_indicator]
+              xml.LodgingDuration lodging[:duration] if lodging[:duration]
+              xml.LodgingCustomerName lodging[:customer_name] if lodging[:customer_name]
+              xml.LodgingClientCode lodging[:client_code] if lodging[:client_code]
+              xml.LodgingExtraChargesDetail lodging[:extra_charges_detail] if lodging[:extra_charges_detail]
+              xml.LodgingExtraChargesAmounts lodging[:extra_charges_amounts] if lodging[:extra_charges_amounts]
+              xml.LodgingPrestigiousPropertyCode lodging[:prestigious_property_code] if lodging[:prestigious_property_code]
+              xml.LodgingSpecialProgramCode lodging[:special_program_code] if lodging[:special_program_code]
+              xml.LodgingChargeType lodging[:charge_type] if lodging[:charge_type]
+            end
+          end
+        end
+      end
+
+      def add_terminal(xml, options, network_token_eci = nil)
+        options = parse_terminal(options)
+
+        xml.Terminal do
+          xml.TerminalID options[:terminal_id] || '01'
+          xml.TerminalType options[:terminal_type] if options[:terminal_type]
+          xml.CardPresentCode options[:card_present_code] || 0
+          xml.CardholderPresentCode options[:card_holder_present_code] || 0
+          xml.CardInputCode options[:card_input_code] || 0
+          xml.CVVPresenceCode options[:cvv_presence_code] || 0
+          xml.TerminalCapabilityCode options[:terminal_capability_code] || 0
+          xml.TerminalEnvironmentCode options[:terminal_environment_code] || 0
+          xml.MotoECICode network_token_eci || 7
+          xml.PartialApprovedFlag options[:partial_approved_flag] if options[:partial_approved_flag]
+        end
+      end
+
+      def add_credit_card(xml, payment)
+        xml.Card do
+          xml.CardNumber payment.number
+          xml.ExpirationMonth format(payment.month, :two_digits)
+          xml.ExpirationYear format(payment.year, :two_digits)
+          xml.CardholderName "#{payment.first_name} #{payment.last_name}"
+          xml.CVV payment.verification_value
+        end
+      end
+
+      def add_echeck(xml, payment)
+        xml.DemandDepositAccount do
+          xml.AccountNumber payment.account_number
+          xml.RoutingNumber payment.routing_number
+          xml.DDAAccountType payment.account_type == 'checking' ? 0 : 1
+        end
+      end
+
+      def add_network_tokenization_card(xml, payment)
+        xml.Card do
+          xml.CardNumber payment.number
+          xml.ExpirationMonth format(payment.month, :two_digits)
+          xml.ExpirationYear format(payment.year, :two_digits)
+          xml.CardholderName "#{payment.first_name} #{payment.last_name}"
+          xml.Cryptogram payment.payment_cryptogram
+          xml.WalletType NETWORK_TOKEN_TYPE[payment.source]
+        end
+      end
+
+      def add_address(xml, options)
+        address = address = options[:billing_address] || options[:address]
+        shipping_address = options[:shipping_address]
+
+        if address || shipping_address
+          xml.Address do
+            if address
+              address[:email] ||= options[:email]
+
+              xml.BillingAddress1 address[:address1] if address[:address1]
+              xml.BillingAddress2 address[:address2] if address[:address2]
+              xml.BillingCity address[:city] if address[:city]
+              xml.BillingState address[:state] if address[:state]
+              xml.BillingZipcode address[:zip] if address[:zip]
+              xml.BillingEmail address[:email] if address[:email]
+              xml.BillingPhone address[:phone_number] if address[:phone_number]
+            end
+
+            if shipping_address
+              xml.ShippingAddress1 shipping_address[:address1] if shipping_address[:address1]
+              xml.ShippingAddress2 shipping_address[:address2] if shipping_address[:address2]
+              xml.ShippingCity shipping_address[:city] if shipping_address[:city]
+              xml.ShippingState shipping_address[:state] if shipping_address[:state]
+              xml.ShippingZipcode shipping_address[:zip] if shipping_address[:zip]
+              xml.ShippingEmail shipping_address[:email] if shipping_address[:email]
+              xml.ShippingPhone shipping_address[:phone_number] if shipping_address[:phone_number]
+            end
+          end
+        end
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.remove_namespaces!
+        root = doc.root.xpath('//response/*')
+
+        root = doc.root.xpath('//Response/*') if root.empty?
+
+        root.each do |node|
+          if node.elements.empty?
+            response[node.name.downcase] = node.text
+          else
+            node_name = node.name.downcase
+            response[node_name] = {}
+
+            node.elements.each do |childnode|
+              response[node_name][childnode.name.downcase] = childnode.text
+            end
+          end
+        end
+
+        response
+      end
+
+      def parse_lodging(lodging)
+        lodging[:prestigious_property_code] = LODGING_PPC[lodging[:prestigious_property_code]] || lodging[:prestigious_property_code] if lodging[:prestigious_property_code]
+        lodging[:special_program_code] = LODGING_SPC[lodging[:special_program_code]] || lodging[:special_program_code] if lodging[:special_program_code]
+        lodging[:charge_type] = LODGING_CHARGE_TYPE[lodging[:charge_type]] || lodging[:charge_type] if lodging[:charge_type]
+
+        lodging
+      end
+
+      def parse_terminal(options)
+        options[:terminal_type] = TERMINAL_TYPE[options[:terminal_type]] || options[:terminal_type]
+        options[:card_present_code] = CARD_PRESENT_CODE[options[:card_present_code]] || options[:card_present_code]
+        options[:card_holder_present_code] = CARD_HOLDER_PRESENT_CODE[options[:card_holder_present_code]] || options[:card_holder_present_code]
+        options[:card_input_code] = CARD_INPUT_CODE[options[:card_input_code]] || options[:card_input_code]
+        options[:cvv_presence_code] = CVV_PRESENCE_CODE[options[:cvv_presence_code]] || options[:cvv_presence_code]
+        options[:terminal_capability_code] = TERMINAL_CAPABILITY_CODE[options[:terminal_capability_code]] || options[:terminal_capability_code]
+        options[:terminal_environment_code] = TERMINAL_ENVIRONMENT_CODE[options[:terminal_environment_code]] || options[:terminal_environment_code]
+
+        options
+      end
+
+      def commit(xml, amount = nil, payment = nil, action = nil)
+        response = parse(ssl_post(url(action), xml, headers))
+        success = success_from(response)
+
+        Response.new(
+          success,
+          message_from(response),
+          response,
+          authorization: authorization_from(action, response, amount, payment),
+          avs_result: success ? avs_from(response) : nil,
+          cvv_result: success ? cvv_from(response) : nil,
+          test: test?
+        )
+      end
+
+      def authorization_from(action, response, amount, payment)
+        return response.dig('paymentaccount', 'paymentaccountid') if action == :store
+
+        if response['transaction']
+          authorization = "#{response.dig('transaction', 'transactionid')}|#{amount}"
+          authorization << "|#{parse_eci(payment)}" if parse_eci(payment)
+          authorization
+        end
+      end
+
+      def success_from(response)
+        response['expressresponsecode'] == '0'
+      end
+
+      def message_from(response)
+        response['expressresponsemessage']
+      end
+
+      def avs_from(response)
+        AVSResult.new(code: response['card']['avsresponsecode']) if response['card']
+      end
+
+      def cvv_from(response)
+        CVVResult.new(response['card']['cvvresponsecode']) if response['card']
+      end
+
+      def build_xml_request(&block)
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8', &block)
+
+        builder.to_xml
+      end
+
+      def payment_account_type(payment)
+        return 0 unless payment.is_a?(Check)
+
+        if payment.account_type == 'checking'
+          1
+        elsif payment.account_type == 'savings'
+          2
+        else
+          3
+        end
+      end
+
+      def url(action)
+        if action == :store
+          test? ? SERVICE_TEST_URL : SERVICE_LIVE_URL
+        else
+          test? ? test_url : live_url
+        end
+      end
+
+      def headers
+        {
+          'Content-Type' => 'text/xml'
+        }
+      end
+    end
+  end
+end

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

@@ -194,11 +194,15 @@ module ActiveMerchant #:nodoc:
 
         response = parse(ssl_post(self.live_url, post_data(trx_type, post)))
 
-        Response.new(response[:response].to_i == SUCCESS, message_from(response), response,
+        Response.new(
+          response[:response].to_i == SUCCESS,
+          message_from(response),
+          response,
           test: test?,
           authorization: response[:transactionid],
           avs_result: { code: response[:avsresponse] },
-          cvv_result: response[:cvvresponse])
+          cvv_result: response[:cvvresponse]
+        )
       end
 
       def message_from(response)

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

@@ -136,11 +136,15 @@ module ActiveMerchant #:nodoc:
 
         response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)))
 
-        Response.new(response['result'] == APPROVED, message_from(response), response,
+        Response.new(
+          response['result'] == APPROVED,
+          message_from(response),
+          response,
           test: @options[:test] || test?,
           authorization: authorization_from(response),
           avs_result: { code: response['avs_response'] },
-          cvv_result: response['cvv2_response'])
+          cvv_result: response['cvv2_response']
+        )
       end
 
       def authorization_from(response)

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

@@ -143,12 +143,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def generate_purchase_number_stamp
-        Time.now.to_f.to_s.delete('.')[1..10] + rand(99).to_s
+        rand(('9' * 12).to_i).to_s.center(12, rand(9).to_s)
       end
 
       def commit(action, params, options = {})
         raw_response = ssl_request(method(action), url(action, params, options), params.to_json, headers)
-        response = parse(raw_response)
+        response = parse(raw_response).merge('purchaseNumber' => params[:purchaseNumber])
       rescue ResponseError => e
         raw_response = e.response.body
         response_error(raw_response, options, action)

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

@@ -9,7 +9,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['PY']
       self.default_currency = 'PYG'
-      self.supported_cardtypes = %i[visa master]
+      self.supported_cardtypes = %i[visa master panal]
 
       self.homepage_url = 'https://comercios.bancard.com.py'
       self.display_name = 'vPOS'
@@ -137,7 +137,7 @@ module ActiveMerchant #:nodoc:
         card_number = payment.number
         cvv = payment.verification_value
 
-        payload = { card_number: card_number, 'cvv': cvv }.to_json
+        payload = { card_number: card_number, cvv: cvv }.to_json
 
         encryption_key = @encryption_key || OpenSSL::PKey::RSA.new(one_time_public_key)
 
@@ -158,10 +158,10 @@ module ActiveMerchant #:nodoc:
         url = build_request_url(action)
         begin
           response = parse(ssl_post(url, post_data(parameters)))
-        rescue ResponseError => response
+        rescue ResponseError => e
           # Errors are returned with helpful data,
           # but get filtered out by `ssl_post` because of their HTTP status.
-          response = parse(response.response.body)
+          response = parse(e.response.body)
         end
 
         Response.new(

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

@@ -179,11 +179,15 @@ module ActiveMerchant #:nodoc:
         message = response[:Message]
         authorization = response[:GuWID]
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test?,
           authorization: authorization,
           avs_result: { code: avs_code(response, options) },
-          cvv_result: response[:CVCResponseCode])
+          cvv_result: response[:CVCResponseCode]
+        )
       rescue ResponseError => e
         if e.response.code == '401'
           return Response.new(false, 'Invalid Login')
@@ -405,7 +409,7 @@ module ActiveMerchant #:nodoc:
         'N' => 'I', # CSC Match
         'U' => 'U', # Data Not Checked
         'Y' => 'D', # All Data Matched
-        'Z' => 'P', # CSC and Postcode Matched
+        'Z' => 'P' # CSC and Postcode Matched
       }
 
       # Amex have different AVS response codes to visa etc