activemerchant 1.28.0 → 1.29.0

data/lib/active_merchant/billing/gateways/orbital/avs_result.rb

@@ -0,0 +1,93 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class OrbitalGateway < Gateway
+      # Unfortunately, Orbital uses their own special codes for AVS responses
+      # that are different than the standard codes defined in
+      # <tt>ActiveMerchant::Billing::AVSResult</tt>.
+      #
+      # This class encapsulates the response codes shown on page 240 of their spec:
+      # http://download.chasepaymentech.com/docs/orbital/orbital_gateway_xml_specification.pdf
+      #
+      class AVSResult < ActiveMerchant::Billing::AVSResult
+        CODES = {
+            '1'  => 'No address supplied',
+            '2'  => 'Bill-to address did not pass Auth Host edit checks',
+            '3'  => 'AVS not performed',
+            '4'  => 'Issuer does not participate in AVS',
+            '5'  => 'Edit-error - AVS data is invalid',
+            '6'  => 'System unavailable or time-out',
+            '7'  => 'Address information unavailable',
+            '8'  => 'Transaction Ineligible for AVS',
+            '9'  => 'Zip Match/Zip 4 Match/Locale match',
+            'A'  => 'Zip Match/Zip 4 Match/Locale no match',
+            'B'  => 'Zip Match/Zip 4 no Match/Locale match',
+            'C'  => 'Zip Match/Zip 4 no Match/Locale no match',
+            'D'  => 'Zip No Match/Zip 4 Match/Locale match',
+            'E'  => 'Zip No Match/Zip 4 Match/Locale no match',
+            'F'  => 'Zip No Match/Zip 4 No Match/Locale match',
+            'G'  => 'No match at all',
+            'H'  => 'Zip Match/Locale match',
+            'J'  => 'Issuer does not participate in Global AVS',
+            'JA' => 'International street address and postal match',
+            'JB' => 'International street address match. Postal code not verified',
+            'JC' => 'International street address and postal code not verified',
+            'JD' => 'International postal code match. Street address not verified',
+            'M1' => 'Merchant Override Decline',
+            'M2' => 'Cardholder name, billing address, and postal code matches',
+            'M3' => 'Cardholder name and billing code matches',
+            'M4' => 'Cardholder name and billing address matches',
+            'M5' => 'Cardholder name incorrect, billing address and postal code match',
+            'M6' => 'Cardholder name incorrect, billing address matches',
+            'M7' => 'Cardholder name incorrect, billing address matches',
+            'M8' => 'Cardholder name, billing address and postal code are all incorrect',
+            'N3' => 'Address matches, ZIP not verified',
+            'N4' => 'Address and ZIP code not verified due to incompatible formats',
+            'N5' => 'Address and ZIP code match (International only)',
+            'N6' => 'Address not verified (International only)',
+            'N7' => 'ZIP matches, address not verified',
+            'N8' => 'Address and ZIP code match (International only)',
+            'N9' => 'Address and ZIP code match (UK only)',
+            'R'  => 'Issuer does not participate in AVS',
+            'UX' => 'Unknown',
+            'X'  => 'Zip Match/Zip 4 Match/Address Match',
+            'Z'  => 'Zip Match/Locale no match',
+        }
+
+        # Map vendor's AVS result code to a postal match code
+        ORBITAL_POSTAL_MATCH_CODE = {
+            'Y' => %w( 9 A B C H JA JD M2 M3 M5 N5 N8 N9 X Z ),
+            'N' => %w( D E F G M8 ),
+            'X' => %w( 4 J R ),
+            nil => %w( 1 2 3 5 6 7 8 JB JC M1 M4 M6 M7 N3 N4 N6 N7 UX )
+        }.inject({}) do |map, (type, codes)|
+          codes.each { |code| map[code] = type }
+          map
+        end
+
+        # Map vendor's AVS result code to a street match code
+        ORBITAL_STREET_MATCH_CODE = {
+            'Y' => %w( 9 B D F H JA JB M2 M4 M5 M6 M7 N3 N5 N7 N8 N9 X ),
+            'N' => %w( A C E G M8 Z ),
+            'X' => %w( 4 J R ),
+            nil => %w( 1 2 3 5 6 7 8 JC JD M1 M3 N4 N6 UX )
+        }.inject({}) do |map, (type, codes)|
+          codes.each { |code| map[code] = type }
+          map
+        end
+
+        def self.messages
+          CODES
+        end
+
+        def initialize(code)
+          @code = code.to_s.strip.upcase unless code.blank?
+          if @code
+            @message      = CODES[@code]
+            @postal_match = ORBITAL_POSTAL_MATCH_CODE[@code]
+            @street_match = ORBITAL_STREET_MATCH_CODE[@code]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -157,12 +157,11 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
 
       def purchase(money, creditcard, options = {})
