activemerchant 1.44.1 → 1.45.0

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

@@ -18,10 +18,22 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'http://www.monerisusa.com/'
       self.display_name = 'Moneris (US)'
 
-      # login is your Store ID
-      # password is your API Token
+      # Initialize the Gateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- Your Store ID
+      # * <tt>:password</tt> -- Your API Token
+      # * <tt>:cvv_enabled</tt> -- Specify that you would like the CVV passed to the gateway.
+      #                            Only particular account types at Moneris will allow this.
+      #                            Defaults to false.  (optional)
       def initialize(options = {})
         requires!(options, :login, :password)
+        @cvv_enabled = options[:cvv_enabled]
+        @avs_enabled = options[:avs_enabled]
         options = { :crypt_type => 7 }.merge(options)
         super
       end
@@ -31,16 +43,32 @@ module ActiveMerchant #:nodoc:
       # captured at a later date.
       #
       # Pass in +order_id+ and optionally a +customer+ parameter.
-      def authorize(money, creditcard, options = {})
-        debit_commit 'us_preauth', money, creditcard, options
+      def authorize(money, creditcard_or_datakey, options = {})
+        requires!(options, :order_id)
+        post = {}
+        add_payment_source(post, creditcard_or_datakey, options)
+        post[:amount]     = amount(money)
+        post[:order_id]   = options[:order_id]
+        post[:address]    = options[:billing_address] || options[:address]
+        post[:crypt_type] = options[:crypt_type] || @options[:crypt_type]
+        action = (post[:data_key].blank?) ? 'us_preauth' : 'us_res_preauth_cc'
+        commit(action, post)
       end
 
-      # This action verifies funding on a customer's card, and readies them for
+      # This action verifies funding on a customer's card and readies them for
       # deposit in a merchant's account.
       #
       # Pass in <tt>order_id</tt> and optionally a <tt>customer</tt> parameter
-      def purchase(money, creditcard, options = {})
-        debit_commit 'us_purchase', money, creditcard, options
+      def purchase(money, creditcard_or_datakey, options = {})
+        requires!(options, :order_id)
+        post = {}
+        add_payment_source(post, creditcard_or_datakey, options)
+        post[:amount]     = amount(money)
+        post[:order_id]   = options[:order_id]
+        post[:address]    = options[:billing_address] || options[:address]
+        post[:crypt_type] = options[:crypt_type] || @options[:crypt_type]
+        action = (post[:data_key].blank?) ? 'us_purchase' : 'us_res_purchase_cc'
+        commit(action, post)
       end
 
       # This method retrieves locked funds from a customer's account (from a
@@ -79,27 +107,45 @@ module ActiveMerchant #:nodoc:
         commit 'us_refund', crediting_params(authorization, :amount => amount(money))
       end
 
+      def store(credit_card, options = {})
+        post = {}
+        post[:pan] = credit_card.number
+        post[:expdate] = expdate(credit_card)
+        post[:crypt_type] = options[:crypt_type] || @options[:crypt_type]
+        commit('us_res_add_cc', post)
+      end
+
+      def unstore(data_key, options = {})
+        post = {}
+        post[:data_key] = data_key
+        commit('us_res_delete', post)
+      end
+
+      def update(data_key, credit_card, options = {})
+        post = {}
+        post[:pan] = credit_card.number
+        post[:expdate] = expdate(credit_card)
+        post[:data_key] = data_key
+        post[:crypt_type] = options[:crypt_type] || @options[:crypt_type]
+        commit('us_res_update_cc', post)
+      end
+
       private # :nodoc: all
 
       def expdate(creditcard)
         sprintf("%.4i", creditcard.year)[-2..-1] + sprintf("%.2i", creditcard.month)
       end
 
-      def debit_commit(commit_type, money, creditcard, options)
-        requires!(options, :order_id)
-        commit(commit_type, debit_params(money, creditcard, options))
-      end
-
-      # Common params used amongst the +purchase+ and +authorization+ methods
-      def debit_params(money, creditcard, options = {})
-        {
-          :order_id   => options[:order_id],
-          :cust_id    => options[:customer],
-          :amount     => amount(money),
-          :pan        => creditcard.number,
-          :expdate    => expdate(creditcard),
-          :crypt_type => options[:crypt_type] || @options[:crypt_type]
-        }
+      def add_payment_source(post, source, options)
+        if source.is_a?(String)
+          post[:data_key]   = source
+          post[:cust_id]    = options[:customer]
+        else
+          post[:pan]        = source.number
+          post[:expdate]    = expdate(source)
+          post[:cvd_value]  = source.verification_value if source.verification_value?
+          post[:cust_id]    = options[:customer] || source.name
+        end
       end
 
       # Common params used amongst the +credit+, +void+ and +capture+ methods
