activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,165 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NcrSecurePayGateway < Gateway
+      self.test_url = 'https://testbox.monetra.com:8665/'
+      self.live_url = 'https://portal.ncrsecurepay.com:8444/'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.ncrretailonline.com'
+      self.display_name = 'NCR Secure Pay'
+
+      def initialize(options={})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+
+        commit('preauth', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, money, options)
+
+        commit('preauthcomplete', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, money, options)
+
+        commit('credit', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        commit('void', post)
+      end
+
+      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) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.gsub(%r((<password>)[^<]*(</password>))i, '\1[FILTERED]\2').
+          gsub(%r((<account>)[^<]*(</account>))i, '\1[FILTERED]\2').
+          gsub(%r((<cv>)[^<]*(</cv>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_reference(post, reference)
+        post[:ttid] = reference
+      end
+
+      def add_address(post, payment, options)
+        address = options[:billing_address] || options[:address]
+        post[:zip] = address[:zip]
+        post[:street] = address[:address1]
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:descmerch] = options[:merchant] if options[:merchant]
+        post[:ordernum] = options[:order_id] if options[:order_id]
+        post[:comments] = options[:description] if options[:description]
+      end
+
+      def add_payment(post, payment)
+        post[:cardholdername] = payment.name
+        post[:account] = payment.number
+        post[:cv] = payment.verification_value
+        post[:expdate] = expdate(payment)
+      end
+
+      def parse(body)
+        doc = Nokogiri::XML(body)
+        doc.remove_namespaces!
+        response = doc.xpath('/MonetraResp/Resp')[0]
+        resp_params = {}
+
+        response.elements.each do |node|
+          resp_params[node.name.downcase.to_sym] = node.text
+        end
+        resp_params
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_post(url, request_body(action, parameters)))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response[:code] == 'AUTH'
+      end
+
+      def message_from(response)
+        response[:verbiage]
+      end
+
+      def authorization_from(response)
+        response[:ttid]
+      end
+
+      def request_body(action, parameters = {})
+        Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |xml|
+          xml.MonetraTrans do
+            xml.Trans(identifier: parameters.delete(:identifier) || '1') do
+              xml.username(options[:username])
+              xml.password(options[:password])
+              xml.action(action)
+              parameters.each do |name, value|
+                xml.send(name, value)
+              end
+            end
+          end
+        end.to_xml
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          response[:msoft_code] || response[:phard_code]
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module ActiveMerchant
     # response will contain a 'receipt' parameter
     # (response.params['receipt']) if a receipt was issued by the gateway.
     class NetRegistryGateway < Gateway
-      self.live_url = self.test_url = 'https://4tknox.au.com/cgi-bin/themerchant.au.com/ecom/external2.pl'
+      self.live_url = self.test_url = 'https://paygate.ssllock.net/external2.pl'
 
       FILTERED_PARAMS = [ 'card_no', 'card_expiry', 'receipt_array' ]
 
@@ -104,7 +104,7 @@ module ActiveMerchant
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
@@ -122,6 +122,7 @@ module ActiveMerchant
       end
 
       private
+
       def add_request_details(params, options)
         params['COMMENT'] = options[:description] unless options[:description].blank?
       end
@@ -130,7 +131,7 @@ module ActiveMerchant
       # format for a command.
       def expiry(credit_card)
         month = format(credit_card.month, :two_digits)
-        year  = format(credit_card.year , :two_digits)
+        year  = format(credit_card.year,  :two_digits)
         "#{month}/#{year}"
       end
 
@@ -141,7 +142,7 @@ module ActiveMerchant
       # omitted if nil.
       def commit(action, params)
         # get gateway response
-        response = parse( ssl_post(self.live_url, post_data(action, params)) )
+        response = parse(ssl_post(self.live_url, post_data(action, params)))
 
         Response.new(response['status'] == 'approved', message_from(response), response,
           :authorization => authorization_from(response, action)
@@ -151,7 +152,12 @@ module ActiveMerchant
       def post_data(action, params)
         params['COMMAND'] = TRANSACTIONS[action]
         params['LOGIN'] = "#{@options[:login]}/#{@options[:password]}"
-        URI.encode(params.map{|k,v| "#{k}=#{v}"}.join('&'))
+        escape_uri(params.map { |k, v| "#{k}=#{v}" }.join('&'))
+      end
+
+      # The upstream is picky and so we can't use CGI.escape like we want to
+      def escape_uri(uri)
+        URI::DEFAULT_PARSER.escape(uri)
       end
 
       def parse(response)

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

@@ -31,8 +31,8 @@ module ActiveMerchant #:nodoc:
         requires!(options, :order_id)
 
         MultiResponse.run do |r|
-          r.process{authorize(money, creditcard, options)}
-          r.process{capture(money, r.authorization, options)}
+          r.process { authorize(money, creditcard, options) }
+          r.process { capture(money, r.authorization, options) }
         end
       end
 
@@ -40,9 +40,9 @@ module ActiveMerchant #:nodoc:
         requires!(options, :order_id)
 
         MultiResponse.run do |r|
-          r.process{setup_transaction(money, options)}
-          r.process{add_and_auth_credit_card(r.authorization, creditcard, options)}
-          r.process{query_transaction(r.authorization, options)}
+          r.process { setup_transaction(money, options) }
+          r.process { add_and_auth_credit_card(r.authorization, creditcard, options) }
+          r.process { query_transaction(r.authorization, options) }
         end
       end
 
@@ -50,24 +50,24 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization, money)
-        post[:operation] = "Capture"
-        commit("Netaxept/process.aspx", post)
+        post[:operation] = 'Capture'
+        commit('Netaxept/process.aspx', post)
       end
 
       def refund(money, authorization, options = {})
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization, money)
-        post[:operation] = "Credit"
-        commit("Netaxept/process.aspx", post)
+        post[:operation] = 'Credit'
+        commit('Netaxept/process.aspx', post)
       end
 
       def void(authorization, options = {})
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization)
-        post[:operation] = "Annul"
-        commit("Netaxept/process.aspx", post)
+        post[:operation] = 'Annul'
+        commit('Netaxept/process.aspx', post)
       end
 
       private