-        MultiResponse.new.tap do |r|
+        MultiResponse.run do |r|
           r.process{authorize(money, creditcard, options)}
           r.process{capture(money, r.authorization, options)}
         end
@@ -182,10 +181,6 @@ module ActiveMerchant #:nodoc:
         commit(action, build_request(action, options))
       end
 
-      def test?
-        @options[:test] || (Base.gateway_mode == :test)
-      end
-
       private
 
       def successful?(response)

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

@@ -5,11 +5,11 @@ module ActiveMerchant #:nodoc:
     # This gateway accepts the following arguments:
     #   :login    => your PayJunction username
     #   :password => your PayJunction pass
-    # 
+    #
     # Example use:
     #
     #   gateway = ActiveMerchant::Billing::Base.gateway(:pay_junction).new(
-    #               :login => "my_account", 
+    #               :login => "my_account",
     #               :password => "my_pass"
     #            )
     #
@@ -51,14 +51,14 @@ module ActiveMerchant #:nodoc:
     # Test Transactions
     #
     # See the source for initialize() for test account information. Note that
-    # PayJunction does not allow test transactions on your account, so if the 
+    # PayJunction does not allow test transactions on your account, so if the
     # gateway is running in :test mode your transaction will be run against
     # PayJunction's global test account and will not show up in your account.
     #
-    # Transactions ran on this account go through a test processor, so there is no 
-    # need to void or otherwise cancel transactions. However, for further safety, 
-    # please use the special card numbers 4433221111223344 or 4444333322221111 and 
-    # keep transaction amounts below $4.00 when testing.  
+    # Transactions ran on this account go through a test processor, so there is no
+    # need to void or otherwise cancel transactions. However, for further safety,
+    # please use the special card numbers 4433221111223344 or 4444333322221111 and
+    # keep transaction amounts below $4.00 when testing.
     #
     # Also note, transactions ran for an amount between $0.00 and $1.99 will likely
     # result in denial. To demonstrate approvals, use amounts between $2.00 and $4.00.
@@ -67,12 +67,12 @@ module ActiveMerchant #:nodoc:
     # PayJunction Web Login with username 'pj-cm-01' and password 'pj-cm-01p'
     #
     # Usage Details
-    # 
+    #
     # Below is a map of values accepted by PayJunction and how you should submit
     # each to ActiveMerchant
     #
     # PayJunction Field       ActiveMerchant Use
-    # 
+    #
     # dc_logon                provide as :login value to gateway instantation
     # dc_password             provide as :password value to gateway instantiation
     #
@@ -106,12 +106,12 @@ module ActiveMerchant #:nodoc:
 
       TEST_LOGIN = 'pj-ql-01'
       TEST_PASSWORD = 'pj-ql-01p'
-      
+
       SUCCESS_CODES = ["00", "85"]
       SUCCESS_MESSAGE = 'The transaction was approved.'
-      
+
       FAILURE_MESSAGE = 'The transaction was declined.'
