activemerchant 1.42.6 → 1.90.0

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

@@ -1,20 +1,284 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    class NmiGateway < AuthorizeNetGateway
-      self.test_url = 'https://secure.networkmerchants.com/gateway/transact.dll'
-      self.live_url = 'https://secure.networkmerchants.com/gateway/transact.dll'
-      self.homepage_url = 'http://nmi.com/'
-      self.display_name = 'NMI'
+    class NmiGateway < Gateway
+      include Empty
+
+      DUP_WINDOW_DEPRECATION_MESSAGE = 'The class-level duplicate_window variable is deprecated. Please use the :dup_seconds transaction option instead.'
+
+      self.test_url = self.live_url = 'https://secure.nmi.com/api/transact.php'
+      self.default_currency = 'USD'
+      self.money_format = :dollars
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://nmi.com/'
+      self.display_name = 'NMI'
 
-      private
-      def add_creditcard(post, creditcard, options={})
+      def self.duplicate_window=(seconds)
+        ActiveMerchant.deprecated(DUP_WINDOW_DEPRECATION_MESSAGE)
+        @dup_seconds = seconds
+      end
+
+      def self.duplicate_window
+        instance_variable_defined?(:@dup_seconds) ? @dup_seconds : nil
+      end
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
         super
-        post[:recurring_billing] = "TRUE" if options[:recurring]
       end