@@ -122,10 +168,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters = {})
-        response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(action, parameters)))
+        data = post_data(action, parameters)
+        url = test? ? self.test_url : self.live_url
+        raw = ssl_post(url, data)
+        response = parse(raw)
 
         Response.new(successful?(response), message_from(response[:message]), response,
           :test          => test?,
+          :avs_result    => { :code => response[:avs_result_code] },
+          :cvv_result    => response[:cvd_result_code] && response[:cvd_result_code][-1,1],
           :authorization => authorization_from(response)
         )
       end
@@ -163,14 +214,49 @@ module ActiveMerchant #:nodoc:
         root  = xml.add_element("request")
         root.add_element("store_id").text  = options[:login]
         root.add_element("api_token").text = options[:password]
-        transaction = root.add_element(action)
+        root.add_element(transaction_element(action, parameters))
+
+        xml.to_s
+      end
+
+      def transaction_element(action, parameters)
+        transaction = REXML::Element.new(action)
 
         # Must add the elements in the correct order
         actions[action].each do |key|
-          transaction.add_element(key.to_s).text = parameters[key] unless parameters[key].blank?
+          case key
+          when :avs_info
+            transaction.add_element(avs_element(parameters[:address])) if @avs_enabled && parameters[:address]
+          when :cvd_info
+            transaction.add_element(cvd_element(parameters[:cvd_value])) if @cvv_enabled
+          else
+            transaction.add_element(key.to_s).text = parameters[key] unless parameters[key].blank?
+          end
         end
 
-        xml.to_s
+        transaction
+      end
+
+      def avs_element(address)
+        full_address = "#{address[:address1]} #{address[:address2]}"
+        tokens = full_address.split(/\s+/)
+
+        element = REXML::Element.new('avs_info')
+        element.add_element('avs_street_number').text = tokens.select{|x| x =~ /\d/}.join(' ')
+        element.add_element('avs_street_name').text = tokens.reject{|x| x =~ /\d/}.join(' ')
+        element.add_element('avs_zipcode').text = address[:zip]
+        element
+      end
+
+      def cvd_element(cvd_value)
+        element = REXML::Element.new('cvd_info')
+        if cvd_value
+          element.add_element('cvd_indicator').text = "1"
+          element.add_element('cvd_value').text = cvd_value
+        else
+          element.add_element('cvd_indicator').text = "0"
+        end
+        element
       end
 
       def message_from(message)
@@ -180,17 +266,24 @@ module ActiveMerchant #:nodoc:
 
       def actions
         {
-          "us_purchase"           => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type],
-          "us_preauth"            => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type],
+          "us_purchase"           => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type, :avs_info, :cvd_info],
+          "us_preauth"            => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type, :avs_info, :cvd_info],
+          "us_command"            => [:order_id],
           "us_refund"             => [:order_id, :amount, :txn_number, :crypt_type],
-          "us_ind_refund"         => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type],
+          "us_indrefund"          => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type],
           "us_completion"         => [:order_id, :comp_amount, :txn_number, :crypt_type],
           "us_purchasecorrection" => [:order_id, :txn_number, :crypt_type],
-          "us_cavv_purchase"      => [:order_id, :cust_id, :amount, :pan, :expdate, :cavv],
-          "us_cavv_preauth"       => [:order_id, :cust_id, :amount, :pan, :expdate, :cavv],
-          "us_batchcloseall"      => [],
+          "us_cavvpurcha"         => [:order_id, :cust_id, :amount, :pan, :expdate, :cav],
+          "us_cavvpreaut"         => [:order_id, :cust_id, :amount, :pan, :expdate, :cavv],
+          "us_transact"           => [:order_id, :cust_id, :amount, :pan, :expdate, :crypt_type],
+          "us_Batchcloseall"      => [],
           "us_opentotals"         => [:ecr_number],