-      
+
       DECLINE_CODES = {
         "AE"  => 'Address verification failed because address did not match.',
         'ZE'  => 'Address verification failed because zip did not match.',
@@ -143,13 +143,13 @@ module ActiveMerchant #:nodoc:
         '15'  => 'Declined because there is no such issuer.',
         '96'  => 'Declined because of a system error.',
         'N7'  => 'Declined because of a CVV2/CVC2 mismatch.',
-        'M4'  => 'Declined.', 
+        'M4'  => 'Declined.',
         "FE"  => "There was a format error with your Trinity Gateway Service (API) request.",
         "LE"  => "Could not log you in (problem with dc_logon and/or dc_password).",
         'NL'  => 'Aborted because of a system error, please try again later. ',
         'AB'  => 'Aborted because of an upstream system error, please try again later.'
       }
-      
+
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.supported_countries = ['US']
       self.homepage_url = 'http://www.payjunction.com/'
@@ -157,31 +157,30 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
-      
+
       # The first half of the preauth(authorize)/postauth(capture) model.
       # Checks to make sure funds are available for a transaction, and returns a
       # transaction_id that can be used later to postauthorize (capture) the funds.
       def authorize(money, payment_source, options = {})
         parameters = {
           :transaction_amount => amount(money),
-        }                                                             
-        
+        }
+
         add_payment_source(parameters, payment_source)
         add_address(parameters, options)
         add_optional_fields(parameters, options)
         commit('AUTHORIZATION', parameters)
       end
-      
+
       # A simple sale, capturing funds immediately.
       # Execute authorization and capture in a single step.
-      def purchase(money, payment_source, options = {})        
+      def purchase(money, payment_source, options = {})
         parameters = {
           :transaction_amount => amount(money),
-        }                                                             
-        
+        }
+
         add_payment_source(parameters, payment_source)
         add_address(parameters, options)
         add_optional_fields(parameters, options)
@@ -195,14 +194,14 @@ module ActiveMerchant #:nodoc:
           :transaction_id => authorization,
           :posture => 'capture'
         }
-        
-        add_optional_fields(parameters, options)                                          
+
+        add_optional_fields(parameters, options)
         commit('update', parameters)
       end
-      
+
       # Return money to a card that was previously billed.
       # _authorization_ should be the transaction id of the transaction we are returning.
