activemerchant 1.4.2 → 1.5.0

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

@@ -0,0 +1,265 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SmartPs < Gateway #:nodoc:
+      
+      ##
+      # This is the base gateway for processors who use the smartPS processing system
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      # Pass :store => true in the options to store the 
+      # payment info at the gateway and get a generated 
+      # customer_vault_id in the response.  
+      # Pass :store => some_number_or_string to specify the
+      # customer_vault_id the gateway should use (make sure it's
+      # unique).
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard,options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_address(post, options[:shipping_address], "shipping")
+        add_customer_data(post, options)
+        add_currency(post, money, options)
+        add_processor(post, options)
+        commit('auth', money, post)
+      end
+      
+      def purchase(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)
+        add_address(post, options[:billing_address] || options[:address])
+        add_address(post, options[:shipping_address], "shipping")
+        add_customer_data(post, options)
+        add_currency(post, money, options)
+        add_processor(post, options)     
+        commit('sale', money, post)
+      end                       
+    
+      def capture(money, authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('capture', money, post)
+      end
+      
+      def void(authorization, options = {})
+        post ={}
+        post[:transactionid] = authorization
+        commit('void', nil, post)
+      end
+      
+      def credit(money, payment_source, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_source, options)        
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+        add_sku(post,options)
+        add_currency(post, money, options)
+        add_processor(post, options)
+        commit('credit', money, post)
+      end
+      
+      def refund(auth, options = {})
+        post = {}
+        add_transaction(post, auth)
+        commit('refund', options.delete(:amount), post)
+      end
+      
+      
+      # Update the values (such as CC expiration) stored at
+      # the gateway.  The CC number must be supplied in the
+      # CreditCard object.
+      def update(vault_id, creditcard, options = {})
+        post = {}
+        post[:customer_vault] = "update_customer"
+        add_customer_vault_id(post, vault_id)
+        add_creditcard(post, creditcard, options)        
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+             
+        commit(nil, nil, post)
+      end
+      
+      # Amend an existing transaction
+      def amend(auth, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_transaction(post, auth)
+        commit('update', nil, post)
+      end
+      
+    
+      def delete(vault_id)
+        post = {}
+        post[:customer_vault] = "delete_customer"
+        add_customer_vault_id(post, vault_id)         
+        commit(nil, nil, post)
+      end
+    
+      # To match the other stored-value gateways, like TrustCommerce,
+      # store and unstore need to be defined
+      def store(payment_source, options = {})
+        post = {}
+        billing_id = options.delete(:billing_id).to_s || true
+        add_payment_source(post, payment_source, :store => billing_id)
+        add_address(post, options[:billing_address] || options[:address])
+        add_customer_data(post, options)
+        commit(nil, nil, post)
+      end
+      
+      alias_method :unstore, :delete
+
+      private                             
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+        end
+
+        if options.has_key? :ip
+          post[:ipaddress] = options[:ip]
+        end        
+      end
+
+      def add_address(post, address,prefix="")     
+        prefix +="_" unless prefix.blank? 
+        unless address.blank? or address.values.blank?
+          post[prefix+"address1"]    = address[:address1].to_s
+          post[prefix+"address2"]    = address[:address2].to_s unless address[:address2].blank?
+          post[prefix+"company"]    = address[:company].to_s
+          post[prefix+"phone"]      = address[:phone].to_s
+          post[prefix+"zip"]        = address[:zip].to_s       
+          post[prefix+"city"]       = address[:city].to_s
+          post[prefix+"country"]    = address[:country].to_s
+          post[prefix+"state"]      = address[:state].blank?  ? 'n/a' : address[:state]
+        end         
+      end
+      
+      def add_currency(post, money, options)
+        post[:currency] = options[:currency] || currency(money)
+      end
+      
+      def add_processor(post, options)
+        post[:processor] = options[:processor] unless options[:processor].nil?
+      end
+      
+      def add_invoice(post, options)
+        post[:orderid] = options[:order_id].to_s.gsub(/[^\w.]/, '')
+      end
+      
+      def add_payment_source(params, source, options={})
+        case determine_funding_source(source)
+        when :vault       then add_customer_vault_id(params, source)
+        when :credit_card then add_creditcard(params, source, options)
+        when :check       then add_check(params, source, options)
+        end
+      end
+      
+      def add_customer_vault_id(params, vault_id)
+        params[:customer_vault_id] = vault_id
+      end
+      
+      def add_creditcard(post, creditcard, options)
+        if options[:store]  
+          post[:customer_vault] = "add_customer"
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+        post[:ccnumber]  = creditcard.number
+        post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+        post[:ccexp]  = expdate(creditcard)
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name   
+      end
+      
+      def add_check(post, check, options)
+        if options[:store]  
+          post[:customer_vault] = "add_customer"
+          post[:customer_vault_id] = options[:store] unless options[:store] == true
+        end
+        
+        post[:payment] = 'check' # Set transaction to ACH
+        post[:checkname] = check.name # The name on the customer's Checking Account
+        post[:checkaba] = check.routing_number # The customer's bank routing number
+        post[:checkaccount] = check.account_number # The customer's account number
+        post[:account_holder_type] = check.account_holder_type # The customer's type of ACH account
+        post[:account_type] = check.account_type # The customer's type of ACH account
+      end
+      
+      def add_sku(post,options)
+        post["product_sku_#"] = options[:sku] || options["product_sku_#"]
+      end
+      
+      def add_transaction(post, auth)
+        post[:transactionid] = auth
+      end
+      
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key,val = pair.split(/=/)
+          results[key] = val
+        end
+        
+        results
+      end     
+      
+      def commit(action, money, parameters)
+        parameters[:amount]  = amount(money) if money
+        response = parse( ssl_post(api_url, post_data(action,parameters)) )
+        Response.new(response["response"] == "1", message_from(response), response, 
+          :authorization => response["transactionid"],
+          :test => test?,
+          :cvv_result => response["cvvresponse"],
+          :avs_result => { :code => response["avsresponse"] }
+        )
+        
+      end
+      
+      def expdate(creditcard)
+        year  = sprintf("%.04i", creditcard.year.to_i)
+        month = sprintf("%.02i", creditcard.month.to_i)
+
+        "#{month}#{year[-2..-1]}"
+      end
+      
+
+      def message_from(response)
+        case response["responsetext"]
+        when "SUCCESS", "Approved", nil # This is dubious, but responses from UPDATE are nil.
+          "This transaction has been approved"
+        when "DECLINE"
+          "This transaction has been declined"
+        else
+          response["responsetext"]
+        end
+      end
+      
+      def post_data(action, parameters = {})
+        post = {}
+        post[:username]      = @options[:login]
+        post[:password]   = @options[:password]
+        post[:type]       = action if action
+
+        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request        
+      end
+      
+      def determine_funding_source(source)
+        case 
+        when source.is_a?(String) then :vault
+        when CreditCard.card_companies.keys.include?(card_brand(source)) then :credit_card
+        when card_brand(source) == 'check' then :check
+        else raise ArgumentError, "Unsupported funding source provided"
+        end
+      end
+    end    
+  end
+end
+

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

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__),'smart_ps.rb')
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransaxGateway < SmartPs
+      def api_url 
+        'https://secure.nelixtransax.net/api/transact.php'
+      end
+      
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US']
+      
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      
+      # The homepage URL of the gateway
+      self.homepage_url = 'https://www.nelixtransax.com/'
+      
+      # The name of the gateway
+      self.display_name = 'NELiX TransaX'
+
+    end
+  end
+end
+

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