-          "us_batchclose"         => [:ecr_number]
+          "us_batchclose"         => [:ecr_number],
+          "us_res_add_cc"         => [:pan, :expdate, :crypt_type],
+          "us_res_delete"         => [:data_key],
+          "us_res_update_cc"      => [:data_key, :pan, :expdate, :crypt_type],
+          "us_res_purchase_cc"    => [:data_key, :order_id, :cust_id, :amount, :crypt_type],
+          "us_res_preauth_cc"     => [:data_key, :order_id, :cust_id, :amount, :crypt_type]
         }
       end
     end

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

@@ -9,7 +9,6 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'MoneyMovers'
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
-      self.ssl_version = :SSLv3
 
       def initialize(options = {})
         requires!(options, :login, :password)

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

@@ -151,7 +151,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/network_merchants.rb

@@ -60,7 +60,7 @@ module ActiveMerchant #:nodoc:
         add_address(post, options)
         add_shipping_address(post, options)
         add_payment_method(post, creditcard_or_vault_id, options)
-        add_amount(post, money)
+        add_amount(post, money, options)
         post
       end
 
@@ -68,10 +68,10 @@ module ActiveMerchant #:nodoc:
         build_auth_post(money, creditcard, options)
       end
 
-      def build_capture_post(money, authorization, option)
+      def build_capture_post(money, authorization, options)
         post = {}
         post[:transactionid] = authorization
-        add_amount(post, money)
+        add_amount(post, money, options)
         post
       end
 
@@ -84,7 +84,7 @@ module ActiveMerchant #:nodoc:
       def build_refund_post(money, authorization, options)
         post = {}
         post[:transactionid] = authorization
-        add_amount(post, money)
+        add_amount(post, money, options)
         post
       end
 
@@ -184,7 +184,7 @@ module ActiveMerchant #:nodoc:
         post[:password] = @options[:password]
       end
 
-      def add_amount(post, money)
+      def add_amount(post, money, options)
         post[:currency] = options[:currency] || currency(money)
         post[:amount] = amount(money)
       end

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

@@ -1,20 +1,256 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    class NmiGateway < AuthorizeNetGateway
+    class NmiGateway < Gateway
+      API_VERSION = '3.1'
+
       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_attribute :duplicate_window
+
+      APPROVED, DECLINED, ERROR, FRAUD_REVIEW = 1, 2, 3, 4
+
+      RESPONSE_CODE, RESPONSE_REASON_CODE, RESPONSE_REASON_TEXT, AUTHORIZATION_CODE = 0, 2, 3, 4
+      AVS_RESULT_CODE, TRANSACTION_ID, CARD_CODE_RESPONSE_CODE, CARDHOLDER_AUTH_CODE = 5, 6, 38, 39
+
+      self.default_currency = 'USD'
+
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://nmi.com/'
+      self.display_name = 'NMI'
+
+      CARD_CODE_ERRORS = %w( N S )
+      AVS_ERRORS = %w( A E N R W Z )
+      AVS_REASON_CODES = %w(27 45)
+      TRANSACTION_ALREADY_ACTIONED = %w(310 311)
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, paysource, options = {})
+        post = {}
+        add_currency_code(post, money, options)
+        add_invoice(post, options)
+        add_payment_source(post, paysource, options)
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_duplicate_window(post)
+
+        commit('AUTH_ONLY', money, post)
+      end
+
+      def purchase(money, paysource, options = {})
+        post = {}
+        add_currency_code(post, money, options)
+        add_invoice(post, options)
+        add_payment_source(post, paysource, options)
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_duplicate_window(post)
+
+        commit('AUTH_CAPTURE', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {:trans_id => authorization}
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        commit('PRIOR_AUTH_CAPTURE', money, post)
+      end
+
+      def void(authorization, options = {})
+        post = {:trans_id => authorization}
+        add_duplicate_window(post)
+        commit('VOID', nil, post)
+      end
+
+      def refund(money, identification, options = {})
+        requires!(options, :card_number)
+
+        post = { :trans_id => identification,
+                 :card_num => options[:card_number]
+               }
+
+        post[:first_name] = options[:first_name] if options[:first_name]
+        post[:last_name] = options[:last_name] if options[:last_name]
+        post[:zip] = options[:zip] if options[:zip]
+
+        add_invoice(post, options)
+        add_duplicate_window(post)
+
+        commit('CREDIT', money, post)
+      end
+
+      def credit(money, identification, options = {})
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, 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
 
       private
+
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money) unless action == 'VOID'
+
+        url = test? ? self.test_url : self.live_url
+        data = ssl_post(url, post_data(action, parameters))
+
+        response          = parse(data)
+        response[:action] = action
+
+        message = message_from(response)
+
+        Response.new(success?(response), message, response,
+          :test => test?,
+          :authorization => response[:transaction_id],
+          :fraud_review => fraud_review?(response),
+          :avs_result => { :code => response[:avs_result_code] },
+          :cvv_result => response[:card_code]
+        )
+      end
+
+      def success?(response)
+        response[:response_code] == APPROVED && TRANSACTION_ALREADY_ACTIONED.exclude?(response[:response_reason_code])
+      end
+
+      def fraud_review?(response)
+        response[:response_code] == FRAUD_REVIEW
+      end
+
+      def parse(body)
+        fields = split(body)
+
+        results = {
+          :response_code => fields[RESPONSE_CODE].to_i,
+          :response_reason_code => fields[RESPONSE_REASON_CODE],
+          :response_reason_text => fields[RESPONSE_REASON_TEXT],
+          :avs_result_code => fields[AVS_RESULT_CODE],
+          :transaction_id => fields[TRANSACTION_ID],
+          :card_code => fields[CARD_CODE_RESPONSE_CODE],
+          :authorization_code => fields[AUTHORIZATION_CODE],
+          :cardholder_authentication_code => fields[CARDHOLDER_AUTH_CODE]
+        }
+        results
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+
+        post[:version]        = API_VERSION
+        post[:login]          = @options[:login]
+        post[:tran_key]       = @options[:password]
+        post[:relay_response] = "FALSE"
+        post[:type]           = action
+        post[:delim_data]     = "TRUE"
+        post[:delim_char]     = ","
+        post[:encap_char]     = "$"
+        post[:solution_ID]    = application_id if application_id.present? && application_id != "ActiveMerchant"
+
+        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+
+      def add_currency_code(post, money, options)
+        post[:currency_code] = options[:currency] || currency(money)
+      end
+
+      def add_invoice(post, options)
+        post[:invoice_num] = options[:order_id]
+        post[:description] = options[:description]
+      end
+
       def add_creditcard(post, creditcard, options={})
