activemerchant 1.2.1 → 1.3.0

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

@@ -0,0 +1,168 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetbillingGateway < Gateway
+      URL = 'https://secure.netbilling.com:1402/gw/sas/direct3.1'
+      
+      TRANSACTIONS = {
+        :authorization       => 'A',
+        :purchase            => 'S',
+        :referenced_credit   => 'R',
+        :unreferenced_credit => 'C',
+        :capture             => 'D'
+      }
+      
+      SUCCESS_CODES = [ '1', 'T' ]
+      SUCCESS_MESSAGE = 'The transaction was approved'
+      FAILURE_MESSAGE = 'The transaction failed'
+      TEST_LOGIN = '104901072025'
+
+      self.display_name = 'NETbilling'
+      self.homepage_url = 'http://www.netbilling.com'
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+      
+      def initialize(options = {})
+        requires!(options, :login)
+        @options = options
+        super
+      end  
+      
+      def authorize(money, credit_card, options = {})
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)        
+        add_address(post, credit_card, options)        
+        add_customer_data(post, options)
+        
+        commit(:authorization, money, post)
+      end
+      
+      def purchase(money, credit_card, options = {})
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)        
+        add_address(post, credit_card, options)        
+        add_customer_data(post, options)
+             
+        commit(:purchase, money, post)
+      end                       
+    
+      def capture(money, authorization, options = {})
+        post = {}
+        add_reference(post, authorization)
+        commit(:capture, money, post)
+      end
+      
+      def test?
+        @options[:login] == TEST_LOGIN || super
+      end
+     
+      private      
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+      
+      def add_reference(post, reference)
+        post[:orig_id] = reference
+      end
+      
+      def add_customer_data(post, options)
+        post[:cust_email] = options[:email]
+        post[:cust_ip] = options[:ip]
+      end
+
+      def add_address(post, credit_card, options)
+        if billing_address = options[:billing_address] || options[:address]
+          post[:bill_street]     = billing_address[:address1]
+          post[:cust_phone]      = billing_address[:phone]
+          post[:bill_zip]        = billing_address[:zip]
+          post[:bill_city]       = billing_address[:city]
+          post[:bill_country]    = billing_address[:country]
+          post[:bill_state]      = billing_address[:state]
+        end
+        
+       if shipping_address = options[:shipping_address]
+         first_name, last_name = parse_first_and_last_name(shipping_address[:name])
+        
+         post[:ship_name1]      = first_name
+         post[:ship_name2]      = last_name
+         post[:ship_street]     = shipping_address[:address1]
+         post[:ship_zip]        = shipping_address[:zip]
+         post[:ship_city]       = shipping_address[:city]
+         post[:ship_country]    = shipping_address[:country]
+         post[:ship_state]      = shipping_address[:state]
+       end
+      end
+    
+      def add_invoice(post, options)
+        post[:description] = options[:description]
+      end
+      
+      def add_credit_card(post, credit_card)
+        post[:bill_name1] = credit_card.first_name
+        post[:bill_name2] = credit_card.last_name
+        post[:card_number] = credit_card.number
+        post[:card_expire] = expdate(credit_card)
+        post[:card_cvv2] = credit_card.verification_value
+      end
+      
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key,val = pair.split(/=/)
+          results[key.to_sym] = CGI.unescape(val)
+        end
+        results
+      end     
+      
+      def commit(action, money, parameters)
+        response = parse(ssl_post(URL, post_data(action, parameters)))
+        
+        Response.new(success?(response), message_from(response), response, 
+          :test => test_response?(response), 
+          :authorization => response[:trans_id],
+          :avs_result => { :code => response[:avs_code]},
+          :cvv_result => response[:cvv2_code]
+        )
+      end
+      
+      def test_response?(response)
+        !!(test? || response[:auth_msg] =~ /TEST/)
+      end
+      
+      def success?(response)
+        SUCCESS_CODES.include?(response[:status_code])
+      end
+
+      def message_from(response)
+        success?(response) ? SUCCESS_MESSAGE : (response[:auth_msg] || FAILURE_MESSAGE)
+      end
+      
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+      
+      def post_data(action, parameters = {})
+        parameters[:account_id] = @options[:login]
+        parameters[:pay_type] = 'C'
+        parameters[:tran_type] = TRANSACTIONS[action]  
+        
+        parameters.reject{|k,v| v.blank?}.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+      
+      def parse_first_and_last_name(value)
+        name = value.to_s.split(' ')
+        
+        last_name = name.pop || ''
+        first_name = name.join(' ')
+        [ first_name, last_name ] 
+      end
+    end
+  end
+end
+

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

