activemerchant 1.62.0 → 1.79.2

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

@@ -2,43 +2,16 @@ require 'active_merchant/billing/gateways/viaklix'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    # = Elavon Virtual Merchant Gateway
-    #
-    # == Example use:
-    #
-    #   gateway = ActiveMerchant::Billing::ElavonGateway.new(
-    #               :login     => "my_virtual_merchant_id",
-    #               :password  => "my_virtual_merchant_pin",
-    #               :user      => "my_virtual_merchant_user_id" # optional
-    #            )
-    #
-    #   # set up credit card obj as in main ActiveMerchant example
-    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
-    #     :type       => 'visa',
-    #     :number     => '41111111111111111',
-    #     :month      => 10,
-    #     :year       => 2011,
-    #     :first_name => 'Bob',
-    #     :last_name  => 'Bobsen'
-    #   )
-    #
-    #   # run request
-    #   response = gateway.purchase(1000, creditcard) # authorize and capture 10 USD
-    #
-    #   puts response.success?      # Check whether the transaction was successful
-    #   puts response.message       # Retrieve the message returned by Elavon
-    #   puts response.authorization # Retrieve the unique transaction ID returned by Elavon
-    #
     class ElavonGateway < Gateway
       include Empty
 
       class_attribute :test_url, :live_url, :delimiter, :actions
 
-      self.test_url = 'https://demo.myvirtualmerchant.com/VirtualMerchantDemo/process.do'
-      self.live_url = 'https://www.myvirtualmerchant.com/VirtualMerchant/process.do'
+      self.test_url = 'https://api.demo.convergepay.com/VirtualMerchantDemo/process.do'
+      self.live_url = 'https://api.convergepay.com/VirtualMerchant/process.do'
 
       self.display_name = 'Elavon MyVirtualMerchant'
-      self.supported_countries = %w(US CA PR DE IE NO PL LU BE NL)
+      self.supported_countries = %w(US CA PR DE IE NO PL LU BE NL MX)
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.homepage_url = 'http://www.elavon.com/'
 
@@ -55,23 +28,11 @@ module ActiveMerchant #:nodoc:
         :update => 'CCUPDATETOKEN',
       }
 
-      # Initialize the Gateway
-      #
-      # The gateway requires that a valid login and password be passed
-      # in the +options+ hash.
-      #
-      # ==== Options
-      #
-      # * <tt>:login</tt> -- Merchant ID
-      # * <tt>:password</tt> -- PIN
-      # * <tt>:user</tt> -- Specify a subuser of the account (optional)
-      # * <tt>:test => +true+ or +false+</tt> -- Force test transactions
       def initialize(options = {})
         requires!(options, :login, :password)
         super
       end
 
-      # Make a purchase
       def purchase(money, payment_method, options = {})
         form = {}
         add_salestax(form, options)
@@ -85,16 +46,9 @@ module ActiveMerchant #:nodoc:
         add_customer_data(form, options)
         add_test_mode(form, options)
         add_ip(form, options)
-        commit(:purchase, money, form)
+        commit(:purchase, money, form, options)
       end
 
-      # Authorize a credit card for a given amount.
-      #
-      # ==== Parameters
-      # * <tt>money</tt> - The amount to be authorized as an Integer value in cents.
-      # * <tt>credit_card</tt> - The CreditCard details for the transaction.
-      # * <tt>options</tt>
-      #   * <tt>:billing_address</tt> - The billing address for the cardholder.
       def authorize(money, creditcard, options = {})
         form = {}
         add_salestax(form, options)
@@ -104,16 +58,9 @@ module ActiveMerchant #:nodoc:
         add_customer_data(form, options)
         add_test_mode(form, options)
         add_ip(form, options)
-        commit(:authorize, money, form)
+        commit(:authorize, money, form, options)
       end
 
-      # Capture authorized funds from a credit card.
-      #
-      # ==== Parameters
-      # * <tt>money</tt> - The amount to be captured as an Integer value in cents.
-      # * <tt>authorization</tt> - The approval code returned from the initial authorization.
-      # * <tt>options</tt>
-      #   * <tt>:credit_card</tt> - The CreditCard details from the initial transaction (required).
       def capture(money, authorization, options = {})
         form = {}
         if options[:credit_card]
