activemerchant 1.38.0 → 1.79.2

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

@@ -1,176 +1,162 @@
+require 'nokogiri'
+
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class FirstPayGateway < Gateway
-      class FirstPayPostData < PostData
-        # Fields that will be sent even if they are blank
-        self.required_fields = [ :action, :amount, :trackid ]
-      end
+      self.live_url = 'https://secure.goemerchant.com/secure/gateway/xmlgateway.aspx'
 
-      # both URLs are IP restricted
-      self.test_url = 'https://apgcert.first-pay.com/AcqENGIN/SecureCapture'
-      self.live_url = 'https://acqengin.first-pay.com/AcqENGIN/SecureCapture'
-
-      # The countries the gateway supports merchants from as 2 digit ISO country codes
       self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
 
-      # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master]
-
-      # The homepage URL of the gateway
-      self.homepage_url = 'http://www.first-pay.com'
-
-      # The name of the gateway
-      self.display_name = 'First Pay'
-
-      # all transactions are in cents
-      self.money_format = :cents
-
-      ACTIONS = {
-        'sale' => 1,
-        'credit' => 2,
-        'void' => 3
-      }
+      self.homepage_url = 'http://1stpaygateway.net/'
+      self.display_name = '1stPayGateway.Net'
 
-      def initialize(options = {})
-        requires!(options, :login, :password)
+      def initialize(options={})
+        requires!(options, :transaction_center_id, :gateway_id)
         super
       end
 
-      def purchase(money, creditcard, options = {})
-        post = FirstPayPostData.new
-        add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, options)
+      def purchase(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
         add_customer_data(post, options)
 
-        commit('sale', money, post)
+        commit('sale', post)
       end
 
-      def refund(money, reference, options = {})
-        requires!(options, :credit_card)
-
-        post = FirstPayPostData.new
-        add_invoice(post, options)
-        add_creditcard(post, options[:credit_card])
-        add_address(post, options)
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
         add_customer_data(post, options)
-        add_credit_data(post, reference)
 
-        commit('credit', money, post)
+        commit('auth', post)
       end
 
-      def credit(money, reference, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
-        refund(money, reference, options)
+      def capture(money, authorization, options={})
+        post = {}
+        add_reference(post, 'settle', money, authorization)
+        commit('settle', post)
       end
 
-      def void(money, creditcard, options = {})
-        post = FirstPayPostData.new
-        add_creditcard(post, creditcard)
-        add_void_data(post, options)
-        add_invoice(post, options)
-        add_customer_data(post, options)
-
-        commit('void', money, post)
+      def refund(money, authorization, options={})
+        post = {}
+        add_reference(post, 'credit', money, authorization)
+        commit('credit', post)
       end
 
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, 'void', nil, authorization)
+        commit('void', post)
+      end
 
       private
 
-      def add_customer_data(post, options)
-        post[:cardip] = options[:ip]
-        post[:email] = options[:email]
+      def add_authentication(post, options)
+        post[:transaction_center_id] = options[:transaction_center_id]
+        post[:gateway_id] = options[:gateway_id]
       end
 
-      def add_address(post, options)
-        if billing_address = options[:billing_address] || options[:address]
-          post[:addr]     = billing_address[:address1].to_s + ' ' + billing_address[:address2].to_s
-          post[:city]     = billing_address[:city]
-          post[:state]    = billing_address[:state]
-          post[:zip]      = billing_address[:zip]
-          post[:country]  = billing_address[:country]
+      def add_customer_data(post, options)
+        post[:owner_email] = options[:email] if options[:email]
+        post[:remote_ip_address] = options[:ip] if options[:ip]
+        post[:processor_id] = options[:processor_id] if options[:processor_id]
+      end
+
+      def add_address(post, creditcard, options)
+        if address = options[:billing_address] || options[:address]
+          post[:owner_name] = address[:name]
+          post[:owner_street] = address[:address1]
+          post[:owner_street2] = address[:address2] if address[:address2]
+          post[:owner_city] = address[:city]
+          post[:owner_state] = address[:state]
+          post[:owner_zip] = address[:zip]
+          post[:owner_country] = address[:country]
+          post[:owner_phone] = address[:phone] if address[:phone]
         end
       end
 
-      def add_invoice(post, options)
-        post[:trackid] = rand(Time.now.to_i)
+      def add_invoice(post, money, options)
+        post[:order_id] = options[:order_id]
+        post[:total] = amount(money)
       end
 
-      def add_creditcard(post, creditcard)
-        post[:member] = creditcard.first_name.to_s + " " + creditcard.last_name.to_s
-        post[:card] = creditcard.number
-        post[:exp] = expdate(creditcard)
+      def add_payment(post, payment)
+        post[:card_name] = payment.brand # Unclear if need to map to known names or open text field??
+        post[:card_number] = payment.number
+        post[:card_exp] = expdate(payment)
+        post[:cvv2] = payment.verification_value
       end
 
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
+      def add_reference(post, action, money, authorization)
+        post[:"#{action}_amount1"] = amount(money) if money
+        post[:total_number_transactions] = 1
+        post[:reference_number1] = authorization
       end
 
-      def add_credit_data(post, transaction_id)
-        post[:transid] = transaction_id
-      end
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath("//RESPONSE/FIELDS/FIELD").each do |field|
+          response[field['KEY']] = field.text
+        end unless doc.root.nil?
 
-      def add_void_data(post, options)
-        post[:transid] = options[:transactionid]
+        response
       end
 
-      def commit(action, money, post)
-        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(action, post, money)) )
+      def commit(action, parameters)
+        response = parse(ssl_post(live_url, post_data(action, parameters)))
 