@@ -1,6 +1,5 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    
     # PayJunction Gateway
     #
     # This gateway accepts the following arguments:
@@ -11,7 +10,8 @@ module ActiveMerchant #:nodoc:
     #
     #   gateway = ActiveMerchant::Billing::Base.gateway(:pay_junction).new(
     #               :login => "my_account", 
-    #               :password => "my_pass" )
+    #               :password => "my_pass"
+    #            )
     #
     #   # set up credit card obj as in main ActiveMerchant example
     #   creditcard = ActiveMerchant::Billing::CreditCard.new(
@@ -25,7 +25,7 @@ module ActiveMerchant #:nodoc:
     #
     #   # optionally specify address if using AVS
     #   address = { :address1 => '101 Test Ave', :city => 'Test', :state => 'TS',
-    #               :zipcode  => '10101', :country => 'US' }
+    #               :zip  => '10101', :country => 'US' }
     #
     #   # run request
     #   response = gateway.purchase(1000, creditcard, :address => address) # charge 10 dollars
@@ -52,8 +52,7 @@ module ActiveMerchant #:nodoc:
     #
     # See the source for initialize() for test account information. Note that
     # PayJunction does not allow test transactions on your account, so if the 
-    # gateway is running in :test mode or the :test_request option has been
-    # been specified and is true, your transaction will be run against
+    # 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 
@@ -93,18 +92,21 @@ module ActiveMerchant #:nodoc:
     #                         "instant" transactions.
     #
     # dc_invoice              :order_id in options for transaction method
-    # dc_notes                :notes in options for transaction method
+    # dc_notes                :description in options for transaction method
     #
     # See example use above for address AVS fields
     # See #recurring for periodic transaction fields
-    #
-    
-    
     class PayJunctionGateway < Gateway
       API_VERSION   = '1.2'
-      LIVE_URL      = 'https://payjunction.com/quick_link' # also handles test requests 
+      URL      = 'https://payjunction.com/quick_link' # also handles test requests 
+      
+      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.',
@@ -137,15 +139,8 @@ 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.' 
-        
-      }
-      
-      BADDATA_CODES = {
-        "FE"  => "There was a format error with your Trinity Gateway Service (API) request."
-      }
-      
-      ERROR_CODES = {
+        '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.'
@@ -153,11 +148,8 @@ module ActiveMerchant #:nodoc:
       
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.supported_countries = ['US']
-      
       self.homepage_url = 'http://www.payjunction.com/'
       self.display_name = 'PayJunction'
-      
-      attr_reader :url, :response, :options
 
       def initialize(options = {})
         requires!(options, :login, :password)
@@ -168,12 +160,12 @@ module ActiveMerchant #:nodoc:
       # 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, creditcard_or_billing_id, options = {})
+      def authorize(money, payment_source, options = {})
         parameters = {
           :transaction_amount => amount(money),
         }                                                             
         
-        add_payment_source(parameters, creditcard_or_billing_id)
+        add_payment_source(parameters, payment_source)
         add_address(parameters, options)
         add_optional_fields(parameters, options)
         commit('AUTHORIZATION', parameters)
@@ -181,12 +173,12 @@ module ActiveMerchant #:nodoc:
       
       # A simple sale, capturing funds immediately.
       # Execute authorization and capture in a single step.
-      def purchase(money, creditcard_or_billing_id, options = {})        
+      def purchase(money, payment_source, options = {})        
         parameters = {
           :transaction_amount => amount(money),
         }                                                             
         
-        add_payment_source(parameters, creditcard_or_billing_id)
+        add_payment_source(parameters, payment_source)
         add_address(parameters, options)
         add_optional_fields(parameters, options)
         commit('AUTHORIZATION_CAPTURE', parameters)
@@ -238,7 +230,7 @@ module ActiveMerchant #:nodoc:
       # 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, creditcard_or_billing_id, options = {})        
+      def recurring(money, payment_source, options = {})        
         requires!(options, [:periodicity, :monthly, :weekly, :daily], :payments)
       
         periodic_type = case options[:periodicity]
@@ -268,18 +260,22 @@ module ActiveMerchant #:nodoc:
           :schedule_start => start_date
         }
         