-      def refund(money, authorization, options = {})  
+      def refund(money, authorization, options = {})
         parameters = {
           :transaction_amount => amount(money),
           :transaction_id => authorization
@@ -228,7 +227,7 @@ module ActiveMerchant #:nodoc:
         commit('update', parameters)
       end
 
-      # Set up a sale that will be made on a regular basis for the same amount 
+      # Set up a sale that will be made on a regular basis for the same amount
       # (ex. $20 a month for 12 months)
       #
       # The parameter :periodicity should be specified as either :monthly, :weekly, or :daily
@@ -236,12 +235,12 @@ module ActiveMerchant #:nodoc:
       #
       #   gateway.recurring('2000', creditcard, :periodicity => :monthly, :payments => 12)
       #
-      # The optional parameter :starting_at takes a date or time argument or a string in 
-      # YYYYMMDD format and can be used to specify when the first charge will be made. 
-      # If omitted the first charge will be immediate.      
-      def recurring(money, payment_source, options = {})        
+      # The optional parameter :starting_at takes a date or time argument or a string in
+      # YYYYMMDD format and can be used to specify when the first charge will be made.
+      # If omitted the first charge will be immediate.
+      def recurring(money, payment_source, options = {})
         requires!(options, [:periodicity, :monthly, :weekly, :daily], :payments)
-      
+
         periodic_type = case options[:periodicity]
         when :monthly
           'month'
@@ -250,7 +249,7 @@ module ActiveMerchant #:nodoc:
         when :daily
           'day'
         end
-        
+
         if options[:starting_at].nil?
           start_date = Time.now.strftime('%Y-%m-%d')
         elsif options[:starting_at].is_a?(String)
@@ -259,7 +258,7 @@ module ActiveMerchant #:nodoc:
         else
           start_date = options[:starting_at].strftime('%Y-%m-%d')
         end
-        
+
         parameters = {
           :transaction_amount => amount(money),
           :schedule_periodic_type => periodic_type,
@@ -268,23 +267,23 @@ module ActiveMerchant #:nodoc:
           :schedule_periodic_number => 1,
           :schedule_start => start_date
         }
-        
+
         add_payment_source(parameters, payment_source)
         add_optional_fields(parameters, options)
-        add_address(parameters, options)                                   
+        add_address(parameters, options)
         commit('AUTHORIZATION_CAPTURE', parameters)
       end
-      
+
       def test?
-        test_login? || @options[:test] || super
+        (test_login? || super)
       end
 
       private
-      
+
       def test_login?
         @options[:login] == TEST_LOGIN && @options[:password] == TEST_PASSWORD
       end
-      
+
       # add fields depending on payment source selected (cc or transaction id)
       def add_payment_source(params, source)
         if source.is_a?(String)
@@ -293,54 +292,54 @@ module ActiveMerchant #:nodoc:
           add_creditcard(params, source)
         end
       end
-      
+
       # add fields for credit card
       def add_creditcard(params, creditcard)
         params[:name]                 = creditcard.name
         params[:number]               = creditcard.number
         params[:expiration_month]     = creditcard.month
-        params[:expiration_year]      = creditcard.year 
+        params[:expiration_year]      = creditcard.year
         params[:verification_number]  = creditcard.verification_value if creditcard.verification_value?
       end
-      
+
       # add field for "instant" transaction, using previous transaction id
       def add_billing_id(params, billingid)
         params[:transaction_id] = billingid
       end
-      
+
       # add address fields if present
       def add_address(params, options)
         address = options[:billing_address] || options[:address]
-        
-        if address          
+
+        if address
           params[:address]  = address[:address1] unless address[:address1].blank?
           params[:city]      = address[:city]     unless address[:city].blank?
           params[:state]     = address[:state]    unless address[:state].blank?
           params[:zipcode]   = address[:zip]      unless address[:zip].blank?
           params[:country]   = address[:country]  unless address[:country].blank?
-        end     
+        end
       end
-      
+
       def add_optional_fields(params, options)
         params[:notes] = options[:description] unless options[:description].blank?
         params[:invoice] = options[:order_id].to_s.gsub(/[^-\/\w.,']/, '') unless options[:order_id].blank?
       end
-      
+
       def commit(action, parameters)
         url = test? ? self.test_url : self.live_url
 
         response = parse( ssl_post(url, post_data(action, parameters)) )
-        
-        Response.new(successful?(response), message_from(response), response, 
-          :test => test?, 
+
+        Response.new(successful?(response), message_from(response), response,
+          :test => test?,
           :authorization => response[:transaction_id] || parameters[:transaction_id]
         )
       end
-      
+
       def successful?(response)
         SUCCESS_CODES.include?(response[:response_code]) || response[:query_status] == true
       end
-      
+
       def message_from(response)
         if successful?(response)
           SUCCESS_MESSAGE
@@ -348,7 +347,7 @@ module ActiveMerchant #:nodoc:
           DECLINE_CODES[response[:response_code]] || FAILURE_MESSAGE
         end
       end
-      
+
       def post_data(action, params)
         if test?
           # test requests must use global test account
@@ -360,18 +359,18 @@ module ActiveMerchant #:nodoc:
         end
         params[:version] = API_VERSION
         params[:transaction_type] = action
-        
+
         params.reject{|k,v| v.blank?}.collect{ |k, v| "dc_#{k.to_s}=#{CGI.escape(v.to_s)}" }.join("&")
       end
-      
+
       def parse(body)
         # PayJunction uses the Field Separator ASCII character to separate key/val
         # pairs in the response. The <FS> character's octal value is 034.
         #
         # Sample response:
-        # 
-        # transaction_id=44752<FS>response_code=M4<FS>response_message=Declined (INV TEST CARD).  
-        
+        #
+        # transaction_id=44752<FS>response_code=M4<FS>response_message=Declined (INV TEST CARD).
+
         pairs = body.chomp.split("\034")
         response = {}
         pairs.each do |pair|
@@ -380,7 +379,7 @@ module ActiveMerchant #:nodoc:
         end
         response
       end
-      
+
       # Make a ruby type out of the response string
       def normalize(field)
         case field
@@ -389,9 +388,9 @@ module ActiveMerchant #:nodoc:
         when ""       then nil
         when "null"   then nil
         else field
-        end        
+        end
       end
-      
+
     end
   end
 end

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

@@ -2,7 +2,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class PaySecureGateway < Gateway
       self.live_url = self.test_url = 'https://clearance.commsecure.com.au/cgi-bin/PSDirect'
-      
+
       self.money_format = :cents
 
       # Currently Authorization and Capture is not implemented because
@@ -10,13 +10,13 @@ module ActiveMerchant #:nodoc:
       TRANSACTIONS = {
         :purchase       => 'PURCHASE',
         :authorization  => 'AUTHORISE',
-        :capture        => 'ADVICE', 
+        :capture        => 'ADVICE',
         :credit         => 'REFUND'
       }
-      
+
       SUCCESS = 'Accepted'
       SUCCESS_MESSAGE = 'The transaction was approved'
-      
+
       self.supported_countries = ['AU']
       self.homepage_url = 'http://www.commsecure.com.au/paysecure.shtml'
       self.display_name = 'PaySecure'
@@ -24,21 +24,20 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
-      end  
+      end
 
       def purchase(money, credit_card, options = {})
         requires!(options, :order_id)
-        
+
         post = {}
         add_amount(post, money)
         add_invoice(post, options)
-        add_credit_card(post, credit_card)        
-             
+        add_credit_card(post, credit_card)
+
         commit(:purchase, money, post)
-      end                       
-         
+      end
+
       private
       # Used for capturing, which is currently not supported.
       def add_reference(post, identification)
@@ -46,72 +45,72 @@ module ActiveMerchant #:nodoc:
         post[:authnum]    = auth
         post[:transid] = trans_id
       end
-      
+
       def add_amount(post, money)
         post[:amount] = amount(money)
       end
-      
+
       def add_invoice(post, options)
         post[:merchant_transid] = options[:order_id].to_s.slice(0,21)
         post[:memnum]           = options[:invoice]
         post[:custnum]          = options[:customer]
         post[:clientdata]       = options[:description]
       end
-      
-      def add_credit_card(post, credit_card)      
+
+      def add_credit_card(post, credit_card)
         post[:cardnum]  = credit_card.number
         post[:cardname] = credit_card.name
         post[:expiry]   = expdate(credit_card)
         post[:cvv2]     = credit_card.verification_value
       end
-      
+
       def expdate(credit_card)
         year  = sprintf("%.4i", credit_card.year)
         month = sprintf("%.2i", credit_card.month)
 
         "#{month}#{year[-2..-1]}"
       end
-       
+
       def commit(action, money, parameters)
         response = parse( ssl_post(self.live_url, post_data(action, parameters)) )
-        
-        Response.new(successful?(response), message_from(response), response, 
-          :test => test_response?(response), 
+
+        Response.new(successful?(response), message_from(response), response,
+          :test => test_response?(response),
           :authorization => authorization_from(response)
         )
-        
+
       end
-      
+
       def successful?(response)
         response[:status] == SUCCESS
       end
-      
+
       def authorization_from(response)
         [ response[:authnum], response[:transid] ].compact.join(";")
       end
-      
+
       def test_response?(response)
         !!(response[:transid] =~ /SimProxy/)
       end
-      
+
       def message_from(response)
         successful?(response) ? SUCCESS_MESSAGE : response[:errorstring]
       end
-      
+
       def parse(body)
         response = {}
-        body.to_s.each_line do |l| 
+        body.to_s.each_line do |l|
           key, value = l.split(":", 2)
           response[key.to_s.downcase.to_sym] = value.strip
         end
         response
-      end 
-      
+      end
+
       def post_data(action, parameters = {})
         parameters[:request_type]     = TRANSACTIONS[action]
         parameters[:merchant_id]      = @options[:login]
         parameters[:password]         = @options[:password]
-        
+
         parameters.reject{|k,v| v.blank?}.collect { |key, value| "#{key.to_s.upcase}=#{CGI.escape(value.to_s)}" }.join("&")
       end
     end