activemerchant 1.2.1 → 1.3.0

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

@@ -2,10 +2,6 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class TransFirstGateway < Gateway
       URL = 'https://webservices.primerchants.com/creditcard.asmx/CCSale'
-      
-      attr_reader :url 
-      attr_reader :response
-      attr_reader :options
 
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
@@ -94,18 +90,13 @@ module ActiveMerchant #:nodoc:
       end
       
       def commit(params) 
-        if result = test_result_from_cc_number(params[:CardNumber])
-          return result
-        end
-  
-        data = ssl_post URL, post_data(params)
-        
-        @response = parse(data)  
-        success = @response[:status] == "Authorized"
+        response = parse( ssl_post(URL, post_data(params)) )
 
-        Response.new(success, message_from(@response), @response, 
+        Response.new(response[:status] == "Authorized", message_from(response), response, 
           :test => test?, 
-          :authorization => @response[:trans_id]
+          :authorization => response[:trans_id],
+          :avs_result => { :code => response[:avs_code] },
+          :cvv_result => response[:cvv2_code]
         )
       end
       

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

@@ -1,16 +1,11 @@
 begin
   require 'tclink'
 rescue LoadError
-  # Ignore, but we will fail hard if someone actually tries to use this gateway 
+  # Falls back to an SSL post to TrustCommerce
 end
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    
-    # To get started using TrustCommerce with active_merchant, download the tclink library from http://www.trustcommerce.com/tclink.html,
-    # following the instructions available there to get it working on your system. Once it is installed, you should be able to make sure
-    # that it is visible to your ruby install by opening irb and typing "require 'tclink'", which should return "true".
-    #
     # TO USE:
     # First, make sure you have everything setup correctly and all of your dependencies in place with:
     # 
@@ -56,10 +51,22 @@ module ActiveMerchant #:nodoc:
     #
     #   response.params["transid"]
     #
+    # For higher performance and failover with the TrustCommerceGateway you can install the TCLink library from http://www.trustcommerce.com/tclink.html.
+    # Follow the instructions available there to get it working on your system. ActiveMerchant will automatically use tclink if available.
+    #
+    # The TCLink library has the following added benefits:
+    #  * Good transaction times. Transaction duration under 1.2 seconds are common.
+    #  * Fail-over to geographically distributed servers for extreme reliability
+    #
+    # Once it is installed, you should be able to make sure
+    # that it is visible to your ruby install by opening irb and typing "require 'tclink'", which should return "true".
+    #
     # This should be enough to get you started with Trust Commerce and active_merchant. For further information, review the methods
     # below and the rest of active_merchant's documentation, as well as Trust Commerce's user and developer documentation.
     
     class TrustCommerceGateway < Gateway
+      URL = 'https://vault.trustcommerce.com/trans/'
+      
       SUCCESS_TYPES = ["approved", "accepted"]
       
       DECLINE_CODES = {
@@ -94,17 +101,16 @@ module ActiveMerchant #:nodoc:
         "failtoprocess" => "The bank servers are offline and unable to authorize transactions"
       }
       
-      # URL
-      attr_reader :url 
-      attr_reader :response
-      attr_reader :options
-
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :discover, :american_express, :diners_club, :jcb]
       self.supported_countries = ['US']
       self.homepage_url = 'http://www.trustcommerce.com/'
       self.display_name = 'TrustCommerce'
       
+      def self.tclink?
+        defined?(TCLink)
+      end
+      
       # Creates a new TrustCommerceGateway
       # 
       # The gateway requires that a valid login and password be passed
@@ -126,8 +132,12 @@ module ActiveMerchant #:nodoc:
         super
       end
       
+      def tclink?
+        self.class.tclink?
+      end
+      
       def test?
-        @options[:test] || Base.gateway_mode == :test
+        @options[:test] || super
       end
       
       # authorize() is the first half of the preauth(authorize)/postauth(capture) model. The TC API docs call this
@@ -140,28 +150,30 @@ module ActiveMerchant #:nodoc:
           :amount => amount(money),
         }                                                             
         
+        add_order_id(parameters, options)
+        add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard_or_billing_id)
-        add_address(parameters, options)
+        add_addresses(parameters, options)
         commit('preauth', parameters)
       end
       
       # purchase() is a simple sale. This is one of the most common types of transactions, and is extremely simple. All that you need
       # to process a purchase are an amount in cents or a money object and a creditcard object or billingid string.