@@ -76,7 +76,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_credentials(post, options)
         add_order(post, money, options)
-        commit("Netaxept/Register.aspx", post)
+        commit('Netaxept/Register.aspx', post)
       end
 
       def add_and_auth_credit_card(authorization, creditcard, options)
@@ -84,14 +84,14 @@ module ActiveMerchant #:nodoc:
         add_credentials(post, options, false)
         add_authorization(post, authorization)
         add_creditcard(post, creditcard)
-        commit("terminal/default.aspx", post, false)
+        commit('terminal/default.aspx', post, false)
       end
 
       def query_transaction(authorization, options)
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization)
-        commit("Netaxept/query.aspx", post)
+        commit('Netaxept/query.aspx', post)
       end
 
       def add_credentials(post, options, secure=true)
@@ -109,7 +109,7 @@ module ActiveMerchant #:nodoc:
         post[:orderNumber] = options[:order_id]
         post[:amount] = amount(money)
         post[:currencyCode] = (options[:currency] || currency(money))
-        post[:autoAuth] = "true"
+        post[:autoAuth] = 'true'
       end
 
       def add_creditcard(post, options)
@@ -122,13 +122,13 @@ module ActiveMerchant #:nodoc:
         raw = parse(ssl_get(build_url(path, parameters)), xml)
 
         success = false
-        authorization = (raw["TransactionId"] || parameters[:transactionId])
+        authorization = (raw['TransactionId'] || parameters[:transactionId])
         if raw[:container] =~ /Exception|Error/
-          message = (raw["Message"] || raw["Error"]["Message"])
-        elsif raw["Error"] && !raw["Error"].empty?
-          message = (raw["Error"]["ResponseText"] || raw["Error"]["ResponseCode"])
+          message = (raw['Message'] || raw['Error']['Message'])
+        elsif raw['Error'] && !raw['Error'].empty?
+          message = (raw['Error']['ResponseText'] || raw['Error']['ResponseCode'])
         else