-        Response.new(response[:response] == 'CAPTURED', response[:message], response,
-          :test => test?,
-          :authorization => response[:authorization],
-          :avs_result => { :code => response[:avsresponse] },
-          :cvv_result => response[:cvvresponse])
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?
+        )
       end
 
-      def parse(body)
-        response = {}
-
-        # check for an error first
-        if body.include?('!ERROR!')
-          response[:response] = 'ERROR'
-          response[:message] = error_message_from(body)
-        else
-          # a capture / not captured response will be : delimited
-          split = body.split(':')
-          response[:response] = split[0]
-
-          # FirstPay docs are worthless. turns out the transactionid is required for credits
-          # so we need to store that in authorization, not the actual auth.
-          if response[:response] == 'CAPTURED'
-            response[:message] = 'CAPTURED'
-            response[:authorization] = split[9] # actually the transactionid
-            response[:auth] = split[1]
-            response[:avsresponse] = split[3]
-            response[:cvvresponse] = split[17]
-          else
-            # NOT CAPTURED response
-            response[:message] = split[1]
-            response[:transactionid] = split[9]
-          end
-        end
+      def success_from(response)
+        (
+          (response['status'] == '1') ||
+          (response['status1'] == '1')
+        )
+      end
 
-        return response
+      def message_from(response)
+        # Silly inconsistent gateway. Always make capitalized (but not all caps)
+        msg = (response['auth_response'] || response['response1'])
+        msg.downcase.capitalize if msg
       end
 
-      def error_message_from(response)
-        # error messages use this format - '!ERROR! 704-MISSING BASIC DATA TYPE:card, exp, zip, addr, member, amount\n'
-        response.split("! ")[1].chomp
+      def authorization_from(response)
+        response['reference_number'] || response['reference_number1']
       end
 
-      def post_data(action, post, money)
-        post[:vid]        = @options[:login]
-        post[:password]   = @options[:password]
-        post[:action]     = ACTIONS[action]
-        post[:amount]     = amount(money)
+      def post_data(action, parameters = {})
+        parameters[:transaction_center_id] = @options[:transaction_center_id]
+        parameters[:gateway_id] = @options[:gateway_id]
+
+        parameters[:operation_type] = action
 
-        return post.to_post_data
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        xml.tag! 'TRANSACTION' do
+          xml.tag! 'FIELDS' do
+            parameters.each do |key, value|
+              xml.tag! 'FIELD', value, { 'KEY' => key }
+            end
+          end
+        end
+        xml.target!
       end
     end
   end
 end
