activemerchant 1.0.0

data/lib/active_merchant/billing/gateway.rb

@@ -0,0 +1,100 @@
+require 'net/http'
+require 'net/https'
+require 'active_merchant/billing/response'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # The Gateway class is the base class for all ActiveMerchant gateway
+    # implementations. The list of gateway functions that concrete
+    # gateway classes can and should implement include the following:
+    # 
+    # === Core operations supported by most gateways
+    # * purchase(money, creditcard, options = {})
+    # * authorize(money, creditcard, options = {})
+    # * capture(money, authorization, options = {})
+    # * void(identification, options = {})
+    # * credit(money, identification, options = {})
+    class Gateway
+      include PostsData
+      include RequiresParameters
+      
+      # The format of the amounts used by the gateway
+      # :dollars => '12.50'
+      # :cents => '1250'
+      class_inheritable_accessor :money_format
+      self.money_format = :dollars
+      
+      # Return the matching gateway for the provider
+      # * <tt>bogus</tt>: BogusGateway - Does nothing ( for testing)
+      # * <tt>moneris</tt>: MonerisGateway
+      # * <tt>authorize_net</tt>: AuthorizeNetGateway
+      # * <tt>trust_commerce</tt>: TrustCommerceGateway
+      # 
+      #   ActiveMerchant::Base.gateway('moneris').new
+      def self.gateway(name)
+        ActiveMerchant::Billing.const_get("#{name.to_s.downcase}_gateway".camelize)
+      end                        
+             
+      # Does this gateway support credit cards of the passed type?
+      def self.supports?(type)
+        supported_cardtypes.include?(type.intern)
+      end
+                                                                  
+      # Get a list of supported credit card types for this gateway
+      def self.supported_cardtypes
+        []
+      end                                 
+    
+      attr_reader :options
+      # Initialize a new gateway 
+      # 
+      # See the documentation for the gateway you will be using to make sure there
+      # are no other required options
+      def initialize(options = {})    
+        @ssl_strict = options[:ssl_strict] || false
+      end
+                                     
+      # Are we running in test mode?
+      def test?
+        Base.gateway_mode == :test
+      end
+            
+      private
+      def name 
+        self.class.name.scan(/\:\:(\w+)Gateway/).flatten.first
+      end
+      
+      def test_result_from_cc_number(number)
+        return false unless test?
+        
+        case number.to_s
+        when '1', 'success' 
+          Response.new(true, 'Successful test mode response', {:receiptid => '#0001'}, :test => true, :authorization => '5555')
+        when '2', 'failure' 
+          Response.new(false, 'Failed test mode response', {:receiptid => '#0001'}, :test => true)
+        when '3', 'error' 
+          raise Error, 'big bad exception'
+        else 
+          false
+        end
+      end
+      
+      # Return a string with the amount in the appropriate format
+      def amount(money)
+        return nil if money.nil?
+        cents = money.respond_to?(:cents) ? money.cents : money 
+
+        if money.is_a?(String) or cents.to_i < 0
+          raise ArgumentError, 'money amount must be either a Money object or a positive integer in cents.' 
+        end
+
+        case self.money_format
+        when :cents
+          cents.to_s
+        else
+          sprintf("%.2f", cents.to_f/100)
+        end
+      end      
+    end
+  end
+end

data/lib/active_merchant/billing/gateways.rb

@@ -0,0 +1,15 @@
+require 'active_merchant/billing/gateway'
+require 'active_merchant/billing/gateways/bogus'
+require 'active_merchant/billing/gateways/psigate'
+require 'active_merchant/billing/gateways/authorize_net'
+require 'active_merchant/billing/gateways/moneris'
+require 'active_merchant/billing/gateways/trust_commerce'
+require 'active_merchant/billing/gateways/linkpoint'
+require 'active_merchant/billing/gateways/paypal'
+require 'active_merchant/billing/gateways/paypal_express'
+require 'active_merchant/billing/gateways/eway'
+require 'active_merchant/billing/gateways/usa_epay'
+require 'active_merchant/billing/gateways/payflow'
+require 'active_merchant/billing/gateways/payflow_express'
+require 'active_merchant/billing/gateways/payflow_uk'
+require 'active_merchant/billing/gateways/payflow_express_uk'

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