-        super
+        post[:card_num]   = creditcard.number
+        post[:card_code]  = creditcard.verification_value if creditcard.verification_value?
+        post[:exp_date]   = expdate(creditcard)
+        post[:first_name] = creditcard.first_name
+        post[:last_name]  = creditcard.last_name
+
         post[:recurring_billing] = "TRUE" if options[:recurring]
       end
-    end
 
+      def add_payment_source(params, source, options={})
+        add_creditcard(params, source, options)
+      end
+
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+          post[:email_customer] = false
+        end
+
+        if options.has_key? :customer
+          post[:cust_id] = options[:customer] if Float(options[:customer]) rescue nil
+        end
+
+        if options.has_key? :ip
+          post[:customer_ip] = options[:ip]
+        end
+
+        if options.has_key? :cardholder_authentication_value
+          post[:cardholder_authentication_value] = options[:cardholder_authentication_value]
+        end
+
+        if options.has_key? :authentication_indicator
+          post[:authentication_indicator] = options[:authentication_indicator]
+        end
+
+      end
+
+      def add_duplicate_window(post)
+        unless duplicate_window.nil?
+          post[:duplicate_window] = duplicate_window
+        end
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address] = address[:address1].to_s
+          post[:company] = address[:company].to_s
+          post[:phone]   = address[:phone].to_s
+          post[:zip]     = address[:zip].to_s
+          post[:city]    = address[:city].to_s
+          post[:country] = address[:country].to_s
+          post[:state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+
+        if address = options[:shipping_address]
+          post[:ship_to_first_name] = address[:first_name].to_s
+          post[:ship_to_last_name] = address[:last_name].to_s
+          post[:ship_to_address] = address[:address1].to_s
+          post[:ship_to_company] = address[:company].to_s
+          post[:ship_to_phone]   = address[:phone].to_s
+          post[:ship_to_zip]     = address[:zip].to_s
+          post[:ship_to_city]    = address[:city].to_s
+          post[:ship_to_country] = address[:country].to_s
+          post[:ship_to_state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+      end
+
+      def message_from(results)
+        if results[:response_code] == DECLINED
+          return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
+          if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
+            return AVSResult.messages[ results[:avs_result_code] ]
+          end
+        end
+
+        (results[:response_reason_text] ? results[:response_reason_text].chomp('.') : '')
+      end
+
+      def split(response)
+        response[1..-2].split(/\$,\$/)
+      end
+    end
   end
 end