@@ -1,8 +1,16 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class ViaklixGateway < Gateway
-      TEST_URL = 'https://demo.viaklix.com/process.asp'
-      LIVE_URL = 'https://www.viaklix.com/process.asp'
+      class_inheritable_accessor :test_url, :live_url, :delimiter, :actions
+
+      self.test_url = 'https://demo.viaklix.com/process.asp'
+      self.live_url = 'https://www.viaklix.com/process.asp'
+      self.delimiter = "\r\n"
+      
+      self.actions = {
+        :purchase => 'SALE',
+        :credit => 'CREDIT'
+      }
       
       APPROVED = '0'
       
@@ -35,7 +43,7 @@ module ActiveMerchant #:nodoc:
         add_creditcard(form, creditcard)        
         add_address(form, options)   
         add_customer_data(form, options)
-        commit('SALE', money, form)
+        commit(:purchase, money, form)
       end
       
       # Make a credit to a card (Void can only be done from the virtual terminal)
@@ -50,13 +58,13 @@ module ActiveMerchant #:nodoc:
         add_creditcard(form, creditcard)        
         add_address(form, options)   
         add_customer_data(form, options)
-        commit('CREDIT', money, form)
+        commit(:credit, money, form)
       end
       
       private
       def add_customer_data(form, options)
         form[:email] = options[:email].to_s.slice(0, 100) unless options[:email].blank?
-        form[:customer_code] = options[:customer].to_s.slice(0, 17) unless options[:customer].blank?
+        form[:customer_code] = options[:customer].to_s.slice(0, 10) unless options[:customer].blank?
       end
       
       def add_invoice(form,options)
@@ -104,20 +112,24 @@ module ActiveMerchant #:nodoc:
         form[:exp_date] = expdate(creditcard)
         
         if creditcard.verification_value?
-          form[:cvv2cvc2] = creditcard.verification_value 
-          form[:cvv2] = 'present'
+          add_verification_value(form, creditcard)
         end
         
         form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
         form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
       end
       
+      def add_verification_value(form, creditcard)
+        form[:cvv2cvc2] = creditcard.verification_value 
+        form[:cvv2] = 'present'
+      end
+      
       def preamble
         result = {
           'merchant_id'   => @options[:login],
           'pin'           => @options[:password],
           'show_form'     => 'false',
-          'test_mode'     => @options[:test] ? 'TRUE' : 'FALSE',
+          'test_mode'     => test? ? 'TRUE' : 'FALSE',
           'result_format' => 'ASCII',          
         }
         