@@ -0,0 +1,236 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+        
+    class AuthorizeNetGateway < Gateway
+      API_VERSION = '3.1'
+      LIVE_URL = "https://secure.authorize.net/gateway/transact.dll"
+      TEST_URL = "https://test.authorize.net/gateway/transact.dll"
+
+      APPROVED, DECLINED, ERROR = 1, 2, 3
+
+      RESPONSE_CODE, RESPONSE_REASON_CODE, RESPONSE_REASON_TEXT = 0, 2, 3
+      AVS_RESULT_CODE, TRANSACTION_ID, CARD_CODE_RESPONSE_CODE  = 5, 6, 38
+
+      CARD_CODE_ERRORS = %w( N S )
+
+      CARD_CODE_MESSAGES = {
+        "M" => "Card verification number matched",
+        "N" => "Card verification number didn't match",
+        "P" => "Card verification number was not processed",
+        "S" => "Card verification number should be on card but was not indicated",
+        "U" => "Issuer was not certified for card verification"
+      }
+
+      AVS_ERRORS = %w( A E N R W Z )
+
+      AVS_MESSAGES = {
+        "A" => "Street address matches billing information, zip/postal code does not",
+        "B" => "Address information not provided for address verification check",
+        "E" => "Address verification service error",
+        "G" => "Non-U.S. card-issuing bank",
+        "N" => "Neither street address nor zip/postal match billing information",
+        "P" => "Address verification not applicable for this transaction",
+        "R" => "Payment gateway was unavailable or timed out",
+        "S" => "Address verification service not supported by issuer",
+        "U" => "Address information is unavailable",
+        "W" => "9-digit zip/postal code matches billing information, street address does not",
+        "X" => "Street address and 9-digit zip/postal code matches billing information",
+        "Y" => "Street address and 5-digit zip/postal code matches billing information",
+        "Z" => "5-digit zip/postal code matches billing information, street address does not",
+      }
+     
+      # URL
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)        
+        add_address(post, options)        
+        add_customer_data(post, options)
+        
+        commit('AUTH_ONLY', money, post)
+      end
+      
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)        
+        add_address(post, options)   
+        add_customer_data(post, options)
+             
+        commit('AUTH_CAPTURE', money, post)
+      end                       
+    
+      def capture(money, authorization, options = {})
+        post = {:trans_id => authorization}
+        add_customer_data(post, options)
+        commit('PRIOR_AUTH_CAPTURE', money, post)
+      end
+
+      def void(authorization, options = {})
+        post = {:trans_id => authorization}
+        commit('VOID', nil, post)
+      end
+    
+      # We support visa and master card
+      def self.supported_cardtypes
+        [:visa, :master, :american_express, :discover]
+      end
+         
+      private                       
+    
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{year[-2..-1]}#{month}"
+      end
+  
+      def commit(action, money, parameters)
+        parameters[:amount]       = amount(money) unless action == 'VOID'
+        
+        # Only activate the test_request when the :test option is passed in
+        parameters[:test_request] = @options[:test] ? 'TRUE' : 'FALSE'                                  
+        
+        if result = test_result_from_cc_number(parameters[:card_num])
+          return result
+        end
+        
+        url = test? ? TEST_URL : LIVE_URL
+        data = ssl_post url, post_data(action, parameters)
+
+        @response = parse(data)
+        success = @response[:response_code] == APPROVED
+        message = message_from(@response)
+
+        # Return the response. The authorization can be taken out of the transaction_id 
+        # Test Mode on/off is something we have to parse from the response text.
+        # It usually looks something like this
+        #
+        #   (TESTMODE) Successful Sale
+        #
+        
+        test_mode = test? || message =~ /TESTMODE/
+        
+        Response.new(success, message, @response, 
+            :test => test_mode, 
+            :authorization => @response[:transaction_id]
+        )        
+      end
+                                               
+      def parse(body)
+        fields = body[1..-2].split(/\$,\$/)
+               
+        results = {         
+          :response_code => fields[RESPONSE_CODE].to_i,
+          :response_reason_code => fields[RESPONSE_REASON_CODE], 
+          :response_reason_text => fields[RESPONSE_REASON_TEXT],
+          :avs_result_code => fields[AVS_RESULT_CODE],
+          :transaction_id => fields[TRANSACTION_ID],
+          :card_code => fields[CARD_CODE_RESPONSE_CODE]          
+        }      
+        
+        
+        results[:card_code_message] = CARD_CODE_MESSAGES[results[:card_code]] if results[:card_code]
+        results[:avs_message]       = AVS_MESSAGES[results[:avs_result_code]] if results[:avs_result_code]
+        
+        results
+      end     
+
+      def post_data(action, parameters = {})
+        post = {}
+
+        post[:version]    = API_VERSION
+        post[:login]      = @options[:login]
+        post[:tran_key]   = @options[:password]
+        post[:relay_response] = "FALSE"
+        post[:type]       = action
+        post[:delim_data] = "TRUE"
+        post[:delim_char] = ","
+        post[:encap_char] = "$"
+
+        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+
+      def add_invoice(post, options)
+        post[:invoice_num] = options[:order_id]
+        post[:description] = options[:description]
+      end
+      
+      def add_creditcard(post, creditcard)      
+        post[:card_num]  = creditcard.number
+        post[:card_code] = creditcard.verification_value if creditcard.verification_value?
+        post[:exp_date]  = expdate(creditcard)
+        post[:first_name] = creditcard.first_name
+        post[:last_name]  = creditcard.last_name
+      end
+      
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+          post[:email_customer] = false
+        end
+        
+        if options.has_key? :customer
+          post[:cust_id] = options[:customer]
+        end
+        
+        if options.has_key? :ip
+          post[:customer_ip] = options[:ip]
+        end        
+      end
+
+      def add_address(post, options)      
+
+        if address = options[:billing_address] || options[:address]
+          post[:address]    = address[:address1].to_s
+          post[:company]    = address[:company].to_s
+          post[:phone]      = address[:phone].to_s
+          post[:zip]        = address[:zip].to_s       
+          post[:city]       = address[:city].to_s
+          post[:country]    = address[:country].to_s
+          post[:state]      = address[:state].blank?  ? 'n/a' : address[:state]
+        end        
+      end
+    
+      # Make a ruby type out of the response string
+      def normalize(field)
+        case field
+        when "true"   then true
+        when "false"  then false
+        when ""       then nil
+        when "null"   then nil
+        else field
+        end        
+      end          
+      
+      def message_from(results)        
+        if results[:response_code] == DECLINED
+          return CARD_CODE_MESSAGES[results[:card_code]] if CARD_CODE_ERRORS.include?(results[:card_code])
+          return AVS_MESSAGES[results[:avs_result_code]] if AVS_ERRORS.include?(results[:avs_result_code])
+        end
+        
+        return results[:response_reason_text][0..-2] # Forget the punctuation at the end
+      end
+        
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+    end
+    
+    AuthorizedNetGateway = AuthorizeNetGateway
+  end
+end

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

