activemerchant 1.28.0 → 1.29.1

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

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

@@ -60,7 +60,6 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
 
@@ -109,10 +108,6 @@ module ActiveMerchant #:nodoc:
         commit('refund', money, post)
       end
 
-      def test?
-        @options[:test] || Base.gateway_mode == :test
-      end
-
       private
 
       def add_invoice(post, options)

data/lib/active_merchant/billing/gateways/payflow/payflow_common_api.rb

@@ -3,20 +3,20 @@ module ActiveMerchant #:nodoc:
     module PayflowCommonAPI
       def self.included(base)
         base.default_currency = 'USD'
-          
+
         base.class_attribute :partner
-        
+
         # Set the default partner to PayPal
         base.partner = 'PayPal'
-        
+
         base.supported_countries = ['US', 'CA', 'SG', 'AU']
-        
+
         base.class_attribute :timeout
         base.timeout = 60
 
         base.test_url = 'https://pilot-payflowpro.paypal.com'
         base.live_url = 'https://payflowpro.paypal.com'
-        
+
         # Enable safe retry of failed connections
         # Payflow is safe to retry because retried transactions use the same
         # X-VPS-Request-ID header. If a transaction is detected as a duplicate
@@ -25,9 +25,9 @@ module ActiveMerchant #:nodoc:
         # hash.
         base.retry_safe = true
       end
-      
+
       XMLNS = 'http://www.paypal.com/XMLPay'
-      
+
       CARD_MAPPING = {
         :visa => 'Visa',
         :master => 'MasterCard',
@@ -38,45 +38,40 @@ module ActiveMerchant #:nodoc:
         :switch => 'Switch',
         :solo => 'Solo'
       }
-      
-      TRANSACTIONS = { 
+
+      TRANSACTIONS = {
         :purchase       => "Sale",
         :authorization  => "Authorization",
         :capture        => "Capture",
         :void           => "Void",
-        :credit         => "Credit" 
+        :credit         => "Credit"
       }
-      
+
       CVV_CODE = {
         'Match' => 'M',
         'No Match' => 'N',
-        'Service Not Available' => 'U', 
+        'Service Not Available' => 'U',
         'Service not Requested' => 'P'
       }
-          
+
       def initialize(options = {})
         requires!(options, :login, :password)
-        
-        @options = options
-        @options[:partner] = partner if @options[:partner].blank?
+
+        options[:partner] = partner if options[:partner].blank?
         super
-      end  
-      
-      def test?
-        @options[:test] || super
       end
-      
+
       def capture(money, authorization, options = {})
         request = build_reference_request(:capture, money, authorization, options)
         commit(request, options)
       end
-      
+
       def void(authorization, options = {})
         request = build_reference_request(:void, nil, authorization, options)
         commit(request, options)
       end
-  
-      private      
+
+      private
       def build_request(body, options = {})
         xml = Builder::XmlMarkup.new
         xml.instruct!
@@ -104,12 +99,12 @@ module ActiveMerchant #:nodoc:
         end
         xml.target!
       end
-      
+
       def build_reference_request(action, money, authorization, options)
         xml = Builder::XmlMarkup.new
         xml.tag! TRANSACTIONS[action] do
           xml.tag! 'PNRef', authorization
-        
+
           unless money.nil?
             xml.tag! 'Invoice' do
               xml.tag!('TotalAmt', amount(money), 'Currency' => options[:currency] || currency(money))
@@ -119,11 +114,11 @@ module ActiveMerchant #:nodoc:
             end
           end
         end
-        
+
         xml.target!
       end
 
-      def add_address(xml, tag, address, options)  
+      def add_address(xml, tag, address, options)
         return if address.nil?
         xml.tag! tag do
           xml.tag! 'Name', address[:name] unless address[:name].blank?
@@ -131,7 +126,7 @@ module ActiveMerchant #:nodoc:
           xml.tag! 'Phone', address[:phone] unless address[:phone].blank?
           xml.tag! 'CustCode', options[:customer] if !options[:customer].blank? && tag == 'BillTo'
           xml.tag! 'PONum', options[:po_number] if !options[:po_number].blank? && tag == 'BillTo'
-          
+
           xml.tag! 'Address' do
             xml.tag! 'Street', address[:address1] unless address[:address1].blank?
             xml.tag! 'City', address[:city] unless address[:city].blank?
@@ -141,26 +136,26 @@ module ActiveMerchant #:nodoc:
           end
         end
       end
-          
+
       def parse(data)
         response = {}
         xml = REXML::Document.new(data)
         root = REXML::XPath.first(xml, "//ResponseData")
-        
+
         # REXML::XPath in Ruby 1.8.6 is now unable to match nodes based on their attributes
         tx_result = REXML::XPath.first(root, "//TransactionResult")
-        
+
         if tx_result && tx_result.attributes['Duplicate'] == "true"
-          response[:duplicate] = true 
+          response[:duplicate] = true
         end
-        
+
         root.elements.to_a.each do |node|
           parse_element(response, node)
         end
 
         response
       end
-      
+
       def parse_element(response, node)
         node_name = node.name.underscore.to_sym
         case
@@ -182,7 +177,7 @@ module ActiveMerchant #:nodoc:
           response[node_name] = node.text
         end
       end
-      
+
       def build_headers(content_length)
         {
           "Content-Type" => "text/xml",
@@ -193,11 +188,11 @@ module ActiveMerchant #:nodoc:
       	  "X-VPS-Request-ID" => Utils.generate_unique_id
     	  }
     	end
-    	
+
     	def commit(request_body, options  = {})
         request = build_request(request_body, options)
         headers = build_headers(request.size)
-        
+
     	  response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
 
     	  build_response(response[:result] == "0", response[:message], response,