@@ -130,45 +77,23 @@ module ActiveMerchant #:nodoc:
           add_partial_shipment_flag(form, options)
           add_test_mode(form, options)
         end
-        commit(action, money, form)
-      end
-
-      # Refund a transaction.
-      #
-      # This transaction indicates to the gateway that
-      # money should flow from the merchant to the customer.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be credited to the customer as an Integer value in cents.
-      # * <tt>identification</tt> -- The ID of the original transaction against which the refund is being issued.
-      # * <tt>options</tt> -- A hash of parameters.
+        commit(action, money, form, options)
+      end
+
       def refund(money, identification, options = {})
         form = {}
         add_txn_id(form, identification)
         add_test_mode(form, options)
-        commit(:refund, money, form)
+        commit(:refund, money, form, options)
       end
 
-      # Void a previous transaction
-      #
-      # ==== Parameters
-      #
-      # * <tt>authorization</tt> - The authorization returned from the previous request.
       def void(identification, options = {})
         form = {}
         add_txn_id(form, identification)
         add_test_mode(form, options)
-        commit(:void, nil, form)
+        commit(:void, nil, form, options)
       end
 
-      # Make a credit to a card.  Use the refund method if you'd like to credit using
-      # previous transaction
-      #
-      # ==== Parameters
-      # * <tt>money</tt> - The amount to be credited as an Integer value in cents.
-      # * <tt>creditcard</tt> - The credit card to be credited.
-      # * <tt>options</tt>
       def credit(money, creditcard, options = {})
         if creditcard.is_a?(String)
           raise ArgumentError, "Reference credits are not supported. Please supply the original credit card or use the #refund method."
@@ -180,7 +105,7 @@ module ActiveMerchant #:nodoc:
         add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
-        commit(:credit, money, form)
+        commit(:credit, money, form, options)
       end
 
       def verify(credit_card, options = {})
@@ -198,7 +123,7 @@ module ActiveMerchant #:nodoc:
         add_test_mode(form, options)
         add_verification(form, options)
         form[:add_token] = 'Y'
-        commit(:store, nil, form)
+        commit(:store, nil, form, options)
       end
 
       def update(token, creditcard, options = {})
@@ -208,7 +133,18 @@ module ActiveMerchant #:nodoc:
         add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
-        commit(:update, nil, form)
+        commit(:update, nil, form, options)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?ssl_pin=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?ssl_card_number=)[^&\\n\r\n]*)i, '\1[FILTERED]').
+          gsub(%r((&?ssl_cvv2cvc2=)[^&]*)i, '\1[FILTERED]')
       end
 
       private
@@ -255,6 +191,11 @@ module ActiveMerchant #:nodoc:
         form[:email] = truncate(options[:email], 100) unless empty?(options[:email])
         form[:customer_code] = truncate(options[:customer], 10) unless empty?(options[:customer])
         form[:customer_number] = options[:customer_number] unless empty?(options[:customer_number])
+        if options[:custom_fields]
+          options[:custom_fields].each do |key, value|
+            form[key.to_s] = value
+          end
+        end
       end
 
       def add_salestax(form, options)
@@ -313,11 +254,11 @@ module ActiveMerchant #:nodoc:
         !response.has_key?('errorMessage')
       end
 
-      def commit(action, money, parameters)
+      def commit(action, money, parameters, options)
         parameters[:amount] = amount(money)
         parameters[:transaction_type] = self.actions[action]
 