@@ -0,0 +1,92 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Bogus Gateway
+    class BogusGateway < Gateway
+      
+      def authorize(money, creditcard, options = {})
+        case creditcard.number
+        when '1'
+          Response.new(true, "Bogus Gateway: Forced success", {:authorized_amount => money.to_s}, :test => true, :authorization => '53433' )
+        when '2'
+          Response.new(false, "Bogus Gateway: Forced failure", {:authorized_amount => money.to_s, :error => 'Bogus Gateway: Forced failure' }, :test => true)
+        else
+          raise Error, 'Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error'
+        end      
+      end
+  
+      def purchase(money, creditcard, options = {})
+        case creditcard.number
+        when '1'
+          Response.new(true, "Bogus Gateway: Forced success", {:paid_amount => money.to_s}, :test => true)
+        when '2'
+          Response.new(false, "Bogus Gateway: Forced failure", {:paid_amount => money.to_s, :error => 'Bogus Gateway: Forced failure' },:test => true)
+        else
+          raise Error, 'Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error'
+        end
+      end
+ 
+      def credit(money, ident, options = {})
+        case ident
+        when '1'
+          Response.new(true, "Bogus Gateway: Forced success", {:paid_amount => money.to_s}, :test => true)
+        when '2'
+          Response.new(false, "Bogus Gateway: Forced failure", {:paid_amount => money.to_s, :error => 'Bogus Gateway: Forced failure' },:test => true)
+        else
+          raise Error, 'Bogus Gateway: Use trans_id 1 for success, 2 for exception and anything else for error'
+        end
+      end
+ 
+      def capture(money, ident, options = {})
+        case ident
+        when '1'
+          raise Error, 'Bogus Gateway: Use authorization number 1 for exception, 2 for error and anything else for success'
+        when '2'
+          Response.new(false, "Bogus Gateway: Forced failure", {:paid_amount => money.to_s, :error => 'Bogus Gateway: Forced failure' }, :test => true)
+        else
+          Response.new(true, "Bogus Gateway: Forced success", {:paid_amount => money.to_s}, :test => true)
+        end
+      end
+      
+      def store(creditcard, options = {})
+        case creditcard.number
+        when '1'
+          Response.new(true, "Bogus Gateway: Forced success", {:billingid => '1'}, :test => true, :authorization => '53433' )
+        when '2'
+          Response.new(false, "Bogus Gateway: Forced failure", {:billingid => nil, :error => 'Bogus Gateway: Forced failure' }, :test => true)
+        else
+          raise Error, 'Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error'
+        end              
+      end
+      
+      def unstore(identification, options = {})
+        case identification
+        when '1'
+          Response.new(true, "Bogus Gateway: Forced success", {}, :test => true)
+        when '2'
+          Response.new(false, "Bogus Gateway: Forced failure", {:error => 'Bogus Gateway: Forced failure' },:test => true)
+        else
+          raise Error, 'Bogus Gateway: Use trans_id 1 for success, 2 for exception and anything else for error'
+        end
+      end
+ 
+      # We support visa and master card
+      def self.supported_cardtypes
+        [:bogus]
+      end
+    
+      private 
+    
+      def deal_with_cc(creditcard)
+        case creditcard.number
+          when '1'
+            Response.new(true, "Bogus Gateway: Forced success", {}, :test => true)
+          when '2'
+            Response.new(false, "Bogus Gateway: Forced failure", @response, :test => true)
+          else
+            raise Error, 'Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error'
+        end      
+      end
+ 
+    end
+  end
+end

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

