activemerchant 1.58.0 → 1.59.0

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

@@ -21,12 +21,11 @@ module ActiveMerchant #:nodoc:
         'unchecked' => 'P'
       }
 
-      CURRENCIES_WITHOUT_FRACTIONS = %w(BIF CLP DJF GNF JPY KMF KRW MGA PYG RWF VND VUV XAF XOF XPF)
-
       self.supported_countries = %w(AT AU BE CA CH DE DK ES FI FR GB IE IT LU NL NO SE US)
       self.default_currency = 'USD'
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club, :maestro]
+      self.currencies_without_fractions = %w(BIF CLP DJF GNF JPY KMF KRW MGA PYG RWF VND VUV XAF XOF XPF)
 
       self.homepage_url = 'https://stripe.com/'
       self.display_name = 'Stripe'
@@ -341,7 +340,8 @@ module ActiveMerchant #:nodoc:
         card = {}
         if emv_payment?(creditcard)
           add_emv_creditcard(post, creditcard.icc_data)
-          post[:card][:read_method] = "contactless" if creditcard.contactless
+          post[:card][:read_method] = "contactless" if creditcard.contactless_emv
+          post[:card][:read_method] = "contactless_magstripe_mode" if creditcard.contactless_magstripe
           if creditcard.encrypted_pin_cryptogram.present? && creditcard.encrypted_pin_ksn.present?
             post[:card][:encrypted_pin] = creditcard.encrypted_pin_cryptogram
             post[:card][:encrypted_pin_key_id] = creditcard.encrypted_pin_ksn
@@ -350,7 +350,8 @@ module ActiveMerchant #:nodoc:
           if creditcard.respond_to?(:track_data) && creditcard.track_data.present?
             card[:swipe_data] = creditcard.track_data
             card[:fallback_reason] = creditcard.fallback_reason if creditcard.fallback_reason
-            card[:read_method] = "contactless" if creditcard.contactless
+            card[:read_method] = "contactless" if creditcard.contactless_emv
+            post[:read_method] = "contactless_magstripe_mode" if creditcard.contactless_magstripe
           else
             card[:number] = creditcard.number
             card[:exp_month] = creditcard.month
@@ -534,10 +535,6 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def non_fractional_currency?(currency)
-        CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
-      end
-
       def emv_payment?(payment)
         payment.respond_to?(:emv?) && payment.emv?
       end

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

@@ -122,7 +122,7 @@ module ActiveMerchant #:nodoc:
           billing[:phone]                   = billing_address[:phone]
 
           customer[:email]                  = options[:email] if options[:email]
-          customer[:ipaddress]              = options[:ip] if options[:ip]
+          customer[:ipAddress]              = options[:ip] if options[:ip]
         end
 
         if(shipping_address = options[:shipping_address])

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

@@ -40,7 +40,7 @@ module ActiveMerchant #:nodoc:
         add_amount(post, money)
         add_payment(post, payment)
         add_address(post, options)
-        add_invoice(post, options) if payment.is_a?(CreditCard)
+        add_invoice(post, options) if payment.credit_card?
         add_pair(post, :RefID, options[:order_id], required: true)
 
         commit((payment.is_a?(Check) ? :purchase_echeck : :purchase), post)
@@ -237,4 +237,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -6,7 +6,7 @@ module ActiveMerchant
       include Empty
 
       self.test_url = 'https://www.vancodev.com/cgi-bin/wstest2.vps'
-      self.live_url = 'https://www.vancoservices.com/cgi-bin/ws2.vps'
+      self.live_url = 'https://myvanco.vancopayments.com/cgi-bin/ws2.vps'
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'

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