-        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)) )
+        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(parameters, options)) )
 
         Response.new(response['result'] == '0', message_from(response), response,
           :test => @options[:test] || test?,
@@ -327,21 +268,22 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def post_data(parameters)
+      def post_data(parameters, options)
         result = preamble
         result.merge!(parameters)
-        result.collect { |key, value| post_data_string(key, value) }.join("&")
+        result.collect { |key, value| post_data_string(key, value, options) }.join("&")
       end
 
-      def post_data_string(key, value)
-        if custom_field?(key)
+      def post_data_string(key, value, options)
+        if custom_field?(key, options)
           "#{key}=#{CGI.escape(value.to_s)}"
         else
           "ssl_#{key}=#{CGI.escape(value.to_s)}"
         end
       end
 
-      def custom_field?(field_name)
+      def custom_field?(field_name, options)
+        return true if options[:custom_fields] && options[:custom_fields].include?(field_name.to_sym)
         field_name == :customer_number
       end
 

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

@@ -15,7 +15,7 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'Element'
 
       SERVICE_TEST_URL = 'https://certservices.elementexpress.com/express.asmx'
-      SERVICE_LIVE_URL = 'https://service.elementexpress.com/express.asmx'
+      SERVICE_LIVE_URL = 'https://services.elementexpress.com/express.asmx'
 
       def initialize(options={})
         requires!(options, :account_id, :account_token, :application_id, :acceptor_id, :application_name, :application_version)
@@ -274,6 +274,8 @@ module ActiveMerchant #:nodoc:
           message_from(response),
           response,
           authorization: authorization_from(action, response, amount),
+          avs_result: success_from(response) ? avs_from(response) : nil,
+          cvv_result: success_from(response) ? cvv_from(response) : nil,
           test: test?
         )
       end
@@ -294,6 +296,14 @@ module ActiveMerchant #:nodoc:
         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 split_authorization(authorization)
         authorization.split("|")
       end

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

@@ -14,23 +14,11 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://www.fatzebra.com.au/'
       self.display_name = 'Fat Zebra'
 
-      # Setup a new instance of the gateway.
-      #
-      # The options hash should include :username and :token
-      # You can find your username and token at https://dashboard.fatzebra.com.au
-      # Under the Your Account section
       def initialize(options = {})
         requires!(options, :username, :token)
         super
       end
 
-      # To create a purchase on a credit card use:
-      #
-      #   purchase(money, creditcard)
-      #
-      # To charge a tokenized card
-      #
-      #   purchase(money, "abzy87u", :cvv => "123")
       def purchase(money, creditcard, options = {})
         post = {}
 
@@ -65,11 +53,6 @@ module ActiveMerchant #:nodoc:
         commit(:post, "purchases/#{CGI.escape(authorization)}/capture", post)
       end
 
-      # Refund a transaction
-      #
-      # amount - Integer - the amount to refund
-      # txn_id - String - the original transaction to be refunded
-      # reference - String - your transaction reference
       def refund(money, txn_id, options={})
         post = {}
 
@@ -81,9 +64,6 @@ module ActiveMerchant #:nodoc:
         commit(:post, "refunds", post)
       end
 
-      # Tokenize a credit card
-      #
-      # The token is returned in the Response#authorization
       def store(creditcard, options={})
         post = {}
         add_creditcard(post, creditcard)
@@ -98,20 +78,18 @@ module ActiveMerchant #:nodoc:
       def scrub(transcript)
         transcript.
           gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