-        add_payment_source(parameters, creditcard_or_billing_id)
+        add_payment_source(parameters, payment_source)
         add_optional_fields(parameters, options)
         add_address(parameters, options)                                   
         commit('AUTHORIZATION_CAPTURE', parameters)
       end
       
       def test?
-        @options[:test] || super
+        test_login? || @options[:test] || 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)
@@ -321,57 +317,40 @@ module ActiveMerchant #:nodoc:
         params[:invoice] = options[:order_id].to_s.gsub(/[^-\/\w.,']/, '') unless options[:order_id].blank?
       end
       
-      def clean_and_stringify_params(parameters)
-        # PayJunction uses an HTTPS POST request to submit key-pairs. Here we're going
-        # to convert all symbols in the params to strings and remove any pairs that 
-        # have a nil value to keep the gateway happy.
-        to_submit = {}
-        parameters.keys.reverse.each do |key|
-          if parameters[key]
-            to_submit[key.to_s] = parameters[key] 
-          end
+      def commit(action, parameters)
+        response = parse( ssl_post(URL, post_data(action, parameters)) )
+        
+        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
+        else
+          DECLINE_CODES[response[:response_code]] || FAILURE_MESSAGE
         end
-        to_submit
       end
-  
-      def commit(action, parameters)
+      
+      def post_data(action, params)
         if test?
           # test requests must use global test account
-          parameters[:logon]      = 'pj-ql-01'
-          parameters[:password]   = 'pj-ql-01p'
+          params[:logon]      = TEST_LOGIN
+          params[:password]   = TEST_PASSWORD
         else
-          parameters[:logon]      = @options[:login]
-          parameters[:password]   = @options[:password]
+          params[:logon]      = @options[:login]
+          params[:password]   = @options[:password]
         end
-        parameters[:version] = API_VERSION
-        parameters[:transaction_type] = action
+        params[:version] = API_VERSION
+        params[:transaction_type] = action
         
-        submission = clean_and_stringify_params(parameters)
-                
-        if result = test_result_from_cc_number(parameters[:number])
-          return result
-        end
-        
-        post_args = submission.collect { |key, value| "dc_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
-        headers = {'Content-type' => 'application/x-www-form-urlencoded '}
-
-        data = ssl_post(LIVE_URL, post_args, headers) # execute transaction
-        @response = parse(data)
-
-        unless action == 'update'
-          success = SUCCESS_CODES.include?(@response[:response_code])
-          message = @response[:response_message]
-          authorization = @response[:transaction_id]
-        else
-          success = @response[:query_status] == true
-          message = 'Transaction update request.'     # no message returned with this trans. type
-          authorization = parameters[:transaction_id] # maintain trans ID since it isn't returned
-        end
-
-        Response.new(success, message, @response, 
-            :test => test?, 
-            :authorization => authorization
-        )
+        params.reject{|k,v| v.blank?}.collect{ |k, v| "dc_#{k.to_s}=#{CGI.escape(v.to_s)}" }.join("&")
       end
       
       def parse(body)

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

@@ -0,0 +1,120 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaySecureGateway < Gateway
+      URL = 'https://clearance.commsecure.com.au/cgi-bin/PSDirect'
+      
+      self.money_format = :cents
+
+      # Currently Authorization and Capture is not implemented because
+      # capturing requires the original credit card information
+      TRANSACTIONS = {
+        :purchase       => 'PURCHASE',
+        :authorization  => 'AUTHORISE',
+        :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'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      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)        
+             
+        commit(:purchase, money, post)
+      end                       
+         
+      private
+      # Used for capturing, which is currently not supported.
+      def add_reference(post, identification)
+        auth, trans_id = identification.split(";")
+        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)      
+        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(URL, post_data(action, parameters)) )
+        
+        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.collect do |l| 
+          key, value = l.split(":", 2)
+          response[key.to_s.downcase.to_sym] = value.strip
+        end
+        response
+      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
+  end
+end
+