-      
       def purchase(money, creditcard_or_billing_id, options = {})        
         parameters = {
           :amount => amount(money),
         }                                                             
         
+        add_order_id(parameters, options)
+        add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard_or_billing_id)
-        add_address(parameters, options)
+        add_addresses(parameters, options)
         commit('sale', parameters)
       end
 
       # capture() is the second half of the preauth(authorize)/postauth(capture) model. The TC API docs call this
       # postauth, we preserve active_merchant's nomenclature of capture() for consistency with the rest of the library. To process
       # a postauthorization with TC, you need an amount in cents or a money object, and a TC transid.
-      
       def capture(money, authorization, options = {})
         parameters = {
           :amount => amount(money),
@@ -173,7 +185,6 @@ module ActiveMerchant #:nodoc:
       
       # credit() allows you to return money to a card that was previously billed. You need to supply the amount, in cents or a money object,
       # that you want to refund, and a TC transid for the transaction that you are refunding.
-      
       def credit(money, identification, options = {})  
         parameters = {
           :amount => amount(money),
@@ -183,6 +194,28 @@ module ActiveMerchant #:nodoc:
         commit('credit', parameters)
       end
       
+      # void() clears an existing authorization and releases the reserved fund
+      # s back to the cardholder. The TC API refers to this transaction as a 
+      # reversal. After voiding, you will no longer be able to capture funds 
+      # from this authorization. TrustCommerce seems to always return a status 
+      # of "accepted" even if the transid you are trying to deauthorize has 
+      # already been captured. Note: Your account needs to be configured by 
+      # TrustCommerce to allow for reversal transactions before you can use this 
+      # method. 
+      # 
+      # NOTE: AMEX preauth's cannot be reversed. If you want to clear it more 
+      # quickly than the automatic expiration (7-10 days), you will have to 
+      # capture it and then immediately issue a credit for the same amount 
+      # which should clear the customers credit card with 48 hours according to
+      # TC.
+      def void(authorization, options = {})
+        parameters = {
+          :transid => authorization,
+        }
+        
+        commit('reversal', parameters)
+      end
+      
       # recurring() a TrustCommerce account that is activated for Citatdel, TrustCommerce's
       # hosted customer billing info database.
       #
@@ -194,7 +227,6 @@ module ActiveMerchant #:nodoc:
       #   gateway.recurring(tendollar, creditcard, :periodicity => :weekly)
       #
       # You can optionally specify how long you want payments to continue using 'payments'
-            
       def recurring(money, creditcard, options = {})        
         requires!(options, [:periodicity, :bimonthly, :monthly, :biweekly, :weekly, :yearly, :daily] )
       
@@ -237,7 +269,7 @@ module ActiveMerchant #:nodoc:
         }
         
         add_creditcard(parameters, creditcard)
-        add_address(parameters, options)                              
+        add_addresses(parameters, options)                              
         commit('store', parameters)
       end
       
@@ -275,11 +307,20 @@ module ActiveMerchant #:nodoc:
         params[:cvv]       = creditcard.verification_value if creditcard.verification_value?
       end
       
+      def add_order_id(params, options)
+        params[:ticket] = options[:order_id] unless options[:order_id].blank?
+      end
+      
       def add_billing_id(params, billingid)
         params[:billingid] = billingid
       end
       
-      def add_address(params, options)
+      def add_customer_data(params, options)
+        params[:email] = options[:email] unless options[:email].blank?
+        params[:ip] = options[:ip] unless options[:ip].blank?
+      end
+      
+      def add_addresses(params, options)
         address = options[:billing_address] || options[:address]
         
         if address          
@@ -290,7 +331,17 @@ module ActiveMerchant #:nodoc:
           params[:zip]       = address[:zip]      unless address[:zip].blank?
           params[:country]   = address[:country]  unless address[:country].blank?
           params[:avs]       = 'n'
-        end        
+        end
+        
+        if shipping_address = options[:shipping_address]
+          params[:shipto_name]     = shipping_address[:name]     unless shipping_address[:name].blank?
+          params[:shipto_address1] = shipping_address[:address1] unless shipping_address[:address1].blank?
+          params[:shipto_address2] = shipping_address[:address2] unless shipping_address[:address2].blank?
+          params[:shipto_city]     = shipping_address[:city]     unless shipping_address[:city].blank?
+          params[:shipto_state]    = shipping_address[:state]    unless shipping_address[:state].blank?
+          params[:shipto_zip]	     = shipping_address[:zip]      unless shipping_address[:zip].blank?
+          params[:shipto_country]  = shipping_address[:country]  unless shipping_address[:country].blank?
+        end
       end
       
       def clean_and_stringify_params(parameters)
@@ -304,35 +355,45 @@ module ActiveMerchant #:nodoc:
           parameters.delete(key)
         end
       end
+      
+      def post_data(parameters)
+        parameters.collect { |key, value| "#{key}=#{ CGI.escape(value.to_s)}" }.join("&")
+      end
   
       def commit(action, parameters)
-        test = test? || parameters[:test_request]
         parameters[:custid]      = @options[:login]
         parameters[:password]    = @options[:password]
-        parameters[:demo]        = test ? 'y' : 'n'
+        parameters[:demo]        = test? ? 'y' : 'n'
         parameters[:action]      = action
                 
-        if result = test_result_from_cc_number(parameters[:cc])
-          return result
+        clean_and_stringify_params(parameters)
+        
+        data = if tclink?
+          TCLink.send(parameters)
+        else
+          parse( ssl_post(URL, post_data(parameters)) )
         end
         
-        begin        
-          clean_and_stringify_params(parameters)
+        # to be considered successful, transaction status must be either "approved" or "accepted"
+        success = SUCCESS_TYPES.include?(data["status"])
+        message = message_from(data)
+        Response.new(success, message, data, 
+          :test => test?, 
+          :authorization => data["transid"],
+          :cvv_result => data["cvv"],
+          :avs_result => { :code => data["avs"] }
+        )
+      end
+      
+      def parse(body)
+        results = {}
         
-          data = TCLink.send(parameters)
-          # to be considered successful, transaction status must be either "approved" or "accepted"
-          success = SUCCESS_TYPES.include?(data["status"])
-          message = message_from(data)
-       
-          Response.new(success, message, data, :test => test, :authorization => data["transid"] )
-        rescue NameError => e 
-          if e.message =~ /constant TCLink/
-            raise 'Trust Commerce requires "tclink" library from http://www.trustcommerce.com/tclink.html'        
-          else
-            raise
-          end
+        body.split(/\n/).each do |pair|
+          key,val = pair.split(/=/)
+          results[key] = val
         end
         
+        results
       end
       
       def message_from(data)        

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

@@ -2,54 +2,67 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
         
     class UsaEpayGateway < Gateway
-    	GATEWAY_URL = 'https://www.usaepay.com/gate.php'
-      POST_HEADERS = { 'Content-Type' => 'application/x-www-form-urlencoded' }
-      
-      attr_reader :url 
-      attr_reader :response
-      attr_reader :options
+    	URL = 'https://www.usaepay.com/gate.php'
       
       self.supported_cardtypes = [:visa, :master, :american_express]
       self.supported_countries = ['US']
-      self.homepage_url = 'http://www.usa_epay.com/'
+      self.homepage_url = 'http://www.usaepay.com/'
       self.display_name = 'USA ePay'
 
+      TRANSACTIONS = {
+        :authorization => 'authonly',
+        :purchase => 'sale',
+        :capture => 'capture'
+      }
+
       def initialize(options = {})
         requires!(options, :login)
         @options = options
         super
       end  
       
-      def authorize(money, creditcard, options = {})
+      def authorize(money, credit_card, options = {})
         post = {}
+        
+        add_amount(post, money)
         add_invoice(post, options)
-        add_creditcard(post, creditcard)        
-        add_address(post, creditcard, options)        
+        add_credit_card(post, credit_card)        
+        add_address(post, credit_card, options)        
         add_customer_data(post, options)
         
-        commit('authonly', money, post)
+        commit(:authorization, post)
       end
       
-      def purchase(money, creditcard, options = {})
+      def purchase(money, credit_card, options = {})
         post = {}
+        
+        add_amount(post, money)
         add_invoice(post, options)
-        add_creditcard(post, creditcard)        
-        add_address(post, creditcard, options)   
+        add_credit_card(post, credit_card)        
+        add_address(post, credit_card, options)   
         add_customer_data(post, options)
              
-        commit('sale', money, post)
+        commit(:purchase, post)
       end                       
     
       def capture(money, authorization, options = {})
-        post = {:refNum => authorization}
-        commit('capture', money, post)
+        post = {
+          :refNum => authorization
+        }
+        
+        add_amount(post, money)
+        commit(:capture, post)
       end
        
       private                       
     
-      def expdate(creditcard)
-        year  = format(creditcard.year, :two_digits)
-        month = format(creditcard.month, :two_digits)
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+      
+      def expdate(credit_card)
+        year  = format(credit_card.year, :two_digits)
+        month = format(credit_card.month, :two_digits)
 
         "#{month}#{year}"
       end
@@ -73,19 +86,18 @@ module ActiveMerchant #:nodoc:
         end        
       end
 
-      def add_address(post, creditcard, options)
+      def add_address(post, credit_card, options)
         billing_address = options[:billing_address] || options[:address]
-        shipping_address = options[:shipping_address] || billing_address
         
-        add_address_for_type(:billing, post, creditcard, billing_address) unless billing_address.nil?
-        add_address_for_type(:shipping, post, creditcard, shipping_address) unless shipping_address.nil?
+        add_address_for_type(:billing, post, credit_card, billing_address) if billing_address
+        add_address_for_type(:shipping, post, credit_card, options[:shipping_address]) if options[:shipping_address]
       end
 
-      def add_address_for_type(type, post, creditcard, address)
+      def add_address_for_type(type, post, credit_card, address)
         prefix = address_key_prefix(type)
 
-        post[address_key(prefix, 'fname')] = creditcard.first_name
-        post[address_key(prefix, 'lname')] = creditcard.last_name
+        post[address_key(prefix, 'fname')] = credit_card.first_name
+        post[address_key(prefix, 'lname')] = credit_card.last_name
         post[address_key(prefix, 'company')] = address[:company] unless address[:company].blank?
         post[address_key(prefix, 'street')] = address[:address1] unless address[:address1].blank?
         post[address_key(prefix, 'street2')] = address[:address2] unless address[:address2].blank?
@@ -111,11 +123,11 @@ module ActiveMerchant #:nodoc:
         post[:invoice] = options[:order_id]
       end
       
-      def add_creditcard(post, creditcard)      
-        post[:card]  = creditcard.number
-        post[:cvv2] = creditcard.verification_value if creditcard.verification_value?
-        post[:expir]  = expdate(creditcard)
-        post[:name] = creditcard.name
+      def add_credit_card(post, credit_card)      
+        post[:card]  = credit_card.number
+        post[:cvv2] = credit_card.verification_value if credit_card.verification_value?
+        post[:expir]  = expdate(credit_card)
+        post[:name] = credit_card.name
       end
       
       def parse(body)
@@ -144,24 +156,18 @@ module ActiveMerchant #:nodoc:
       end     
 
       
-      def commit(action, money, parameters)
-        parameters[:software] = 'Active Merchant'
-        parameters[:amount]       = amount(money)
-        parameters[:testmode] = test? ? 1 : 0
-        
-        if result = test_result_from_cc_number(parameters[:card])
-          return result
-        end
-                   
-        data = ssl_post(GATEWAY_URL, post_data(action, parameters), POST_HEADERS)
+      def commit(action, parameters)
+        response = parse( ssl_post(URL, post_data(action, parameters)) )
         
-        @response = parse(data)
-        success = @response[:status] == 'Approved'
-        message = message_from(@response)
-
-        Response.new(success, message, @response, 
-            :test => test?,
-            :authorization => @response[:ref_num]
+        Response.new(response[:status] == 'Approved', message_from(response), response, 
+          :test => @options[:test] || test?,
+          :authorization => response[:ref_num],
+          :cvv_result => response[:cvv2_result_code],
+          :avs_result => { 
+            :street_match => response[:avs_result_code].to_s[0,1],
+            :postal_match => response[:avs_result_code].to_s[1,1],
+            :code => response[:avs_result_code].to_s[2,1]
+          }
         )        
       end
 
@@ -175,13 +181,12 @@ module ActiveMerchant #:nodoc:
       end
       
       def post_data(action, parameters = {})
-        post = {}
-  
-        post[:command]  = action
-        post[:key] = @options[:login]
+        parameters[:command]  = TRANSACTIONS[action]
+        parameters[:key] = @options[:login]
+        parameters[:software] = 'Active Merchant'
+        parameters[:testmode] = @options[:test] ? 1 : 0
 
-        request = post.merge(parameters).collect { |key, value| "UM#{key}=#{CGI.escape(value.to_s)}" }.join("&")
-        request
+        parameters.collect { |key, value| "UM#{key}=#{CGI.escape(value.to_s)}" }.join("&")
       end
     end
   end