-          gsub(%r(("card_number\\":\\")[^"\\]*)i, '\1[FILTERED]').
-          gsub(%r(("cvv\\":\\")\d+), '\1[FILTERED]')
+          gsub(%r(("card_number\\?":\\?")[^"\\]*)i, '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]')
       end
 
       private
 
-      # Add the money details to the request
       def add_amount(post, money, options)
         post[:currency] = (options[:currency] || currency(money))
         post[:currency] = post[:currency].upcase if post[:currency]
         post[:amount] = money
       end
 
-      # Add the credit card details to the request
       def add_creditcard(post, creditcard, options = {})
         if creditcard.respond_to?(:number)
           post[:card_number] = creditcard.number
@@ -134,7 +112,7 @@ module ActiveMerchant #:nodoc:
         extra = {}
         extra[:ecm] = "32" if options[:recurring]
         extra[:cavv] = options[:cavv] if options[:cavv]
-        extra[:xid] = options[:cavv] if options[:xid]
+        extra[:xid] = options[:xid] if options[:xid]
         extra[:sli] = options[:sli] if options[:sli]
         extra[:name] = options[:merchant] if options[:merchant]
         extra[:location] = options[:merchant_location] if options[:merchant_location]
@@ -149,7 +127,6 @@ module ActiveMerchant #:nodoc:
         post[:customer_ip] = options[:ip] || "127.0.0.1"
       end
 
-      # Post the data to the gateway
       def commit(method, uri, parameters=nil)
         response = begin
           parse(ssl_request(method, get_url(uri), parameters.to_json, headers))
@@ -194,7 +171,6 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      # Parse the returned JSON, if parse errors are raised then return a detailed error.
       def parse(response)
         begin
           JSON.parse(response)
@@ -209,13 +185,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      # Build the URL based on the AM mode and the URI
       def get_url(uri)
         base = test? ? self.test_url : self.live_url
         base + "/" + uri
       end
 
-      # Builds the auth and U-A headers for the request
       def headers
         {
           "Authorization" => "Basic " + Base64.strict_encode64(@options[:username].to_s + ":" + @options[:token].to_s).strip,

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

@@ -3,7 +3,7 @@ require 'nokogiri'
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class FirstPayGateway < Gateway
-      self.live_url = 'https://secure.1stpaygateway.net/secure/gateway/xmlgateway.aspx'
+      self.live_url = 'https://secure.goemerchant.com/secure/gateway/xmlgateway.aspx'
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
@@ -66,18 +66,20 @@ module ActiveMerchant #:nodoc:
       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)
-        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]
+        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, money, options)

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

@@ -34,6 +34,8 @@ module ActiveMerchant #:nodoc:
 
       E4_BRANDS = BRANDS.merge({:mastercard => "Mastercard"})
 
+      DEFAULT_ECI = "07"
+
       self.supported_cardtypes = BRANDS.keys
       self.supported_countries = ["CA", "US"]
       self.default_currency = "USD"
@@ -139,9 +141,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def scrub(transcript)
-        transcript.
-          gsub(%r((<Card_Number>).+(</Card_Number>)), '\1[FILTERED]\2').
-          gsub(%r((<VerificationStr2>).+(</VerificationStr2>)), '\1[FILTERED]\2')
+        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?
@@ -154,7 +159,7 @@ module ActiveMerchant #:nodoc:
         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
@@ -169,14 +174,13 @@ module ActiveMerchant #:nodoc:
         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_card_authentication_data(xml, options)
         add_tax_fields(xml, options)
         add_level_3(xml, options)
 
@@ -226,19 +230,33 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_credit_card(xml, credit_card, options)
-
         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
+
+        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)
         address = options[:billing_address] || options[:address]
         if address
@@ -249,36 +267,34 @@ module ActiveMerchant #:nodoc:
 
         if credit_card.is_a?(NetworkTokenizationCreditCard)
           add_network_tokenization_credit_card(xml, credit_card)
-        elsif credit_card.verification_value?
-          xml.tag! "CVD_Presence_Ind", "1"
-          xml.tag! "VerificationStr2", credit_card.verification_value
+        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_network_tokenization_credit_card(xml, credit_card)
-        xml.tag!("Ecommerce_Flag", credit_card.eci)
-
         case card_brand(credit_card).to_sym
-        when :visa
-          xml.tag!("XID", credit_card.transaction_id) if credit_card.transaction_id
-          xml.tag!("CAVV", credit_card.payment_cryptogram)
-        when :mastercard
-          xml.tag!("XID", credit_card.transaction_id) if credit_card.transaction_id
-          xml.tag!("CAVV", credit_card.payment_cryptogram)
         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]
-        xml.tag! "Ecommerce_Flag", options[:eci]
       end
 
-      def add_credit_card_token(xml, store_authorization)
+      def add_credit_card_token(xml, store_authorization, options)
         params = store_authorization.split(";")
         credit_card = CreditCard.new(
           :brand      => params[1],
@@ -291,6 +307,7 @@ module ActiveMerchant #:nodoc:
         xml.tag! "Expiry_Date", expdate(credit_card)
         xml.tag! "CardHoldersName", credit_card.name
         xml.tag! "CardType", card_type(credit_card.brand)
+        add_card_authentication_data(xml, options)
       end
 
       def add_customer_data(xml, options)

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

@@ -46,7 +46,6 @@ module ActiveMerchant #:nodoc:
 
       def capture(money, authorization, options={})
         post = {}
-        add_invoice(post, options)
         post[:transaction_id] = transaction_id_from(authorization)
         post[:authorization_code] = authorization_code_from(authorization) || ""
         post[:action] = "capture"