@@ -125,20 +137,32 @@ module ActiveMerchant #:nodoc:
         result
       end
       
+      def test?
+        @options[:test] || super
+      end
+      
       def commit(action, money, parameters)
         parameters[:amount] = amount(money)
-        parameters[:transaction_type] = action
+        parameters[:transaction_type] = self.actions[action]
             
-        response = parse( ssl_post(test? ? TEST_URL : LIVE_URL, post_data(parameters)) )
+        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)) )
 
-        Response.new(response['result'] == APPROVED, response['result_message'], response, 
+        Response.new(response['result'] == APPROVED, message_from(response), response, 
           :test => @options[:test] || test?, 
-          :authorization => response['txn_id'],
+          :authorization => authorization_from(response),
           :avs_result => { :code => response['avs_response'] },
           :cvv_result => response['cvv2_response']
         )
       end
       
+      def authorization_from(response)
+        response['txn_id']
+      end
+      
+      def message_from(response)
+        response['result_message']
+      end
+      
       def post_data(parameters)
         result = preamble
         result.merge!(parameters)        
@@ -154,9 +178,9 @@ module ActiveMerchant #:nodoc:
       # Parse the response message
       def parse(msg)
         resp = {}
-        msg.split("\r\n").collect{|li|
+        msg.split(self.delimiter).collect{|li|
             key, value = li.split("=")
-            resp[key.gsub(/^ssl_/, '')] = value.to_s.strip
+            resp[key.strip.gsub(/^ssl_/, '')] = value.to_s.strip
           }
         resp
       end

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

@@ -20,6 +20,15 @@ module ActiveMerchant #:nodoc:
 
       RETURN_CODES = %w[ ACK NOK ]
 
+      # Wirecard only allows phone numbers with a format like this: +xxx(yyy)zzz-zzzz-ppp, where: 
+      #   xxx = Country code 
+      #   yyy = Area or city code 
+      #   zzz-zzzz = Local number 
+      #   ppp = PBX extension 
+      # For example, a typical U.S. or Canadian number would be "+1(202)555-1234-739" indicating PBX extension 739 at phone 
+      # number 5551234 within area code 202 (country code 1).
+      VALID_PHONE_FORMAT = /\+\d{1,3}(\(?\d{3}\)?)?\d{3}-\d{4}-\d{3}/
+      
       # The countries the gateway supports merchants from as 2 digit ISO country codes
       # TODO: Check supported countries
       self.supported_countries = ['DE']
@@ -202,9 +211,13 @@ module ActiveMerchant #:nodoc:
 	          xml.tag! 'Address2', address[:address2] if address[:address2]
 	          xml.tag! 'City', address[:city]
 	          xml.tag! 'ZipCode', address[:zip]
-	          xml.tag! 'State', address[:state].blank? ? 'N/A' : address[:state]
+	          
+	          if address[:state] =~ /[A-Za-z]{2}/ && address[:country] =~ /^(us|ca)$/i
+	            xml.tag! 'State', address[:state].upcase
+	          end
+	          
 	          xml.tag! 'Country', address[:country]
-	          xml.tag! 'Phone', address[:phone]
+            xml.tag! 'Phone', address[:phone] if address[:phone] =~ VALID_PHONE_FORMAT
 	          xml.tag! 'Email', address[:email]
 	        end
 	      end

data/lib/active_merchant/billing/integrations.rb

@@ -1,14 +1,3 @@
-require 'active_merchant/billing/integrations/notification'
-require 'active_merchant/billing/integrations/helper'
-require 'active_merchant/billing/integrations/return'
-require 'active_merchant/billing/integrations/bogus'
-require 'active_merchant/billing/integrations/chronopay'
-require 'active_merchant/billing/integrations/paypal'
-require 'active_merchant/billing/integrations/nochex'
-require 'active_merchant/billing/integrations/gestpay'
-require 'active_merchant/billing/integrations/two_checkout'
-require 'active_merchant/billing/integrations/hi_trust'
-require 'active_merchant/billing/integrations/quickpay'
 
 # make the bogus gateway be classified correctly by the inflector
 if defined?(ActiveSupport::Inflector)
@@ -20,3 +9,21 @@ else
     inflect.uncountable 'bogus'
   end
 end
+
+module ActiveMerchant
+  module Billing
+    module Integrations        
+    
+      Dir[File.dirname(__FILE__) + '/integrations/*.rb'].each do |f|      
+      
+        # Get camelized class name 
+        filename = File.basename(f, '.rb')
+        # Camelize the string to get the class name
+        gateway_class = filename.camelize.to_sym
+              
+        # Register for autoloading
+        autoload gateway_class, f      
+      end
+    end
+  end
+end