@@ -0,0 +1,235 @@
+# Author::    Lucas Carlson  (mailto:lucas@rufy.com)
+# Copyright:: Copyright (c) 2005 Lucas Carlson
+# License::   Distributes under the same terms as Ruby
+
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # TO USE:
+    # 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'
+    #
+    # 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)
+    #
+    # Next, create a credit card object using a TC approved test card.
+    #
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new({
+    #	    :number => '4111111111111111',
+    #	    :month => 8,
+    #	    :year => 2006,
+    #	    :first_name => 'Longbob',
+    #     :last_name => 'Longsen'
+    #   })
+    #   options = {
+    #     :login => '87654321',
+    #     :order_id => '1230123',
+    #     :email => 'bob@testbob.com',
+    #     :address => { :address1 => '47 Bobway, Bobville, WA, Australia',
+    #                   :zip => '2000'
+    #                 }
+    #     :description => 'purchased items'
+    #   }
+    #
+    # To finish setting up, create the active_merchant object you will be using, with the eWay gateway. If you have a
+    # functional eWay account, replace :login with your account info. 
+    #
+    #   gateway = ActiveMerchant::Billing::Base.gateway(:eway).new()
+    #
+    # Now we are ready to process our transaction
+    #
+    #   response = gateway.purchase(tendollar, creditcard, options)
+    #
+    # Sending a transaction to TrustCommerce with active_merchant returns a Response object, which consistently allows you to:
+    #
+    # 1) Check whether the transaction was successful
+    #
+    #   response.success?
+    #
+    # 2) Retrieve any message returned by eWay, either a "transaction was successful" note or an explanation of why the
+    # transaction was rejected.
+    #
+    #   response.message
+    #
+    # 3) Retrieve and store the unique transaction ID returned by eWway, for use in referencing the transaction in the future.
+    #
+    #   response.authorization
+    #
+    # This should be enough to get you started with eWay and active_merchant. For further information, review the methods
+    # below and the rest of active_merchant's documentation.
+
+    class EwayGateway < Gateway 
+      TEST_URL     = 'https://www.eway.com.au/gateway/xmltest/testpage.asp'
+      LIVE_URL     = 'https://www.eway.com.au/gateway/xmlpayment.asp'
+      
+      TEST_CVN_URL = 'https://www.eway.com.au/gateway_cvn/xmltest/testpage.asp'
+      LIVE_CVN_URL = 'https://www.eway.com.au/gateway_cvn/xmlpayment.asp'
+      
+      MESSAGES = {
+        "00" => "Transaction was successfully processed",
+        "A8" => "Amount is invalid",
+        "A9" => "Card number is invalid",
+        "AA" => "Account is invalid",
+        "AB" => "Card expiry date is invalid",
+        "01" => "Card verification number didn't match",
+        "05" => "Card verification number didn't match"
+      }
+      
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+	
+	    self.money_format = :cents
+	    
+    	def initialize(options = {})
+        requires!(options, :login)
+        @options = options
+        super
+    	end
+
+      # ewayCustomerEmail, ewayCustomerAddress, ewayCustomerPostcode
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        add_creditcard(post, creditcard)
+        add_address(post, options)  
+        add_customer_data(post, options)
+        add_invoice_data(post, options)
+        # The request fails if all of the fields aren't present
+        add_optional_data(post)
+    
+        commit(money, post)
+      end
+    
+      def self.supported_cardtypes
+        [:visa, :master]
+      end
+    
+      private                       
+      def add_creditcard(post, creditcard)
+        post[:CardNumber]  = creditcard.number
+        post[:CardExpiryMonth]  = sprintf("%.2i", creditcard.month)
+        post[:CardExpiryYear] = sprintf("%.4i", creditcard.year)[-2..-1]
+        post[:CustomerFirstName] = creditcard.first_name
+        post[:CustomerLastName]  = creditcard.last_name
+        post[:CardHoldersName] = creditcard.name
+              
+        post[:CVN] = creditcard.verification_value if creditcard.verification_value?
+      end 
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:CustomerAddress]    = address[:address1]
+          post[:CustomerPostcode]   = address[:zip]
+        end
+      end
+
+      def add_customer_data(post, options)
+        post[:CustomerEmail] = options[:email]
+      end
+      
+      def add_invoice_data(post, options)
+        post[:CustomerInvoiceRef] = options[:order_id]
+        post[:CustomerInvoiceDescription] = options[:description]
+      end
+
+      def add_optional_data(post)
+        post[:TrxnNumber] = nil
+        post[:Option1] = nil
+        post[:Option2] = nil
+        post[:Option3] = nil     
+      end
+
+      def commit(money, parameters)
+          
+        parameters[:TotalAmount] = amount(money)
+        
+        if result = test_result_from_cc_number(parameters[:CardNumber])
+          return result
+        end
+
+        data = ssl_post gateway_url(parameters[:CVN], test?), post_data(parameters)
+        
+        @response = parse(data)
+
+        success = (response[:ewaytrxnstatus] == "True")
+        message = message_from(response[:ewaytrxnerror])
+    
+        Response.new(success, message, @response,
+          :authorization => response[:ewayauthcode]
+        )      
+      end
+                                             
+      # Parse eway response xml into a convinient hash
+      def parse(xml)
+        #  "<?xml version=\"1.0\"?>".
+        #  <ewayResponse>
+        #  <ewayTrxnError></ewayTrxnError>
+        #  <ewayTrxnStatus>True</ewayTrxnStatus>
+        #  <ewayTrxnNumber>10002</ewayTrxnNumber>
+        #  <ewayTrxnOption1></ewayTrxnOption1>
+        #  <ewayTrxnOption2></ewayTrxnOption2>
+        #  <ewayTrxnOption3></ewayTrxnOption3>
+        #  <ewayReturnAmount>10</ewayReturnAmount>
+        #  <ewayAuthCode>123456</ewayAuthCode>
+        #  <ewayTrxnReference>987654321</ewayTrxnReference>
+        #  </ewayResponse>     
+
+        response = {}
+
+        xml = REXML::Document.new(xml)          
+        xml.elements.each('//ewayResponse/*') do |node|
+
+          response[node.name.downcase.to_sym] = normalize(node.text)
+
+        end unless xml.root.nil?
+
+        response
+      end   
+
+      def post_data(parameters = {})
+        parameters[:CustomerID] = @options[:login]
+        
+        xml   = REXML::Document.new
+        root  = xml.add_element("ewaygateway")
+        
+        parameters.each do |key, value|
+          root.add_element("eway#{key}").text = value
+        end    
+        xml.to_s
+      end
+    
+      def message_from(message)
+        return '' if message.blank?
+        MESSAGES[message[0,2]] || message
+      end
+
+      # Make a ruby type out of the response string
+      def normalize(field)
+        case field
+        when "true"   then true
+        when "false"  then false
+        when ""       then nil
+        when "null"   then nil
+        else field
+        end        
+      end
+      
+      def gateway_url(cvn, test)
+        if cvn
+          test ? TEST_CVN_URL : LIVE_CVN_URL
+        else
+          test ? TEST_URL : LIVE_URL
+        end
+      end
+    end
+  end
+end