-          message = (raw["ResponseText"] || raw["ResponseCode"] || "OK")
+          message = (raw['ResponseText'] || raw['ResponseCode'] || 'OK')
           success = true
         end
 
@@ -173,9 +173,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def encode(hash)
-        hash.collect{|(k,v)| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join('&')
+        hash.collect { |(k, v)| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
       end
     end
   end
 end
-

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

@@ -0,0 +1,290 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetbanxGateway < Gateway
+      # Netbanx is the new REST based API for Optimal Payments / Paysafe
+      self.test_url = 'https://api.test.netbanx.com/'
+      self.live_url = 'https://api.netbanx.com/'
+
+      self.supported_countries = %w(AF AX AL DZ AS AD AO AI AQ AG AR AM AW AU AT AZ BS BH BD BB BY BE BZ BJ BM BT BO BQ BA BW BV BR IO BN BG BF BI KH CM CA CV KY CF TD CL CN CX CC CO KM CG CD CK CR CI HR CU CW CY CZ DK DJ DM DO EC EG SV GQ ER EE ET FK FO FJ FI FR GF PF TF GA GM GE DE GH GI GR GL GD GP GU GT GG GN GW GY HT HM HN HK HU IS IN ID IR IQ IE IM IL IT JM JP JE JO KZ KE KI KP KR KW KG LA LV LB LS LR LY LI LT LU MO MK MG MW MY MV ML MT MH MQ MR MU YT MX FM MD MC MN ME MS MA MZ MM NA NR NP NC NZ NI NE NG NU NF MP NO OM PK PW PS PA PG PY PE PH PN PL PT PR QA RE RO RU RW BL SH KN LC MF VC WS SM ST SA SN RS SC SL SG SX SK SI SB SO ZA GS SS ES LK PM SD SR SJ SZ SE CH SY TW TJ TZ TH NL TL TG TK TO TT TN TR TM TC TV UG UA AE GB US UM UY UZ VU VA VE VN VG VI WF EH YE ZM ZW)
+      self.default_currency = 'CAD'
+      self.supported_cardtypes = [
+        :american_express,
+        :diners_club,
+        :discover,
+        :jcb,
+        :master,
+        :maestro,
+        :visa
+      ]
+
+      self.money_format = :cents
+
+      self.homepage_url = 'https://processing.paysafe.com/'
+      self.display_name = 'Netbanx by PaySafe'
+
+      def initialize(options={})
+        requires!(options, :account_number, :api_key)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_settle_with_auth(post)
+        add_payment(post, payment, options)
+
+        commit(:post, 'auths', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment, options)
+
+        commit(:post, 'auths', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_invoice(post, money, options)
+
+        commit(:post, "auths/#{authorization}/settlements", post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_invoice(post, money, options)
+
+        commit(:post, "settlements/#{authorization}/refunds", post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_order_id(post, options)
+
+        commit(:post, "auths/#{authorization}/voidauths", post)
+      end
+
+      def verify(credit_card, options={})
+        post = {}
+        add_payment(post, credit_card)
+        add_order_id(post, options)
+
+        commit(:post, 'verifications', post)
+      end
+
+      # note: when passing options[:customer] we only attempt to add the
+      #       card to the profile_id passed as the options[:customer]
+      def store(credit_card, options={})
+        # locale can only be one of en_US, fr_CA, en_GB
+        requires!(options, :locale)
+        post = {}
+        add_credit_card(post, credit_card, options)
+        add_customer_data(post, options)
+
+        commit(:post, 'customervault/v1/profiles', post)
+      end
+
+      def unstore(identification, options = {})
+        customer_id, card_id = identification.split('|')
+
+        if card_id.nil?
+          # deleting the profile
+          commit(:delete, "customervault/v1/profiles/#{CGI.escape(customer_id)}", nil)
+        else
+          # deleting the card from the profile
+          commit(:delete, "customervault/v1/profiles/#{CGI.escape(customer_id)}/cards/#{CGI.escape(card_id)}", nil)
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r(("card\\?":{\\?"cardNum\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_settle_with_auth(post)
+        post[:settleWithAuth] = true
+      end
+
+      def add_customer_data(post, options)
+        post[:merchantCustomerId] = (options[:merchant_customer_id] || SecureRandom.uuid)
+        post[:locale] = options[:locale]
+      end
+
+      def add_credit_card(post, credit_card, options = {})
+        post[:card] ||= {}
+        post[:card][:cardNum]    = credit_card.number
+        post[:card][:holderName] = credit_card.name
+        post[:card][:cvv]        = credit_card.verification_value
+        post[:card][:cardExpiry] = expdate(credit_card)
+        if options[:billing_address]
+          post[:card][:billingAddress]  = map_address(options[:billing_address])
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        add_order_id(post, options)
+      end
+
+      def add_payment(post, credit_card_or_reference, options = {})
+        post[:card] ||= {}
+        if credit_card_or_reference.is_a?(String)
+          post[:card][:paymentToken] = credit_card_or_reference
+        else
+          post[:card][:cardNum]    = credit_card_or_reference.number
+          post[:card][:cvv]        = credit_card_or_reference.verification_value
+          post[:card][:cardExpiry] = expdate(credit_card_or_reference)
+        end
+
+        post[:currencyCode] = options[:currency] if options[:currency]
+        post[:billingDetails]  = map_address(options[:billing_address]) if options[:billing_address]
+      end
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :four_digits)
+        month = format(credit_card.month, :two_digits)
+
+        # returns a hash (necessary in the card JSON object)
+        { :month => month, :year => year }
+      end
+
+      def add_order_id(post, options)
+        post[:merchantRefNum] = (options[:order_id] || SecureRandom.uuid)
+      end
+
+      def map_address(address)
+        return {} if address.nil?
+        country = Country.find(address[:country]) if address[:country]
+        mapped = {
+          :street => address[:address1],
+          :city   => address[:city],
+          :zip    => address[:zip],
+          :state  => address[:state],
+        }
+        mapped[:country] = country.code(:alpha2).value unless country.blank?
+
+        mapped
+      end
+
+      def parse(body)
+        body.blank? ? {} : JSON.parse(body)
+      end
+
+      def commit(method, uri, parameters)
+        params = parameters.to_json unless parameters.nil?
+        response = begin
+          parse(ssl_request(method, get_url(uri), params, headers))
+        rescue ResponseError => e
+          return Response.new(false, 'Invalid Login') if(e.response.code == '401')
+          parse(e.response.body)
+        end
+
+        success = success_from(response)
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          :test => test?,
+          :error_code => error_code_from(response),
+          :authorization => authorization_from(success, get_url(uri), method, response)
+        )
+      end
+
+      def get_url(uri)
+        url = (test? ? test_url : live_url)
+        if uri =~ /^customervault/
+          "#{url}#{uri}"
+        else
+          "#{url}cardpayments/v1/accounts/#{@options[:account_number]}/#{uri}"
+        end
+      end
+
+      def success_from(response)
+        response.blank? || !response.key?('error')
+      end
+
+      def message_from(success, response)
+        success ? 'OK' : (response['error']['message'] || 'Unknown error - please contact Netbanx-Paysafe')
+      end
+
+      def authorization_from(success, url, method, response)
+        if success && response.present? && url.match(/cardpayments\/v1\/accounts\/.*\//)
+          response['id']
+        elsif method == :post && url.match(/customervault\/.*\//)
+          # auth for tokenised customer vault is returned as
+          # customer_profile_id|card_id|payment_method_token
+          #
+          # customer_profile_id is the uuid that identifies the customer
+          # card_id is the uuid that identifies the card
+          # payment_method_token is the token that needs to be used when
+          #                      calling purchase with a token
+          #
+          # both id's are used to unstore, the payment token is only used for
+          # purchase transactions
+          [response['id'], response['cards'].first['id'], response['cards'].first['paymentToken']].join('|')
+        end
+      end
+
+      # Builds the auth and U-A headers for the request
+      def headers
+        {
+          'Accept'        => 'application/json',
+          'Content-type'  => 'application/json',
+          'Authorization' => "Basic #{Base64.strict_encode64(@options[:api_key].to_s)}",
+          'User-Agent'    => "Netbanx-Paysafe v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
+        }
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          case response['errorCode']
+          when '3002' then STANDARD_ERROR_CODE[:invalid_number] # You submitted an invalid card number or brand or combination of card number and brand with your request.
+          when '3004' then STANDARD_ERROR_CODE[:incorrect_zip] # The zip/postal code must be provided for an AVS check request.
+          when '3005' then STANDARD_ERROR_CODE[:incorrect_cvc] # You submitted an incorrect CVC value with your request.
+          when '3006' then STANDARD_ERROR_CODE[:expired_card] # You submitted an expired credit card number with your request.
+          when '3009' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined by the issuing bank.
+          when '3011' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined by the issuing bank because the card used is a restricted card. Contact the cardholder's credit card company for further investigation.
+          when '3012' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined by the issuing bank because the credit card expiry date submitted is invalid.
+          when '3013' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined by the issuing bank due to problems with the credit card account.
+          when '3014' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined - the issuing bank has returned an unknown response. Contact the card holder's credit card company for further investigation.
+          when '3015' then STANDARD_ERROR_CODE[:card_declined] # The bank has requested that you process the transaction manually by calling the cardholder's credit card company.
+          when '3016' then STANDARD_ERROR_CODE[:card_declined] # The bank has requested that you retrieve the card from the cardholder – it may be a lost or stolen card.
+          when '3017' then STANDARD_ERROR_CODE[:invalid_number] # You submitted an invalid credit card number with your request.
+          when '3022' then STANDARD_ERROR_CODE[:card_declined] # The card has been declined due to insufficient funds.
+          when '3023' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined by the issuing bank due to its proprietary card activity regulations.
+          when '3024' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined because the issuing bank does not permit the transaction for this card.
+          when '3032' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined by the issuing bank or external gateway because the card is probably in one of their negative databases.
+          when '3035' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined due to exceeded PIN attempts.
+          when '3036' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined due to an invalid issuer.
+          when '3037' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined because it is invalid.
+          when '3038' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined due to customer cancellation.
+          when '3039' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined due to an invalid authentication value.
+          when '3040' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined because the request type is not permitted on the card.
+          when '3041' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined due to a timeout.
+          when '3042' then STANDARD_ERROR_CODE[:card_declined] # Your request has been declined due to a cryptographic error.
+          when '3045' then STANDARD_ERROR_CODE[:invalid_expiry_date] # You submitted an invalid date format for this request.
+          when '3046' then STANDARD_ERROR_CODE[:card_declined] # The transaction was declined because the amount was set to zero.
+          when '3047' then STANDARD_ERROR_CODE[:card_declined] # The transaction was declined because the amount exceeds the floor limit.
+          when '3048' then STANDARD_ERROR_CODE[:card_declined] # The transaction was declined because the amount is less than the floor limit.
+          when '3049' then STANDARD_ERROR_CODE[:card_declined] # The bank has requested that you retrieve the card from the cardholder – the credit card has expired.
+          when '3050' then STANDARD_ERROR_CODE[:card_declined] # The bank has requested that you retrieve the card from the cardholder – fraudulent activity is suspected.
+          when '3051' then STANDARD_ERROR_CODE[:card_declined] # The bank has requested that you retrieve the card from the cardholder – contact the acquirer for more information.
+          when '3052' then STANDARD_ERROR_CODE[:card_declined] # The bank has requested that you retrieve the card from the cardholder – the credit card is restricted.
+          when '3053' then STANDARD_ERROR_CODE[:card_declined] # The bank has requested that you retrieve the card from the cardholder – please call the acquirer.
+          when '3054' then STANDARD_ERROR_CODE[:card_declined] # The transaction was declined due to suspected fraud.
+          else STANDARD_ERROR_CODE[:processing_error]
+          end
+        end
+      end
+    end
+  end
+end