activemerchant 1.1.0 → 1.2.0

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

@@ -15,14 +15,11 @@ module ActiveMerchant #:nodoc:
     # First, make sure you have everything setup correctly and all of your dependencies in place with:
     # 
     #   require 'rubygems'
-    #   require 'money'
     #   require 'active_merchant'
     #
-    # The second line is a require for the 'money' library. Make sure you have it installed with 'gem install money'
+    # ActiveMerchant expects amounts to be Integer values in cents
     #
-    # Using the money library, create a money object. Pass the dollar value in cents. In this case, $10 US becomes 1000.
-    #
-    #   tendollar = Money.us_dollar(1000)
+    #   tendollar = 1000
     #
     # Next, create a credit card object using a TC approved test card.
     #
@@ -103,42 +100,60 @@ module ActiveMerchant #:nodoc:
       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'
       
+      # Creates a new TrustCommerceGateway
+      # 
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      # 
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The TrustCommerce account login.
+      # * <tt>:password</tt> -- The TrustCommerce account password.
+      # * <tt>:test => +true+ or +false+</tt> -- Perform test transactions
+      #
+      # ==== Test Account Credentials
+      # * <tt>:login</tt> -- TestMerchant
+      # * <tt>:password</tt> -- password
       def initialize(options = {})
         requires!(options, :login, :password)
-        # these are the defaults for trustcommerce
-        @options = {
-          :login      => "TestMerchant",
-          :password   => "password"
-        }.update(options)
-
+      
+        @options = options
         super
       end
       
+      def test?
+        @options[:test] || Base.gateway_mode == :test
+      end
+      
       # authorize() is the first half of the preauth(authorize)/postauth(capture) model. The TC API docs call this
       # preauth, we preserve active_merchant's nomenclature of authorize() for consistency with the rest of the library. This
       # method simply checks to make sure funds are available for a transaction, and returns a transid that can be used later to
       # postauthorize (capture) the funds.
       
-      def authorize(money, creditcard, options = {})
+      def authorize(money, creditcard_or_billing_id, options = {})
         parameters = {
           :amount => amount(money),
         }                                                             
         