-    end
 
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_vendor_data(post, options)
+        add_merchant_defined_fields(post, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_vendor_data(post, options)
+        add_merchant_defined_fields(post, options)
+
+        commit('auth', post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_merchant_defined_fields(post, options)
+
+        commit('capture', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_payment_type(post, authorization)
+
+        commit('void', post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_payment_type(post, authorization)
+
+        commit('refund', post)
+      end
+
+      def credit(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_vendor_data(post, options)
+
+        commit('credit', post)
+      end
+
+      def verify(payment_method, options={})
+        post = {}
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_vendor_data(post, options)
+        add_merchant_defined_fields(post, options)
+
+        commit('validate', post)
+      end
+
+      def store(payment_method, options = {})
+        post = {}
+        add_invoice(post, nil, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_vendor_data(post, options)
+        add_merchant_defined_fields(post, options)
+
+        commit('add_customer', post)
+      end
+
+      def verify_credentials
+        response = void('0')
+        response.message != 'Authentication Failed'
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((password=)\w+), '\1[FILTERED]').
+          gsub(%r((ccnumber=)\d+), '\1[FILTERED]').
+          gsub(%r((cvv=)\d+), '\1[FILTERED]').
+          gsub(%r((checkaba=)\d+), '\1[FILTERED]').
+          gsub(%r((checkaccount=)\d+), '\1[FILTERED]').
+          gsub(%r((cryptogram=)[^&]+(&?)), '\1[FILTERED]\2')
+      end
+
+      def supports_network_tokenization?
+        true
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+        post[:currency] = options[:currency] || currency(money)
+        post[:billing_method] = 'recurring' if options[:recurring]
+        if (dup_seconds = (options[:dup_seconds] || self.class.duplicate_window))
+          post[:dup_seconds] = dup_seconds
+        end
+      end
+
+      def add_payment_method(post, payment_method, options)
+        if(payment_method.is_a?(String))
+          post[:customer_vault_id] = payment_method
+        elsif payment_method.is_a?(NetworkTokenizationCreditCard)
+          post[:ccnumber] = payment_method.number
+          post[:ccexp] = exp_date(payment_method)
+          post[:token_cryptogram] = payment_method.payment_cryptogram
+        elsif(card_brand(payment_method) == 'check')
+          post[:payment] = 'check'
+          post[:firstname] = payment_method.first_name
+          post[:lastname] = payment_method.last_name
+          post[:checkname] = payment_method.name
+          post[:checkaba] = payment_method.routing_number
+          post[:checkaccount] = payment_method.account_number
+          post[:account_holder_type] = payment_method.account_holder_type
+          post[:account_type] = payment_method.account_type
+          post[:sec_code] = options[:sec_code] || 'WEB'
+        else
+          post[:payment] = 'creditcard'
+          post[:firstname] = payment_method.first_name
+          post[:lastname] = payment_method.last_name
+          post[:ccnumber] = payment_method.number
+          post[:cvv] = payment_method.verification_value unless empty?(payment_method.verification_value)
+          post[:ccexp] = exp_date(payment_method)
+        end
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+        post[:customer_id] = options[:customer_id] || options[:customer]
+
+        if(billing_address = options[:billing_address] || options[:address])
+          post[:company] = billing_address[:company]
+          post[:address1] = billing_address[:address1]
+          post[:address2] = billing_address[:address2]
+          post[:city] = billing_address[:city]
+          post[:state] = billing_address[:state]
+          post[:country] = billing_address[:country]
+          post[:zip]    = billing_address[:zip]
+          post[:phone] = billing_address[:phone]
+        end
+
+        if(shipping_address = options[:shipping_address])
+          post[:shipping_company] = shipping_address[:company]
+          post[:shipping_address1] = shipping_address[:address1]
+          post[:shipping_address2] = shipping_address[:address2]
+          post[:shipping_city] = shipping_address[:city]
+          post[:shipping_state] = shipping_address[:state]
+          post[:shipping_country] = shipping_address[:country]
+          post[:shipping_zip]    = shipping_address[:zip]
+          post[:shipping_phone] = shipping_address[:phone]
+        end
+      end
+
+      def add_vendor_data(post, options)
+        post[:vendor_id] = options[:vendor_id] if options[:vendor_id]
+        post[:processor_id] = options[:processor_id] if options[:processor_id]
+      end
+
+      def add_merchant_defined_fields(post, options)
+        (1..20).each do |each|
+          key = "merchant_defined_field_#{each}".to_sym
+          post[key] = options[key] if options[key]
+        end
+      end
+
+      def add_reference(post, authorization)
+        transaction_id, _ = split_authorization(authorization)
+        post[:transactionid] = transaction_id
+      end
+
+      def add_payment_type(post, authorization)
+        _, payment_type = split_authorization(authorization)
+        post[:payment] = payment_type if payment_type
+      end
+
+      def exp_date(payment_method)
+        "#{format(payment_method.month, :two_digits)}#{format(payment_method.year, :two_digits)}"
+      end
+
+      def commit(action, params)
+        params[action == 'add_customer' ? :customer_vault : :type] = action
+        params[:username] = @options[:login]
+        params[:password] = @options[:password]
+
+        raw_response = ssl_post(url, post_data(action, params), headers)
+        response = parse(raw_response)
+        succeeded = success_from(response)
+
+        Response.new(
+          succeeded,
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response, params[:payment]),
+          avs_result: AVSResult.new(code: response[:avsresponse]),
+          cvv_result: CVVResult.new(response[:cvvresponse]),
+          test: test?
+        )
+      end
+
+      def authorization_from(response, payment_type)
+        [ response[:transactionid], payment_type ].join('#')
+      end
+
+      def split_authorization(authorization)
+        authorization.split('#')
+      end
+
+      def headers
+        { 'Content-Type'  => 'application/x-www-form-urlencoded;charset=UTF-8' }
+      end
+
+      def post_data(action, params)
+        params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        Hash[CGI::parse(body).map { |k, v| [k.intern, v.first] }]
+      end
+
+      def success_from(response)
+        response[:response] == '1'
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          'Succeeded'
+        else
+          response[:responsetext]
+        end
+      end
+
+    end
   end
 end
-

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 require 'rexml/document'
 
 module ActiveMerchant #:nodoc:
@@ -119,20 +120,18 @@ module ActiveMerchant #:nodoc:
                       'KO' => 'N',
                       'NO' => 'R' }
 
-      SUCCESS_MESSAGE = "The transaction was successful"
+      SUCCESS_MESSAGE = 'The transaction was successful'
+
+      THREE_D_SECURE_DISPLAY_WAYS = { :main_window => 'MAINW',  # display the identification page in the main window (default value).
 
-      THREE_D_SECURE_DISPLAY_WAYS = { :main_window => 'MAINW',  # display the identification page in the main window
-                                                                # (default value).
-                                      :pop_up      => 'POPUP',  # display the identification page in a pop-up window
-                                                                # and return to the main window at the end.
-                                      :pop_ix      => 'POPIX' } # display the identification page in a pop-up window
-                                                                # and remain in the pop-up window.
+                                      :pop_up      => 'POPUP',  # display the identification page in a pop-up window and return to the main window at the end.
+                                      :pop_ix      => 'POPIX' } # display the identification page in a pop-up window and remain in the pop-up window.
 
-      OGONE_NO_SIGNATURE_DEPRECATION_MESSAGE   = "Signature usage will be the default for a future release of ActiveMerchant. You should either begin using it, or update your configuration to explicitly disable it (signature_encryptor: none)"
+      OGONE_NO_SIGNATURE_DEPRECATION_MESSAGE   = 'Signature usage will be the default for a future release of ActiveMerchant. You should either begin using it, or update your configuration to explicitly disable it (signature_encryptor: none)'
       OGONE_STORE_OPTION_DEPRECATION_MESSAGE   = "The 'store' option has been renamed to 'billing_id', and its usage is deprecated."
 
-      self.test_url = "https://secure.ogone.com/ncol/test/"
-      self.live_url = "https://secure.ogone.com/ncol/prod/"
+      self.test_url = 'https://secure.ogone.com/ncol/test/'
+      self.live_url = 'https://secure.ogone.com/ncol/prod/'
 
       self.supported_countries = ['BE', 'DE', 'FR', 'NL', 'AT', 'CH']
       # also supports Airplus and UATP
@@ -141,7 +140,6 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'Ogone'
       self.default_currency = 'EUR'
       self.money_format = :cents
-      self.ssl_version = :TLSv1
 
       def initialize(options = {})
         requires!(options, :login, :user, :password)
@@ -151,12 +149,13 @@ module ActiveMerchant #:nodoc:
       # Verify and reserve the specified amount on the account, without actually doing the transaction.
       def authorize(money, payment_source, options = {})
         post = {}
+        action = payment_source.brand == 'mastercard' ? 'PAU' : 'RES'
         add_invoice(post, options)
         add_payment_source(post, payment_source, options)
         add_address(post, payment_source, options)
         add_customer_data(post, options)
         add_money(post, money, options)
-        commit('RES', post)
+        commit(action, post)
       end
 
       # Verify and transfer the specified amount.
@@ -192,7 +191,7 @@ module ActiveMerchant #:nodoc:
       # Credit the specified account by a specific amount.
       def credit(money, identification_or_credit_card, options = {})
         if reference_transaction?(identification_or_credit_card)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           # Referenced credit: refund of a settled transaction
           refund(money, identification_or_credit_card, options)
         else # must be a credit card or card reference
@@ -205,23 +204,42 @@ module ActiveMerchant #:nodoc:
         perform_reference_credit(money, reference, options)
       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
+
       # Store a credit card by creating an Ogone Alias
       def store(payment_source, options = {})
-        options.merge!(:alias_operation => 'BYPSP') unless(options.has_key?(:billing_id) || options.has_key?(:store))
+        options[:alias_operation] = 'BYPSP' unless(options.has_key?(:billing_id) || options.has_key?(:store))
         response = authorize(@options[:store_amount] || 1, payment_source, options)
         void(response.authorization) if response.success?
         response
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((&?cardno=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?cvc=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?pswd=)[^&]*)i, '\1[FILTERED]')
+      end
+
       private
 
       def reference_from(authorization)
-        authorization.split(";").first
+        authorization.split(';').first
       end
 
       def reference_transaction?(identifier)
         return false unless identifier.is_a?(String)
-        _, action = identifier.split(";")
+        _, action = identifier.split(';')
         !action.nil?
       end
 
@@ -251,7 +269,7 @@ module ActiveMerchant #:nodoc:
           add_eci(post, options[:eci] || '9')
         else
           if options.has_key?(:store)
-            deprecated OGONE_STORE_OPTION_DEPRECATION_MESSAGE
+            ActiveMerchant.deprecated OGONE_STORE_OPTION_DEPRECATION_MESSAGE
             options[:billing_id] ||= options[:store]
           end
           add_alias(post, options[:billing_id], options[:alias_operation])
@@ -267,11 +285,13 @@ module ActiveMerchant #:nodoc:
           THREE_D_SECURE_DISPLAY_WAYS[:main_window]
         add_pair post, 'WIN3DS', win_3ds
 
-        add_pair post, 'HTTP_ACCEPT',     options[:http_accept] || "*/*"
+        add_pair post, 'HTTP_ACCEPT',     options[:http_accept] || '*/*'
         add_pair post, 'HTTP_USER_AGENT', options[:http_user_agent] if options[:http_user_agent]
         add_pair post, 'ACCEPTURL',       options[:accept_url]      if options[:accept_url]
         add_pair post, 'DECLINEURL',      options[:decline_url]     if options[:decline_url]
         add_pair post, 'EXCEPTIONURL',    options[:exception_url]   if options[:exception_url]
+        add_pair post, 'CANCELURL',       options[:cancel_url]      if options[:cancel_url]
+        add_pair post, 'PARAMVAR',        options[:paramvar]       if options[:paramvar]
         add_pair post, 'PARAMPLUS',       options[:paramplus]       if options[:paramplus]
         add_pair post, 'COMPLUS',         options[:complus]         if options[:complus]
         add_pair post, 'LANGUAGE',        options[:language]        if options[:language]
@@ -281,8 +301,8 @@ module ActiveMerchant #:nodoc:
         add_pair post, 'ECI', eci.to_s
       end
 
-      def add_alias(post, _alias, alias_operation = nil)
-        add_pair post, 'ALIAS', _alias
+      def add_alias(post, alias_name, alias_operation = nil)
+        add_pair post, 'ALIAS', alias_name
         add_pair post, 'ALIASOPERATION', alias_operation unless alias_operation.nil?
       end
 
@@ -312,12 +332,13 @@ module ActiveMerchant #:nodoc:
       def add_invoice(post, options)
         add_pair post, 'orderID', options[:order_id] || generate_unique_id[0...30]
         add_pair post, 'COM',     options[:description]
+        add_pair post, 'ORIG',    options[:origin] if options[:origin]
       end
 
       def add_creditcard(post, creditcard)
         add_pair post, 'CN',     creditcard.name
         add_pair post, 'CARDNO', creditcard.number
-        add_pair post, 'ED',     "%02d%02s" % [creditcard.month, creditcard.year.to_s[-2..-1]]
+        add_pair post, 'ED',     '%02d%02s' % [creditcard.month, creditcard.year.to_s[-2..-1]]
         add_pair post, 'CVC',    creditcard.verification_value
       end
 
@@ -327,14 +348,15 @@ module ActiveMerchant #:nodoc:
 
         # Add HTML_ANSWER element (3-D Secure specific to the response's params)
         # Note: HTML_ANSWER is not an attribute so we add it "by hand" to the response
-        if html_answer = REXML::XPath.first(xml_root, "//HTML_ANSWER")
-          response["HTML_ANSWER"] = html_answer.text
+        if html_answer = REXML::XPath.first(xml_root, '//HTML_ANSWER')
+          response['HTML_ANSWER'] = html_answer.text
         end
 
         response
       end
 
       def commit(action, parameters)
+        add_pair parameters, 'RTIMEOUT', @options[:timeout] if @options[:timeout]
         add_pair parameters, 'PSPID',  @options[:login]
         add_pair parameters, 'USERID', @options[:user]
         add_pair parameters, 'PSWD',   @options[:password]
@@ -342,27 +364,27 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(url(parameters['PAYID']), post_data(action, parameters)))
 
         options = {
-          :authorization => [response["PAYID"], action].join(";"),
+          :authorization => [response['PAYID'], action].join(';'),
           :test          => test?,
-          :avs_result    => { :code => AVS_MAPPING[response["AAVCheck"]] },
-          :cvv_result    => CVV_MAPPING[response["CVCCheck"]]
+          :avs_result    => { :code => AVS_MAPPING[response['AAVCheck']] },
+          :cvv_result    => CVV_MAPPING[response['CVCCheck']]
         }
         OgoneResponse.new(successful?(response), message_from(response), response, options)
       end
 
       def url(payid)
-        (test? ? test_url : live_url) + (payid ? "maintenancedirect.asp" : "orderdirect.asp")
+        (test? ? test_url : live_url) + (payid ? 'maintenancedirect.asp' : 'orderdirect.asp')
       end
 
       def successful?(response)
-        response["NCERROR"] == "0"
+        response['NCERROR'] == '0'
       end
 
       def message_from(response)
         if successful?(response)
           SUCCESS_MESSAGE
         else
-          format_error_message(response["NCERRORPLUS"])
+          format_error_message(response['NCERRORPLUS'])
         end
       end
 
@@ -370,9 +392,9 @@ module ActiveMerchant #:nodoc:
         raw_message = message.to_s.strip
         case raw_message
         when /\|/
-          raw_message.split("|").join(", ").capitalize
+          raw_message.split('|').join(', ').capitalize
         when /\//
-          raw_message.split("/").first.to_s.capitalize
+          raw_message.split('/').first.to_s.capitalize
         else
           raw_message.to_s.capitalize
         end
@@ -386,27 +408,48 @@ module ActiveMerchant #:nodoc:
 
       def add_signature(parameters)
         if @options[:signature].blank?
-           deprecated(OGONE_NO_SIGNATURE_DEPRECATION_MESSAGE) unless(@options[:signature_encryptor] == "none")
-           return
+          ActiveMerchant.deprecated(OGONE_NO_SIGNATURE_DEPRECATION_MESSAGE) unless(@options[:signature_encryptor] == 'none')
+          return
         end
 
-        sha_encryptor = case @options[:signature_encryptor]
-                        when 'sha256'
-                          Digest::SHA256
-                        when 'sha512'
-                          Digest::SHA512
-                        else
-                          Digest::SHA1
-                        end
-
-        string_to_digest = if @options[:signature_encryptor]
-          parameters.sort { |a, b| a[0].upcase <=> b[0].upcase }.map { |k, v| "#{k.upcase}=#{v}" }.join(@options[:signature])
+        add_pair parameters, 'SHASign', calculate_signature(parameters, @options[:signature_encryptor], @options[:signature])
+      end
+
+      def calculate_signature(signed_parameters, algorithm, secret)
+        return legacy_calculate_signature(signed_parameters, secret) unless algorithm
+
+        sha_encryptor = case algorithm
+        when 'sha256'
+          Digest::SHA256
+        when 'sha512'
+          Digest::SHA512
+        when 'sha1'
+          Digest::SHA1
         else
-          %w[orderID amount currency CARDNO PSPID Operation ALIAS].map { |key| parameters[key] }.join
+          raise "Unknown signature algorithm #{algorithm}"
         end
-        string_to_digest << @options[:signature]
 
-        add_pair parameters, 'SHASign', sha_encryptor.hexdigest(string_to_digest).upcase
+        filtered_params = signed_parameters.select { |k, v| !v.blank? }
+        sha_encryptor.hexdigest(
+          filtered_params.sort_by { |k, v| k.upcase }.map { |k, v| "#{k.upcase}=#{v}#{secret}" }.join('')
+        ).upcase
+      end
+
+      def legacy_calculate_signature(parameters, secret)
+        Digest::SHA1.hexdigest(
+          (
+            %w(
+              orderID
+              amount
+              currency
+              CARDNO
+              PSPID
+              Operation
+              ALIAS
+            ).map { |key| parameters[key] } +
+            [secret]
+          ).join('')
+        ).upcase
       end
 
       def add_pair(post, key, value)