activemerchant 1.4.2 → 1.5.0

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

@@ -1,222 +1,17 @@
-require File.join(File.dirname(__FILE__), '..', 'check.rb')
-
+require File.join(File.dirname(__FILE__),'smart_ps.rb')
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    class BraintreeGateway < Gateway
-      URL = 'https://secure.braintreepaymentgateway.com/api/transact.php'
+    class BraintreeGateway < SmartPs
+      def api_url 
+        'https://secure.braintreepaymentgateway.com/api/transact.php'
+      end
     
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.homepage_url = 'http://www.braintreepaymentsolutions.com'
       self.display_name = 'Braintree'
-
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        @options = options
-        super
-      end  
-      
-      # Pass :store => true in the options to store the 
-      # payment info at BrainTree and get a generated 
-      # customer_vault_id in the response.  
-      # Pass :store => some_number_or_string to specify the
-      # customer_vault_id BrainTree should use (make sure it's
-      # unique).
-      def authorize(money, payment_source, options = {})
-        post = {}
-        add_invoice(post, options)
-        add_payment_source(post, payment_source, options)        
-        add_address(post, payment_source, options)        
-        add_customer_data(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, payment_source, options)   
-        add_customer_data(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
-      
-      # Update the values (such as CC expiration) stored at
-      # BrainTree.  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, creditcard, options)   
-        add_customer_data(post, options)
-             
-        commit(nil, 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 = {})
-        billing_id = options.delete(:billing_id).to_s || true
-        post = {}
-        post[:customer_vault] = 'add_customer'
-        if billing_id
-          post[:customer_vault_id] = billing_id
-        end
-        add_payment_source(post, payment_source, options)
-        add_address(post, payment_source, options)
-        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, creditcard, options)     
-        if address = options[:billing_address] || options[:address]
-          post[:address1]    = address[:address1].to_s
-          post[:address2]    = address[:address2].to_s unless address[:address2].blank?
-          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
-
-      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)
-        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)
-        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 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(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("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-      
-
-      def message_from(response)
-        case response["responsetext"]
-        when "SUCCESS","Approved"
-          "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
+      self.default_currency = 'USD'
     end
-    
-    BrainTreeGateway = BraintreeGateway
   end
 end
 

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

@@ -1,5 +1,3 @@
-# Authors::    MoneySpyder, http://moneyspyder.co.uk and E-consultancy, http://www.e-consultancy.com
-
 module ActiveMerchant
   module Billing
     class DataCashGateway < Gateway
@@ -58,7 +56,7 @@ module ActiveMerchant
       # Perform a purchase, which is essentially an authorization and capture in a single operation.
       # 
       # ==== Parameters
-      # * <tt>money</tt> The amount to be authorized.  Either an Integer value in cents or a Money object.
+      # * <tt>money</tt> The amount to be authorized as an Integer value in cents.
       # * <tt>authorization_or_credit_card</tt>:: The continuous authority reference or CreditCard details for the transaction.
       # * <tt>options</tt> A hash of optional parameters.
       #   * <tt>:order_id</tt> A unique reference for this order (corresponds to merchantreference in datacash documentation)
@@ -86,7 +84,7 @@ module ActiveMerchant
       #
       # ==== Parameters
       #
-      # * <tt>money</tt> The amount to be authorized.  Either an Integer value in cents or a Money object.
+      # * <tt>money</tt> The amount to be authorized as an Integer value in cents.
       # * <tt>authorization_or_credit_card</tt>:: The continuous authority reference or CreditCard details for the transaction.
       # * <tt>options</tt> A hash of optional parameters.
       #   * <tt>:order_id</tt> A unique reference for this order (corresponds to merchantreference in datacash documentation)
@@ -113,7 +111,7 @@ module ActiveMerchant
       # 
       # ==== Parameters
       #
-      # * <tt>money</tt> -- The amount to be captured.  Either an Integer value in cents or a Money object.
+      # * <tt>money</tt> -- The amount to be captured as anInteger value in cents.
       # * <tt>authorization</tt> -- The authorization returned from the previous authorize request.   
       def capture(money, authorization, options = {})
         commit(build_void_or_capture_request(FULFILL_TYPE, money, authorization, options))
@@ -134,7 +132,7 @@ module ActiveMerchant
       # 
       # ==== Parameters
       #
-      # * <tt>money</tt> The amount to be refunded. Either an Integer value in cents or a Money object. Set to nil for a full refund on existing transaction.
+      # * <tt>money</tt> The amount to be refunded as an Integer value in cents. Set to nil for a full refund on existing transaction.
       # * <tt>reference_or_credit_card</tt> The credit card you want to refund OR the datacash_reference for the existing transaction you are refunding
       # * <tt>options</tt> Are ignored when refunding via reference to an existing transaction, otherwise
       #   * <tt>:order_id</tt> A unique reference for this order (corresponds to merchantreference in datacash documentation)
@@ -177,7 +175,7 @@ module ActiveMerchant
       # 
       # Parameters:
       # * <tt>type</tt> must be FULFILL_TYPE or CANCEL_TYPE
-      # * <tt>money</tt> - optional - Money object or value in cents
+      # * <tt>money</tt> - optional - Integer value in cents
       # * <tt>authorization</tt> - the Datacash authorization from a previous succesful authorize transaction
       # * <tt>options</tt>
       #   * <tt>order_id</tt> - A unique reference for the transaction

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

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/viaklix'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # = Elavon Virtual Merchant Gateway
+    #
+    # == Example use:
+    #
+    #   gateway = ActiveMerchant::Billing::ElavonGateway.new(
+    #               :login     => "my_virtual_merchant_id",
+    #               :password  => "my_virtual_merchant_pin",
+    #               :user      => "my_virtual_merchant_user_id" # optional
+    #            )
+    #
+    #   # set up credit card obj as in main ActiveMerchant example
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
+    #     :type       => 'visa',
+    #     :number     => '41111111111111111',
+    #     :month      => 10,
+    #     :year       => 2011,
+    #     :first_name => 'Bob',
+    #     :last_name  => 'Bobsen'
+    #   )
+    #
+    #   # run request
+    #   response = gateway.purchase(1000, creditcard) # authorize and capture 10 USD
+    #
+    #   puts response.success?      # Check whether the transaction was successful
+    #   puts response.message       # Retrieve the message returned by Elavon
+    #   puts response.authorization # Retrieve the unique transaction ID returned by Elavon
+    #
+    class ElavonGateway < ViaklixGateway
+      self.test_url = self.live_url = 'https://www.myvirtualmerchant.com/VirtualMerchant/process.do'
+
+      self.display_name = 'Elavon MyVirtualMerchant'
+      self.supported_countries = ['US', 'CA']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.elavon.com/'
+
+      self.delimiter = "\n"
+      self.actions = {
+        :purchase => 'CCSALE',
+        :credit => 'CCCREDIT',
+        :authorize => 'CCAUTHONLY',
+        :capture => 'CCFORCE'
+      }
+      
+      # Authorize a credit card for a given amount.
+      # 
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be authorized as an Integer value in cents.
+      # * <tt>credit_card</tt> - The CreditCard details for the transaction.
+      # * <tt>options</tt>
+      #   * <tt>:billing_address</tt> - The billing address for the cardholder.      
+      def authorize(money, creditcard, options = {})
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)        
+        add_address(form, options)   
+        add_customer_data(form, options)
+        commit(:authorize, money, form)
+      end
+      
+      # Capture authorized funds from a credit card.
+      # 
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be captured as an Integer value in cents.
+      # * <tt>authorization</tt> - The approval code returned from the initial authorization.
+      # * <tt>options</tt>
+      #   * <tt>:credit_card</tt> - The CreditCard details from the initial transaction (required).
+      def capture(money, authorization, options = {})
+        requires!(options, :credit_card)
+        
+        form = {}
+        add_reference(form, authorization)
+        add_invoice(form, options)
+        add_creditcard(form, options[:credit_card])
+        add_customer_data(form, options)
+        commit(:capture, money, form)
+      end
+      
+      private
+      def add_reference(form, authorization)
+        form[:approval_code] = authorization
+      end
+      
+      def authorization_from(response)
+        response['approval_code']
+      end
+      
+      def add_verification_value(form, creditcard)
+        form[:cvv2cvc2] = creditcard.verification_value 
+        form[:cvv2cvc2_indicator] = '1'
+      end
+
+      def add_address(form,options)
+        billing_address = options[:billing_address] || options[:address] 
+        
+        if billing_address
+          form[:avs_address]    = billing_address[:address1].to_s.slice(0, 30)
+          form[:address2]       = billing_address[:address2].to_s.slice(0, 30)
+          form[:avs_zip]        = billing_address[:zip].to_s.slice(0, 10)
+          form[:city]           = billing_address[:city].to_s.slice(0, 30)
+          form[:state]          = billing_address[:state].to_s.slice(0, 10)
+          form[:company]        = billing_address[:company].to_s.slice(0, 50)
+          form[:phone]          = billing_address[:phone].to_s.slice(0, 20)
+          form[:country]        = billing_address[:country].to_s.slice(0, 50)
+        end
+                
+        if shipping_address = options[:shipping_address]
+          first_name, last_name = parse_first_and_last_name(shipping_address[:name])
+          form[:ship_to_first_name]     = first_name.to_s.slice(0, 20)
+          form[:ship_to_last_name]      = last_name.to_s.slice(0, 30)
+          form[:ship_to_address1]       = shipping_address[:address1].to_s.slice(0, 30)
+          form[:ship_to_address2]       = shipping_address[:address2].to_s.slice(0, 30)
+          form[:ship_to_city]           = shipping_address[:city].to_s.slice(0, 30)
+          form[:ship_to_state]          = shipping_address[:state].to_s.slice(0, 10)
+          form[:ship_to_company]        = shipping_address[:company].to_s.slice(0, 50)
+          form[:ship_to_country]        = shipping_address[:country].to_s.slice(0, 50)
+          form[:ship_to_zip]            = shipping_address[:zip].to_s.slice(0, 10)
+        end
+      end
+      
+      def message_from(response)
+        success?(response) ? response['result_message'] : response['errorMessage']
+      end
+      
+      def success?(response)
+        !response.has_key?('errorMessage')
+      end
+    end
+  end
+end
+

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

@@ -131,7 +131,7 @@ module ActiveMerchant #:nodoc:
       
 	    self.money_format = :cents
       self.supported_countries = ['AU']
-      self.supported_cardtypes = [:visa, :master]
+      self.supported_cardtypes = [:visa, :master, :american_express]
       self.homepage_url = 'http://www.eway.com.au/'
       self.display_name = 'eWAY'
 	    
@@ -155,7 +155,11 @@ module ActiveMerchant #:nodoc:
     
         commit(money, post)
       end
-    
+      
+      def test?
+        @options[:test] || super
+      end
+      
       private                       
       def add_creditcard(post, creditcard)
         post[:CardNumber]  = creditcard.number
@@ -267,6 +271,7 @@ module ActiveMerchant #:nodoc:
           test ? TEST_URL : LIVE_URL
         end
       end
+      
     end
   end
 end

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

@@ -0,0 +1,172 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:    
+    class FirstPayGateway < Gateway
+      class FirstPayPostData < PostData
+        # Fields that will be sent even if they are blank
+        self.required_fields = [ :action, :amount, :trackid ]   
+      end
+
+      # both URLs are IP restricted
+      TEST_URL = 'https://apgcert.first-pay.com/AcqENGIN/SecureCapture'
+      LIVE_URL = 'https://acqengin.first-pay.com/AcqENGIN/SecureCapture'
+      
+      # 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]
+      
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.first-pay.com'
+      
+      # The name of the gateway
+      self.display_name = 'First Pay'
+      
+      # all transactions are in cents
+      self.money_format = :cents
+      
+      ACTIONS = {
+        'sale' => 1,
+        'credit' => 2,
+        'void' => 3
+      }
+      
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      def purchase(money, creditcard, options = {})
+        post = FirstPayPostData.new
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        
+        commit('sale', money, post)
+      end                       
+      
+      def credit(money, reference, options = {})
+        raise ArgumentError, "Both TransactionID and CreditCard are required" unless reference.is_a?(String) && options[:credit_card]
+
+        post = FirstPayPostData.new
+        add_invoice(post, options)
+        add_creditcard(post, options[:credit_card])
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_credit_data(post, reference)
+      
+        commit('credit', money, post)
+      end
+      
+      def void(money, creditcard, options = {})
+        post = FirstPayPostData.new
+        add_creditcard(post, creditcard)
+        add_void_data(post, options)
+        add_invoice(post, options)
+        add_customer_data(post, options)
+        
+        commit('void', money, post)
+      end
+      
+      
+      private
+      
+      def add_customer_data(post, options)
+        post[:cardip] = options[:ip]
+        post[:email] = options[:email]
+      end
+      
+      def add_address(post, options)
+        if billing_address = options[:billing_address] || options[:address]
+          post[:addr]     = billing_address[:address1].to_s + ' ' + billing_address[:address2].to_s
+          post[:city]     = billing_address[:city]
+          post[:state]    = billing_address[:state]
+          post[:zip]      = billing_address[:zip]                             
+          post[:country]  = billing_address[:country]
+        end
+      end
+      
+      def add_invoice(post, options)
+        post[:trackid] = rand(Time.now)
+      end
+      
+      def add_creditcard(post, creditcard)
+        post[:member] = creditcard.first_name.to_s + " " + creditcard.last_name.to_s
+        post[:card] = creditcard.number
+        post[:exp] = expdate(creditcard)
+      end
+      
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+      
+      def add_credit_data(post, transaction_id)
+        post[:transid] = transaction_id
+      end
+      
+      def add_void_data(post, options)
+        post[:transid] = options[:transactionid]
+      end
+      
+      def commit(action, money, post)
+        response = parse( ssl_post(test? ? TEST_URL : LIVE_URL, post_data(action, post, money)) )
+                
+        Response.new(response[:response] == 'CAPTURED', response[:message], response,
+          :test => test?,
+          :authorization => response[:authorization],
+          :avs_result => { :code => response[:avsresponse] },
+          :cvv_result => response[:cvvresponse])
+      end
+      
+      def parse(body)
+        response = {}
+        
+        # check for an error first
+        if body.include?('!ERROR!')
+          response[:response] = 'ERROR'
+          response[:message] = error_message_from(body)
+        else
+          # a capture / not captured response will be : delimited
+          split = body.split(':')
+          response[:response] = split[0]
+          
+          # FirstPay docs are worthless. turns out the transactionid is required for credits
+          # so we need to store that in authorization, not the actual auth.
+          if response[:response] == 'CAPTURED'
+            response[:message] = 'CAPTURED'
+            response[:authorization] = split[9] # actually the transactionid
+            response[:auth] = split[1]
+            response[:avsresponse] = split[3]
+            response[:cvvresponse] = split[17]
+          else
+            # NOT CAPTURED response
+            response[:message] = split[1]
+            response[:transactionid] = split[9]
+          end
+        end
+        
+        return response
+      end
+      
+      def error_message_from(response)
+        # error messages use this format - '!ERROR! 704-MISSING BASIC DATA TYPE:card, exp, zip, addr, member, amount\n'
+        response.split("! ")[1].chomp
+      end
+      
+      def post_data(action, post, money)
+        post[:vid]        = @options[:login]  
+        post[:password]   = @options[:password]
+        post[:action]     = ACTIONS[action]
+        post[:amount]     = amount(money)
+        
+        return post.to_post_data
+      end
+    end
+  end
+end
+