-        add_creditcard(parameters, creditcard)
+        add_payment_source(parameters, creditcard_or_billing_id)
         add_address(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.
+      # to process a purchase are an amount in cents or a money object and a creditcard object or billingid string.
       
-      def purchase(money, creditcard, options = {})        
+      def purchase(money, creditcard_or_billing_id, options = {})        
         parameters = {
           :amount => amount(money),
         }                                                             
         
-        add_creditcard(parameters, creditcard)
+        add_payment_source(parameters, creditcard_or_billing_id)
         add_address(parameters, options)
         commit('sale', parameters)
       end
@@ -235,12 +250,16 @@ module ActiveMerchant #:nodoc:
                                                   
         commit('unstore', parameters)
       end      
-            
-      def self.supported_cardtypes
-        [:visa, :master, :discover, :american_express, :diners_club, :jcb]
+          
+      private
+      def add_payment_source(params, source)
+        if source.is_a?(String)
+          add_billing_id(params, source)
+        else
+          add_creditcard(params, source)
+        end
       end
       
-      private
       def expdate(creditcard)
         year  = sprintf("%.4i", creditcard.year)
         month = sprintf("%.2i", creditcard.month)
@@ -256,6 +275,10 @@ module ActiveMerchant #:nodoc:
         params[:cvv]       = creditcard.verification_value if creditcard.verification_value?
       end
       
+      def add_billing_id(params, billingid)
+        params[:billingid] = billingid
+      end
+      
       def add_address(params, options)
         address = options[:billing_address] || options[:address]
         

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

@@ -8,6 +8,11 @@ module ActiveMerchant #:nodoc:
       attr_reader :url 
       attr_reader :response
       attr_reader :options
+      
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_countries = ['US']
+      self.homepage_url = 'http://www.usa_epay.com/'
+      self.display_name = 'USA ePay'
 
       def initialize(options = {})
         requires!(options, :login)
@@ -39,11 +44,7 @@ module ActiveMerchant #:nodoc:
         post = {:refNum => authorization}
         commit('capture', money, post)
       end
-    
-      def self.supported_cardtypes
-        [:visa, :master, :american_express]
-      end
-         
+       
       private                       
     
       def expdate(creditcard)

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

@@ -0,0 +1,235 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VerifiGateway < Gateway 
+      class VerifiPostData < PostData
+        # Fields that will be send even if they are blank
+        self.required_fields = [ :amount, :type, :ccnumber, :ccexp, :firstname, :lastname,
+          :company, :address1, :address2, :city, :state, :zip, :country, :phone ]   
+      end
+
+      URL = 'https://secure.verifi.com/gw/api/transact.php'
+            
+      RESPONSE_CODE_MESSAGES = {
+        "100" => "Transaction was Approved", 
+        "200" => "Transaction was Declined by Processor", 
+        "201" => "Do Not Honor", 
+        "202" => "Insufficient Funds", 
+        "203" => "Over Limit", 
+        "204" => "Transaction not allowed", 
+        "220" => "Incorrect payment Data", 
+        "221" => "No Such Card Issuer", 
+        "222" => "No Card Number on file with Issuer", 
+        "223" => "Expired Card", 
+        "224" => "Invalid Expiration Date", 
+        "225" => "Invalid Card Security Code", 
+        "240" => "Call Issuer for Further Information", 
+        "250" => "Pick Up Card", 
+        "251" => "Lost Card", 
+        "252" => "Stolen Card", 
+        "253" => "Fraudulent Card", 
+        "260" => "Declined With further Instructions Available (see response text)", 
+        "261" => "Declined - Stop All Recurring Payments", 
+        "262" => "Declined - Stop this Recurring Program", 
+        "263" => "Declined - Update Cardholder Data Available", 
+        "264" => "Declined - Retry in a few days", 
+        "300" => "Transaction was Rejected by Gateway", 
+        "400" => "Transaction Error Returned by Processor", 
+        "410" => "Invalid Merchant Configuration", 
+        "411" => "Merchant Account is Inactive", 
+        "420" => "Communication Error", 
+        "421" => "Communication Error with Issuer", 
+        "430" => "Duplicate Transaction at Processor", 
+        "440" => "Processor Format Error", 
+        "441" => "Invalid Transaction Information", 
+        "460" => "Processor Feature Not Available", 
+        "461" => "Unsupported Card Type"
+      }
+      
+      SUCCESS = 1
+      
+      TRANSACTIONS = {
+        :authorization => 'auth',
+        :purchase => 'sale',
+        :capture => 'capture',
+        :void => 'void',
+        :credit => 'credit',
+        :refund => 'refund'
+      }
+      
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.verifi.com/'
+      self.display_name = 'Verifi'
+                               
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+	                               
+    	def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+    	end
+
+      def purchase(money, creditcard, options = {})
+        sale_authorization_or_credit_template(:purchase, money, creditcard, options)
+      end
+
+      def authorize(money, creditcard, options = {})
+        sale_authorization_or_credit_template(:authorization, money, creditcard, options)
+      end
+                       
+      def capture(money, authorization, options = {})
+        capture_void_or_refund_template(:capture, money, authorization, options)
+      end
+      
+      def void(authorization, options = {})
+        capture_void_or_refund_template(:void, 0, authorization, options)
+      end
+      
+      def credit(money, creditcard_or_authorization, options = {})
+        if creditcard_or_authorization.is_a?(String)
+          capture_void_or_refund_template(:refund, money, creditcard_or_authorization, options)
+        else
+          sale_authorization_or_credit_template(:credit, money, creditcard_or_authorization, options)
+        end
+      end
+
+      private  
+             
+      def sale_authorization_or_credit_template(trx_type, money, creditcard, options = {})
+        post = VerifiPostData.new
+        add_security_key_data(post, options, money)
+        add_creditcard(post, creditcard)
+        add_addresses(post, options)
+        add_customer_data(post, options)
+        add_invoice_data(post, options)
+        add_optional_data(post, options)
+        commit(trx_type, money, post)  
+      end
+
+      def capture_void_or_refund_template(trx_type, money, authorization, options)
+        post = VerifiPostData.new
+        post[:transactionid] = authorization
+        
+        commit(trx_type, money, post)
+      end
+                    
+      def add_creditcard(post, creditcard)
+        post[:ccnumber]  = creditcard.number
+        post[:ccexp]     = expdate(creditcard)
+        post[:firstname] = creditcard.first_name
+        post[:lastname]  = creditcard.last_name      
+        post[:cvv]       = creditcard.verification_value
+      end      
+                 
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+
+      def add_addresses(post, options)
+        if billing_address = options[:billing_address] || options[:address]
+          post[:company]    = billing_address[:company]
+          post[:address1]   = billing_address[:address1]
+          post[:address2]   = billing_address[:address2]
+          post[:city]       = billing_address[:city]                           
+          post[:state]      = billing_address[:state]
+          post[:zip]        = billing_address[:zip]                               
+          post[:country]    = billing_address[:country]
+          post[:phone]      = billing_address[:phone]
+          post[:fax]        = billing_address[:fax]             
+        end
+        
+        if shipping_address = options[:shipping_address] || billing_address
+          post[:shipping_firstname] = shipping_address[:first_name]
+          post[:shipping_lastname]  = shipping_address[:last_name]  
+          post[:shipping_company]   = shipping_address[:company]    
+          post[:shipping_address1]  = shipping_address[:address1]   
+          post[:shipping_address2]  = shipping_address[:address2]   
+          post[:shipping_city]      = shipping_address[:city]       
+          post[:shipping_state]     = shipping_address[:state]      
+          post[:shipping_zip]       = shipping_address[:zip]        
+          post[:shipping_country]   = shipping_address[:country]    
+          post[:shipping_email]     = shipping_address[:email]      
+        end        
+      end
+             
+      def add_customer_data(post, options)
+        post[:email]     = options[:email]
+        post[:ipaddress] = options[:ip]
+      end
+      
+      def add_invoice_data(post, options)
+        post[:orderid]            = options[:order_id]
+        post[:ponumber]           = options[:invoice]
+        post[:orderdescription]   = options[:description]
+        post[:tax]                = options[:tax]
+        post[:shipping]           = options[:shipping]
+      end
+      
+      def add_optional_data(post, options)
+        post[:billing_method]     = options[:billing_method]    
+        post[:website]            = options[:website]   
+        post[:descriptor]         = options[:descriptor]         
+        post[:descriptor_phone]   = options[:descriptor_phone]   
+        post[:cardholder_auth]    = options[:cardholder_auth]    
+        post[:cavv]               = options[:cavv]               
+        post[:xid]                = options[:xid]                
+        post[:customer_receipt]   = options[:customer_receipt]
+      end
+                       
+      def add_security_key_data(post, options, money)
+        # MD5(username|password|orderid|amount|time)
+        now = Time.now.to_i.to_s
+        md5 = Digest::MD5.new
+        md5 << @options[:login].to_s + "|"
+        md5 << @options[:password].to_s + "|"
+        md5 << options[:order_id].to_s + "|"
+        md5 << amount(money).to_s + "|"
+        md5 << now
+        post[:key]  = md5.hexdigest
+        post[:time] = now
+      end                  
+                                                    
+      def commit(trx_type, money, post)
+          
+        post[:amount] = amount(money)
+        
+        if result = test_result_from_cc_number(post[:ccnumber])
+          return result
+        end
+                                                                            
+        data = ssl_post(URL, post_data(trx_type, post), 'Content-type' => "application/x-www-form-urlencoded")
+        @response = parse(data)
+                          
+        success = @response[:response].to_i == SUCCESS
+        message = @response[:response_code_message] ? @response[:response_code_message] : "" 
+    
+        Response.new(success, message, @response,
+          :test => test?,
+          :authorization => @response[:transactionid]
+        )
+      end
+                                                      
+      def parse(body)
+        results = {}
+        CGI.parse(body).each { |key, value| results[key.intern] = value[0] }
+        results[:response_code_message] = RESPONSE_CODE_MESSAGES[results[:response_code]] if results[:response_code]
+        results
+      end   
+      
+      def post_data(trx_type, post)
+        post[:username]   = @options[:login]  
+        post[:password]   = @options[:password]
+        post[:type]       = TRANSACTIONS[trx_type]
+        
+        post.to_s
+      end
+    end 
+  end
+end

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

@@ -0,0 +1,171 @@
+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'
+      
+      APPROVED = '0'
+      
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_countries = ['US']
+      self.display_name = 'ViaKLIX'
+      self.homepage_url = 'http://viaklix.com'
+      
+      # Initialize the Gateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      # 
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- Merchant ID
+      # * <tt>:password</tt> -- PIN
+      # * <tt>:user</tt> -- Specify a subuser of the account (optional)
+      # * <tt>:test => +true+ or +false+</tt> -- Force test transactions
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+      
+      # Make a purchase  
+      def purchase(money, creditcard, options = {})
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)        
+        add_address(form, options)   
+        add_customer_data(form, options)
+        commit('SALE', money, form)
+      end
+      
+      # Make a credit to a card (Void can only be done from the virtual terminal)
+      # Viaklix does not support credits by reference. You must pass in the credit card
+      def credit(money, creditcard, options = {})
+        if creditcard.is_a?(String)
+          raise ArgumentError, "Reference credits are not supported.  Please supply the original credit card"
+        end
+        
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)        
+        add_address(form, options)   
+        add_customer_data(form, options)
+        commit('CREDIT', money, form)
+      end
+      
+      private
+      def add_customer_data(form, options)
+        form[:email] = options[:email] unless options[:email].blank?
+        form[:customer_code] = options[:customer].to_s.slice(0, 17) unless options[:customer].blank?
+      end
+      
+      def add_invoice(form,options)
+        form[:invoice_number] = options[:order_id] || options[:invoice]
+      end
+      
+      def add_address(form,options)
+        billing_address = options[:billing_address] || options[:address] 
+        
+        if billing_address
+          form[:avs_address]    = billing_address[:address1]
+          form[:avs_zip]        = billing_address[:zip]
+          form[:city]           = billing_address[:city]
+          form[:state]          = billing_address[:state]
+          form[:company]        = billing_address[:company]
+          form[:phone]          = billing_address[:phone]
+          form[:country]        = billing_address[:country]
+        end
+        
+        shipping_address = options[:shipping_address] || billing_address
+        
+        if shipping_address
+          first_name, last_name = parse_first_and_last_name(shipping_address[:name])
+          form[:ship_to_first_name]     = first_name
+          form[:ship_to_last_name]      = last_name
+          form[:ship_to_address]        = shipping_address[:address1]
+          form[:ship_to_city]           = shipping_address[:city]
+          form[:ship_to_state]          = shipping_address[:state]
+          form[:ship_to_company]        = shipping_address[:company]
+          form[:ship_to_country]        = shipping_address[:country]
+          form[:ship_to_zip]            = shipping_address[:zip]
+        end
+      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
+      
+      def add_creditcard(form, creditcard)
+        form[:card_number] = creditcard.number
+        form[:exp_date] = expdate(creditcard)
+        
+        if creditcard.verification_value?
+          form[:cvv2cvc2] = creditcard.verification_value 
+          form[:cvv2] = 'present'
+        end
+        
+        form[:first_name] = creditcard.first_name
+        form[:last_name] = creditcard.last_name        
+      end
+      
+      def preamble
+        result = {
+          'merchant_id'   => @options[:login],
+          'pin'           => @options[:password],
+          'show_form'     => 'false',
+          'test_mode'     => @options[:test] ? 'TRUE' : 'FALSE',
+          'result_format' => 'ASCII',          
+        }
+        
+        result['user_id'] = @options[:user] unless @options[:user].blank?
+        result
+      end
+      
+      def commit(action, money, parameters)
+        if result = test_result_from_cc_number(parameters[:card_number])
+          return result
+        end
+        
+        parameters[:amount] = amount(money)
+        parameters[:transaction_type] = action
+            
+        msg = ssl_post(test? ? TEST_URL : LIVE_URL, post_data(parameters))
+        
+        @response = parse(msg)
+        success = @response['result'] == APPROVED
+        message = @response['result_message']
+        
+        Response.new(success, message, @response, 
+          :test => @options[:test] || test?, 
+          :authorization => @response['txn_id']
+        )
+      end
+      
+      def post_data(parameters)
+        result = preamble
+        result.merge!(parameters)        
+        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+      
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+        "#{month}#{year[2..3]}"
+      end
+      
+      # Parse the response message
+      def parse(msg)
+        resp = Hash.new;
+        msg.split("\r\n").collect{|li|
+            key, value = li.split("=")
+            resp[key.gsub(/^ssl_/, '')] = value.to_s.strip
+          }
+        resp
+      end
+    end
+  end
+end