@@ -0,0 +1,218 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VisanetPeruGateway < Gateway
+      include Empty
+      self.display_name = "VisaNet Peru Gateway"
+      self.homepage_url = "http://www.visanet.com.pe"
+
+      self.test_url = "https://devapi.vnforapps.com/api.tokenization/api/v2/merchant"
+      self.live_url = "https://api.vnforapps.com/api.tokenization/api/v2/merchant"
+
+      self.supported_countries = ["US", "PE"]
+      self.default_currency = "PEN"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :access_key_id, :secret_access_key, :merchant_id)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run() do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        params = {}
+
+        add_invoice(params, amount, options)
+        add_payment_method(params, payment_method)
+        add_antifraud_data(params, options)
+        params[:email] = options[:email] || 'unknown@email.com'
+
+        # No vaulting for now
+        params[:createAlias] = false
+
+        commit("authorize", params)
+      end
+
+      def capture(authorization, options={})
+        params = {}
+        _, purchase_number = split_authorization(authorization)
+        params[:purchaseNumber] = purchase_number
+        params[:externalTransactionId] = options[:order_id]
+        commit("deposit", params)
+      end
+
+      def void(authorization, options={})
+        params = {}
+        action, purchase_number = split_authorization(authorization)
+        params[:purchaseNumber] = purchase_number
+        params[:externalTransactionId] = options[:order_id]
+
+        case action
+        when "authorize"
+          commit("void", params)
+        when "deposit"
+          commit("cancelDeposit", params)
+        end
+      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((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((\"cardNumber\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv2Code\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
+      CURRENCY_CODES["USD"] = 840
+      CURRENCY_CODES["PEN"] = 604
+
+      def add_invoice(params, money, options)
+        # Visanet Peru expects a 9-digit numeric purchaseNumber
+        params[:purchaseNumber] = (SecureRandom.random_number(900_000_000) + 100_000_000).to_s
+        params[:externalTransactionId] = options[:order_id]
+        params[:amount] = amount(money)
+        params[:currencyId] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_payment_method(params, payment_method)
+        params[:firstName] = payment_method.first_name
+        params[:lastName] = payment_method.last_name
+        params[:cardNumber] = payment_method.number
+        params[:cvv2Code] = payment_method.verification_value
+        params[:expirationYear] = format(payment_method.year, :four_digits)
+        params[:expirationMonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_antifraud_data(params, options)
+        antifraud = {}
+
+        if billing_address = options[:billing_address] || options[:address]
+          antifraud[:billTo_street1] = billing_address[:address1]
+          antifraud[:billTo_city] = billing_address[:city]
+          antifraud[:billTo_state] = billing_address[:state]
+          antifraud[:billTo_country] = billing_address[:country]
+          antifraud[:billTo_postalCode] = billing_address[:zip]
+        end
+
+        antifraud[:deviceFingerprintId] = options[:device_fingerprint_id] || SecureRandom.hex(16)
+        antifraud[:merchantDefineData] = options[:merchant_define_data] if options[:merchant_define_data]
+
+        params[:antifraud] = antifraud
+      end
+
+      def commit(action, params)
+        begin
+          raw_response = ssl_request(method(action), url(action, params), params.to_json, headers)
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response_error(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          Response.new(
+            success_from(response),
+            message_from(response),
+            response,
+            :test => test?,
+            :authorization => authorization_from(action, params),
+            :error_code => response["errorCode"]
+          )
+        end
+      end
+
+      def headers
+        {
+          "Authorization" => "Basic " + Base64.strict_encode64("#{@options[:access_key_id]}:#{@options[:secret_access_key]}").strip,
+          "Content-Type"  => "application/json"
+        }
+      end
+
+      def url(action, params)
+        if (action == "authorize")
+          url = base_url() + "/" + @options[:merchant_id]
+        else
+          url = base_url() + "/" + @options[:merchant_id] + "/" + action + "/" + params[:purchaseNumber]
+        end
+      end
+
+      def method(action)
+        if (action == "authorize")
+          method = :post
+        else
+          method = :put
+        end
+      end
+
+      def split_authorization(authorization)
+        authorization.split("|")
+      end
+
+      def authorization_from(action, params)
+        action + "|" + (params[:purchaseNumber] || '')
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response["errorCode"] == 0
+      end
+
+      def message_from(response)
+        if empty?(response["errorMessage"]) || response["errorMessage"] == "[ ]"
+          response["data"]["DSC_COD_ACCION"]
+        else
+          response["errorMessage"]
+        end
+      end
+
+      def response_error(raw_response)
+        begin
+          response = parse(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          return Response.new(
+            false,
+            message_from(response),
+            response,
+            :test => test?,
+            :authorization => response["transactionUUID"],
+            :error_code => response["errorCode"]
+          )
+        end
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from VisanetPeruGateway. Please contact VisanetPeruGateway if you continue to receive this message."
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,344 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # See https://helpdesk.worldnettps.com/support/solutions/articles/1000167298-integrator-guide
+    class WorldNetGateway < Gateway
+      self.test_url = 'https://testpayments.worldnettps.com/merchant/xmlpayment'
+      self.live_url = 'https://payments.worldnettps.com/merchant/xmlpayment'
+
+      self.homepage_url = 'http://worldnettps.com/'
+      self.display_name = 'WorldNet'
+
+      self.supported_countries = %w(IE GB US)
+      self.default_currency = 'EUR'
+
+      CARD_TYPES = {
+        visa:             'VISA',
+        master:           'MASTERCARD',
+        discover:         'DISCOVER',
+        american_express: 'AMEX',
+        maestro:          'MAESTRO',
+        diners_club:      'DINERS',
+        jcb:              'JCB',
+        secure_card:      'SECURECARD'
+      }.freeze
+      self.supported_cardtypes = CARD_TYPES.keys
+
+      def initialize(options = {})
+        requires!(options, :terminal_id, :secret)
+        options[:terminal_type] ||= 2 # eCommerce
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('PAYMENT', post)
+      end
+
+      def authorize(money, payment, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+        add_customer_data(post, options)
+
+        commit('PREAUTH', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        post[:uniqueref] = authorization
+
+        commit('PREAUTHCOMPLETION', post)
+      end
+
+      def refund(money, authorization, options = {})
+        requires!(options, :operator, :reason)
+
+        post = {}
+        post[:uniqueref] = authorization
+        add_invoice(post, money, options)
+        post[:operator] = options[:operator]
+        post[:reason] = options[:reason]
+
+        commit('REFUND', post)
+      end
+
+      def void(authorization, _options = {})
+        post = {}
+        post[:uniqueref] = 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 store(payment, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        post[:merchantref] = options[:order_id]
+        add_payment(post, payment)
+
+        commit('SECURECARDREGISTRATION', post)
+      end
+
+      def unstore(payment, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        post[:merchantref] = options[:order_id]
+        add_card_reference(post, payment)
+
+        commit('SECURECARDREMOVAL', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript
+          .gsub(%r{(<CARDNUMBER>\d{6})\d+(\d{4}</CARDNUMBER>)}, '\1...\2')
+          .gsub(%r{(<CVV>)\d+(</CVV)}, '\1...\2')
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+      end
+
+      def add_address(post, _creditcard, options)
+        address = options[:billing_address] || options[:address]
+        return unless address
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city]     = address[:city]
+        post[:country]  = address[:country] # ISO 3166-1-alpha-2 code.
+        post[:postcode] = address[:zip]
+      end
+
+      def add_invoice(post, money, options)
+        post[:orderid] = options[:order_id]
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:description] = options[:description]
+      end
+
+      def add_payment(post, payment)
+        # a payment triggered with a secure_card (tokenised card) will not
+        # respond to `:number`
+        if payment.respond_to?(:number)
+          post[:cardholdername] = cardholdername(payment)
+          post[:cardtype]       = CARD_TYPES[payment.brand.to_sym]
+          post[:cardnumber]     = payment.number
+          post[:cvv]            = payment.verification_value if payment.verification_value
+          post[:cardexpiry]     = expdate(payment)
+        else
+          post[:cardtype]       = CARD_TYPES[:secure_card]
+          post[:cardnumber]     = payment
+        end
+      end
+
+      def add_card_reference(post, payment)
+        post[:cardreference] = payment
+      end
+
+      def cardholdername(payment)
+        [payment.first_name, payment.last_name].join(' ').slice(0, 60)
+      end
+
+      def parse(action, body)
+        results = {}
+        xml = Nokogiri::XML(body)
+        resp = xml.xpath("//#{action}RESPONSE | //ERROR")
+        resp.children.each do |element|
+          results[element.name.downcase.to_sym] = element.text
+        end
+        results
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url)
+        response = parse(action, ssl_post(url, post_data(action, parameters)))
+
+        Response.new(
+          success_from(action, response),
+          message_from(response),
+          response,
+          authorization: authorization_from(action, response),
+          avs_result: AVSResult.new(code: response[:avs_response]),
+          cvv_result: CVVResult.new(response[:cvv_response]),
+          test: test?,
+          error_code: success_from(action, response) ? nil : message_to_standard_error_code_from(response)
+        )
+      end
+
+      def success_from(action, response)
+        case action
+        when 'SECURECARDREGISTRATION'
+          response[:cardreference].present?
+        when 'SECURECARDREMOVAL'
+          response[:datetime].present? && response[:hash].present?
+        else
+          response[:responsecode] == 'A'
+        end
+      end
+
+      def message_to_standard_error_code_from(response)
+        case message_from(response)
+        when /DECLINED/
+          STANDARD_ERROR_CODE[:card_declined]
+        when /CVV FAILURE/
+          STANDARD_ERROR_CODE[:incorrect_cvc]
+        when /Invalid CARDEXPIRY field/
+          STANDARD_ERROR_CODE[:invalid_expiry_date]
+        else
+          STANDARD_ERROR_CODE[:processing_error]
+        end
+      end
+
+      def message_from(response)
+        response[:responsetext] || response[:errorstring]
+      end
+
+      def authorization_from(action, response)
+        case action
+        when 'SECURECARDREGISTRATION'
+          response[:cardreference]
+        else
+          response[:uniqueref]
+        end
+      end
+
+      def post_data(action, parameters = {})
+        parameters[:terminalid]       = @options[:terminal_id]
+        parameters[:terminaltype]     = @options[:terminal_type]
+        parameters[:transactiontype]  = 7 # eCommerce
+        parameters[:datetime]         = create_time_stamp
+        parameters[:hash]             = case action
+                                        when 'SECURECARDREGISTRATION'
+                                          build_store_signature(parameters)
+                                        when 'SECURECARDREMOVAL'
+                                          build_unstore_signature(parameters)
+                                        else
+                                          build_signature(parameters)
+                                        end
+        build_xml_request(action, fields(action), parameters)
+      end
+
+      def create_time_stamp
+        Time.now.gmtime.strftime('%d-%m-%Y:%H:%M:%S:%L')
+      end
+
+      def build_signature(parameters)
+        str = parameters[:terminalid]
+        str += (parameters[:uniqueref] || parameters[:orderid])
+        str += (parameters[:amount].to_s + parameters[:datetime])
+        Digest::MD5.hexdigest(str + @options[:secret])
+      end
+
+      def build_store_signature(parameters)
+        str = parameters[:terminalid]
+        str += parameters[:merchantref]
+        str += parameters[:datetime]
+        str += parameters[:cardnumber]
+        str += parameters[:cardexpiry]
+        str += parameters[:cardtype]
+        str += parameters[:cardholdername]
+        Digest::MD5.hexdigest(str + @options[:secret])
+      end
+
+      def build_unstore_signature(parameters)
+        str = parameters[:terminalid]
+        str += parameters[:merchantref]
+        str += parameters[:datetime]
+        str += parameters[:cardreference]
+        Digest::MD5.hexdigest(str + @options[:secret])
+      end
+
+      def fields(action)
+        # Gateway expects fields in fixed order below.
+        case action
+        when 'PAYMENT', 'PREAUTH'
+          [
+            :orderid,
+            :terminalid,
+            :amount,
+            :datetime,
+            :cardnumber, :cardtype, :cardexpiry, :cardholdername,
+            :hash,
+            :currency,
+            :terminaltype,
+            :transactiontype,
+            :email,
+            :cvv,
+            :address1, :address2,
+            :postcode,
+            :description,
+            :city, :country,
+            :ipaddress
+          ]
+        when 'PREAUTHCOMPLETION'
+          [:uniqueref, :terminalid, :amount, :datetime, :hash]
+        when 'REFUND'
+          [:uniqueref, :terminalid, :amount, :datetime, :hash,
+           :operator, :reason]
+        when 'VOID'
+          [:uniqueref]
+        when 'SECURECARDREGISTRATION'
+          [
+            :merchantref,
+            :terminalid,
+            :datetime,
+            :cardnumber, :cardexpiry, :cardtype, :cardholdername,
+            :hash,
+            :dontchecksecurity,
+            :cvv,
+            :issueno
+          ]
+        when 'SECURECARDREMOVAL'
+          [
+            :merchantref,
+            :cardreference,
+            :terminalid,
+            :datetime,
+            :hash
+          ]
+        end
+      end
+
+      def build_xml_request(action, fields, data)
+        xml = Builder::XmlMarkup.new indent: 2
+        xml.instruct!(:xml, version: '1.0', encoding: 'utf-8')
+        xml.tag!(action) do
+          fields.each do |field|
+            xml.tag!(field.to_s.upcase, data[field]) if data[field]
+          end
+        end
+        xml.target!
+      end
+
+      def expdate(credit_card)
+        sprintf('%02d%02d', credit_card.month, credit_card.year % 100)
+      end
+    end
+  end
+end