-

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

@@ -6,12 +6,13 @@ module ActiveMerchant #:nodoc:
       self.live_url = "https://api.globalgatewaye4.firstdata.com/transaction/v11"
 
       TRANSACTIONS = {
-        :sale          => "00",
-        :authorization => "01",
-        :capture       => "32",
-        :void          => "33",
-        :credit        => "34",
-        :store         => "05"
+        sale:          "00",
+        authorization: "01",
+        verify:        "05",
+        capture:       "32",
+        void:          "33",
+        credit:        "34",
+        store:         "05"
       }
 
       POST_HEADERS = {
@@ -23,12 +24,45 @@ module ActiveMerchant #:nodoc:
 
       SENSITIVE_FIELDS = [:verification_str2, :expiry_date, :card_number]
 
-      self.supported_cardtypes = [:visa, :master, :american_express, :jcb, :discover]
+      BRANDS = {
+        :visa => 'Visa',
+        :master => "Mastercard",
+        :american_express => "American Express",
+        :jcb => "JCB",
+        :discover => "Discover"
+      }
+
+      E4_BRANDS = BRANDS.merge({:mastercard => "Mastercard"})
+
+      DEFAULT_ECI = "07"
+
+      self.supported_cardtypes = BRANDS.keys
       self.supported_countries = ["CA", "US"]
       self.default_currency = "USD"
       self.homepage_url = "http://www.firstdata.com"
       self.display_name = "FirstData Global Gateway e4"
 
+      STANDARD_ERROR_CODE_MAPPING = {
+      # Bank error codes: https://firstdata.zendesk.com/entries/471297-First-Data-Global-Gateway-e4-Bank-Response-Codes
+        '201' => STANDARD_ERROR_CODE[:incorrect_number],
+        '531' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '503' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '811' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '605' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '522' => STANDARD_ERROR_CODE[:expired_card],
+        '303' => STANDARD_ERROR_CODE[:card_declined],
+        '530' => STANDARD_ERROR_CODE[:card_declined],
+        '401' => STANDARD_ERROR_CODE[:call_issuer],
+        '402' => STANDARD_ERROR_CODE[:call_issuer],
+        '501' => STANDARD_ERROR_CODE[:pickup_card],
+      # Ecommerce error codes -- https://firstdata.zendesk.com/entries/451980-ecommerce-response-codes-etg-codes
+        '22' => STANDARD_ERROR_CODE[:invalid_number],
+        '25' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '31' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        '44' => STANDARD_ERROR_CODE[:incorrect_zip],
+        '42' => STANDARD_ERROR_CODE[:processing_error]
+      }
+
       # Create a new FirstdataE4Gateway
       #
       # The gateway requires that a valid login and password be passed
@@ -66,6 +100,10 @@ module ActiveMerchant #:nodoc:
         commit(:credit, build_capture_or_credit_request(money, authorization, options))
       end
 
+      def verify(credit_card, options = {})
+        commit(:verify, build_sale_or_authorization_request(0, credit_card, options))
+      end
+
       # Tokenize a credit card with TransArmor
       #
       # The TransArmor token and other card data necessary for subsequent
@@ -93,13 +131,35 @@ module ActiveMerchant #:nodoc:
         commit(:store, build_store_request(credit_card, options), credit_card)
       end
 
+      def verify_credentials
+        response = void("0")
+        response.message != "Unauthorized Request. Bad or missing credentials."
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript
+          .gsub(%r((<Card_Number>).+(</Card_Number>)), '\1[FILTERED]\2')
+          .gsub(%r((<VerificationStr2>).+(</VerificationStr2>)), '\1[FILTERED]\2')
+          .gsub(%r((<Password>).+(</Password>))i, '\1[FILTERED]\2')
+          .gsub(%r((<CAVV>).+(</CAVV>)), '\1[FILTERED]\2')
+          .gsub(%r((Card Number : ).*\d)i, '\1[FILTERED]')
+      end
+
+      def supports_network_tokenization?
+        true
+      end
+
       private
 
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
 
         xml.instruct!
-        xml.tag! "Transaction" do
+        xml.tag! "Transaction", xmlns: "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/encodedTypes" do
           add_credentials(xml)
           add_transaction_type(xml, action)
           xml << body
@@ -111,16 +171,18 @@ module ActiveMerchant #:nodoc:
       def build_sale_or_authorization_request(money, credit_card_or_store_authorization, options)
         xml = Builder::XmlMarkup.new
 
-        add_amount(xml, money)
+        add_amount(xml, money, options)
 
         if credit_card_or_store_authorization.is_a? String
-          add_credit_card_token(xml, credit_card_or_store_authorization)
+          add_credit_card_token(xml, credit_card_or_store_authorization, options)
         else
           add_credit_card(xml, credit_card_or_store_authorization, options)
         end
 
         add_customer_data(xml, options)
         add_invoice(xml, options)
+        add_tax_fields(xml, options)
+        add_level_3(xml, options)
 
         xml.target!
       end
@@ -129,8 +191,9 @@ module ActiveMerchant #:nodoc:
         xml = Builder::XmlMarkup.new
 
         add_identification(xml, identification)
-        add_amount(xml, money)
+        add_amount(xml, money, options)
         add_customer_data(xml, options)
+        add_card_authentication_data(xml, options)
 
         xml.target!
       end
@@ -160,17 +223,38 @@ module ActiveMerchant #:nodoc:
         xml.tag! "Transaction_Tag", transaction_tag
       end
 
-      def add_amount(xml, money)
-        xml.tag! "DollarAmount", amount(money)
+      def add_amount(xml, money, options)
+        currency_code = options[:currency] || default_currency
+        xml.tag! 'DollarAmount', localized_amount(money, currency_code)
+        xml.tag! 'Currency', currency_code
       end
 
       def add_credit_card(xml, credit_card, options)
-        xml.tag! "Card_Number", credit_card.number
-        xml.tag! "Expiry_Date", expdate(credit_card)
-        xml.tag! "CardHoldersName", credit_card.name
-        xml.tag! "CardType", credit_card.brand
+        if credit_card.respond_to?(:track_data) && credit_card.track_data.present?
+          xml.tag! "Track1", credit_card.track_data
+          xml.tag! "Ecommerce_Flag", "R"
+        else
+          xml.tag! "Card_Number", credit_card.number
+          xml.tag! "Expiry_Date", expdate(credit_card)
+          xml.tag! "CardHoldersName", credit_card.name
+          xml.tag! "CardType", card_type(credit_card.brand)
+
+          add_credit_card_eci(xml, credit_card, options)
+          add_credit_card_verification_strings(xml, credit_card, options)
+        end
+      end
+
+      def add_credit_card_eci(xml, credit_card, options)
+        eci = if credit_card.is_a?(NetworkTokenizationCreditCard) && credit_card.source == :apple_pay && card_brand(credit_card) == "discover"
+          # Discover requires any Apple Pay transaction, regardless of in-app
+          # or web, and regardless of the ECI contained in the PKPaymentToken,
+          # to have an ECI value explicitly of 04.
+          "04"
+        else
+          (credit_card.respond_to?(:eci) ? credit_card.eci : nil) || options[:eci] || DEFAULT_ECI
+        end
 
-        add_credit_card_verification_strings(xml, credit_card, options)
+        xml.tag! "Ecommerce_Flag", eci.to_s =~ /^[0-9]+$/ ? eci.to_s.rjust(2, '0') : eci
       end
 
       def add_credit_card_verification_strings(xml, credit_card, options)
@@ -181,13 +265,36 @@ module ActiveMerchant #:nodoc:
           xml.tag! "VerificationStr1", address_values.join("|")
         end
 
-        if credit_card.verification_value?
-          xml.tag! "CVD_Presence_Ind", "1"
-          xml.tag! "VerificationStr2", credit_card.verification_value
+        if credit_card.is_a?(NetworkTokenizationCreditCard)
+          add_network_tokenization_credit_card(xml, credit_card)
+        else
+          if credit_card.verification_value?
+            xml.tag! "CVD_Presence_Ind", "1"
+            xml.tag! "VerificationStr2", credit_card.verification_value
+          end
+
+          add_card_authentication_data(xml, options)
         end
       end
 
-      def add_credit_card_token(xml, store_authorization)
+      def add_network_tokenization_credit_card(xml, credit_card)
+        case card_brand(credit_card).to_sym
+        when :american_express
+          cryptogram = Base64.decode64(credit_card.payment_cryptogram)
+          xml.tag!("XID", Base64.encode64(cryptogram[20...40]))
+          xml.tag!("CAVV", Base64.encode64(cryptogram[0...20]))
+        else
+          xml.tag!("XID", credit_card.transaction_id) if credit_card.transaction_id
+          xml.tag!("CAVV", credit_card.payment_cryptogram)
+        end
+      end
+
+      def add_card_authentication_data(xml, options)
+        xml.tag! "CAVV", options[:cavv]
+        xml.tag! "XID", options[:xid]
+      end
+
+      def add_credit_card_token(xml, store_authorization, options)
         params = store_authorization.split(";")
         credit_card = CreditCard.new(
           :brand      => params[1],
@@ -199,7 +306,8 @@ module ActiveMerchant #:nodoc:
         xml.tag! "TransarmorToken", params[0]
         xml.tag! "Expiry_Date", expdate(credit_card)
         xml.tag! "CardHoldersName", credit_card.name
-        xml.tag! "CardType", credit_card.brand
+        xml.tag! "CardType", card_type(credit_card.brand)
+        add_card_authentication_data(xml, options)
       end
 
       def add_customer_data(xml, options)
@@ -219,10 +327,23 @@ module ActiveMerchant #:nodoc:
         xml.tag! "Reference_3",  options[:description] if options[:description]
       end
 
+      def add_tax_fields(xml, options)
+        xml.tag! "Tax1Amount",  options[:tax1_amount] if options[:tax1_amount]
+        xml.tag! "Tax1Number",  options[:tax1_number] if options[:tax1_number]
+      end
+
+      def add_level_3(xml, options)
+        xml.tag!("Level3") { |x| x << options[:level_3] } if options[:level_3]
+      end
+
       def expdate(credit_card)
         "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
       end
 
+      def card_type(credit_card_brand)
+        E4_BRANDS[credit_card_brand.to_sym] if credit_card_brand
+      end
+
       def commit(action, request, credit_card = nil)
         url = (test? ? self.test_url : self.live_url)
         begin
@@ -233,9 +354,10 @@ module ActiveMerchant #:nodoc:
 
         Response.new(successful?(response), message_from(response), response,
           :test => test?,
-          :authorization => response_authorization(action, response, credit_card),
+          :authorization => successful?(response) ? response_authorization(action, response, credit_card) : '',
           :avs_result => {:code => response[:avs]},
-          :cvv_result => response[:cvv2]
+          :cvv_result => response[:cvv2],
+          :error_code => standard_error_code(response)
         )
       end
 
@@ -256,7 +378,7 @@ module ActiveMerchant #:nodoc:
           [
             response[:authorization_num],
             response[:transaction_tag],
-            (response[:dollar_amount].to_f * 100).to_i
+            (response[:dollar_amount].to_f * 100).round
           ].join(";")
         else
           ""
@@ -280,7 +402,7 @@ module ActiveMerchant #:nodoc:
 
       def money_from_authorization(auth)
         _, _, amount = auth.split(/;/, 3)
-        amount.to_i # return the # of cents, no need to divide
+        amount.to_i
       end
 
       def message_from(response)
@@ -299,10 +421,15 @@ module ActiveMerchant #:nodoc:
         {
           :transaction_approved => "false",
           :error_number => error.code,
-          :error_description => error.body
+          :error_description => error.body,
+          :ecommerce_error_code => error.body.gsub(/[^\d]/, '')
         }
       end
 
+      def standard_error_code(response)
+        STANDARD_ERROR_CODE_MAPPING[response[:bank_resp_code] || response[:ecommerce_error_code]]
+      end
+
       def parse(xml)
         response = {}
         xml = REXML::Document.new(xml)
@@ -322,4 +449,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-