activemerchant 1.2.1 → 1.3.0

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

@@ -2,6 +2,14 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     # Bogus Gateway
     class BogusGateway < Gateway
+      AUTHORIZATION = '53433'
+      
+      SUCCESS_MESSAGE = "Bogus Gateway: Forced success"
+      FAILURE_MESSAGE = "Bogus Gateway: Forced failure"
+      ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error"
+      CREDIT_ERROR_MESSAGE = "Bogus Gateway: Use trans_id 1 for success, 2 for exception and anything else for error"
+      UNSTORE_ERROR_MESSAGE = "Bogus Gateway: Use trans_id 1 for success, 2 for exception and anything else for error"
+      CAPTURE_ERROR_MESSAGE = "Bogus Gateway: Use authorization number 1 for exception, 2 for error and anything else for success"
       
       self.supported_countries = ['US']
       self.supported_cardtypes = [:bogus]
@@ -11,82 +19,68 @@ module ActiveMerchant #:nodoc:
       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' )
+          Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money.to_s}, :test => true, :authorization => AUTHORIZATION )
         when '2'
-          Response.new(false, "Bogus Gateway: Forced failure", {:authorized_amount => money.to_s, :error => 'Bogus Gateway: Forced failure' }, :test => true)
+          Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money.to_s, :error => FAILURE_MESSAGE }, :test => true)
         else
-          raise Error, 'Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error'
+          raise Error, ERROR_MESSAGE
         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)
+          Response.new(true, SUCCESS_MESSAGE, {: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)
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money.to_s, :error => FAILURE_MESSAGE },:test => true)
         else
-          raise Error, 'Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error'
+          raise Error, ERROR_MESSAGE
         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)
+          raise Error, CREDIT_ERROR_MESSAGE
         when '2'
-          Response.new(false, "Bogus Gateway: Forced failure", {:paid_amount => money.to_s, :error => 'Bogus Gateway: Forced failure' },:test => true)
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money.to_s, :error => FAILURE_MESSAGE }, :test => true)
         else
-          raise Error, 'Bogus Gateway: Use trans_id 1 for success, 2 for exception and anything else for error'
+          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money.to_s}, :test => true)
         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'
+          raise Error, CAPTURE_ERROR_MESSAGE
         when '2'
-          Response.new(false, "Bogus Gateway: Forced failure", {:paid_amount => money.to_s, :error => 'Bogus Gateway: Forced failure' }, :test => true)
+          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money.to_s, :error => FAILURE_MESSAGE }, :test => true)
         else
-          Response.new(true, "Bogus Gateway: Forced success", {:paid_amount => money.to_s}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, {: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' )
+          Response.new(true, SUCCESS_MESSAGE, {:billingid => '1'}, :test => true, :authorization => AUTHORIZATION )
         when '2'
-          Response.new(false, "Bogus Gateway: Forced failure", {:billingid => nil, :error => 'Bogus Gateway: Forced failure' }, :test => true)
+          Response.new(false, FAILURE_MESSAGE, {:billingid => nil, :error => FAILURE_MESSAGE }, :test => true)
         else
-          raise Error, 'Bogus Gateway: Use CreditCard number 1 for success, 2 for exception and anything else for error'
+          raise Error, ERROR_MESSAGE
         end              
       end
       
       def unstore(identification, options = {})
         case identification
         when '1'
-          Response.new(true, "Bogus Gateway: Forced success", {}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, {}, :test => true)
         when '2'
-          Response.new(false, "Bogus Gateway: Forced failure", {:error => 'Bogus Gateway: Forced failure' },:test => true)
+          Response.new(false, FAILURE_MESSAGE, {:error => FAILURE_MESSAGE },:test => true)
         else
-          raise Error, 'Bogus Gateway: Use trans_id 1 for success, 2 for exception and anything else for error'
+          raise Error, UNSTORE_ERROR_MESSAGE
         end
       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/brain_tree.rb

@@ -1,54 +1,27 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class BrainTreeGateway < Gateway
       URL = 'https://secure.braintreepaymentgateway.com/api/transact.php'
-      attr_reader :url 
-      attr_reader :response
-      attr_reader :options
-
+    
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express]
       self.homepage_url = 'http://www.braintreepaymentsolutions.com'
       self.display_name = 'Braintree'
 
-      AVS_MESSAGES = {
-        "X" => "Exact match, 9-character numeric ZIP",
-        "Y" => "Exact match, 5-character numeric ZIP",
-        "D" => "Exact match, 5-character numeric ZIP",
-        "M" => "Exact match, 5-character numeric ZIP",
-        "A" => "Address match only",
-        "B" => "Address match only",
-        "W" => "9-character numeric ZIP match only",
-        "Z" => "5-character Zip match only",
-        "P" => "5-character Zip match only",        
-        "L" => "5-character Zip match only",
-        "N" => "No address or ZIP match",
-        "C" => "No address or ZIP match",
-        "U" => "Address unavailable",
-        "G" => "Non-U.S. Issuer does not participate",
-        "I" => "Non-U.S. Issuer does not participate",
-        "R" => "Issuer system unavailable",
-        "E" => "Not a mail/phone order",
-        "S" => "Service not supported",
-        "0" => "AVS Not Available",
-        "O" => "AVS Not Available",
-        "B" => "AVS Not Available"
-      }
-      
-      CARD_CODE_MESSAGES = {
-        "M" => "CVV2/CVC2 Match",
-        "N" => "CVV2/CVC2 No Match",
-        "P" => "Not Processed",
-        "S" => "Merchant has indicated that CVV2/CVC2 is not present on card",
-        "U" => "Issuer is not certified and/or has not provided Visa encryption keys"
-      }
-
       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, creditcard, options = {})
         post = {}
         add_invoice(post, options)
@@ -59,11 +32,11 @@ module ActiveMerchant #:nodoc:
         commit('auth', money, post)
       end
       
-      def purchase(money, creditcard, options = {})
+      def purchase(money, payment_source, options = {})
         post = {}
         add_invoice(post, options)
-        add_payment_source(post, creditcard,options)        
-        add_address(post, creditcard, options)   
+        add_payment_source(post, payment_source, options)        
+        add_address(post, payment_source, options)   
         add_customer_data(post, options)
              
         commit('sale', money, post)
@@ -74,6 +47,33 @@ module ActiveMerchant #:nodoc:
         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
     
       private                             
       def add_customer_data(post, options)
@@ -103,11 +103,11 @@ module ActiveMerchant #:nodoc:
         post[:orderid] = options[:order_id].to_s.gsub(/[^\w.]/, '')
       end
       
-      def add_payment_source(params, source,options)
-        if source.is_a?(String)
-          add_customer_vault_id(params, source)
-        else
-          add_creditcard(params, source,options)
+      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
       
@@ -115,9 +115,11 @@ module ActiveMerchant #:nodoc:
         params[:customer_vault_id] = vault_id
       end
       
-      def add_creditcard(post, creditcard,options)   
-        post[:customer_vault] = "add_customer" if options[:store]
-        
+      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)
@@ -125,32 +127,35 @@ module ActiveMerchant #:nodoc:
         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[:card_code_message] = CARD_CODE_MESSAGES[results[:cvvresponse]] if results[:cvvresponse]
-        results[:avs_message]       = AVS_MESSAGES[results["avsresponse"]] if results["avsresponse"]
-        results
         
+        results
       end     
       
       def commit(action, money, parameters)
         parameters[:amount]  = amount(money) if money
         
-        if result = test_result_from_cc_number(parameters[:ccnumber])
-          return result
-        end
-        
-        data = ssl_post URL, post_data(action,parameters)
-
-        @response = parse(data)
+        response = parse( ssl_post(URL, post_data(action,parameters)) )
 
-        Response.new(@response["response"]=="1", message_from(@response), @response, 
-            :authorization => @response["transactionid"],
-            :test => test?
+        Response.new(response["response"] == "1", message_from(response), response, 
+          :authorization => response["transactionid"],
+          :test => test?,
+          :cvv_result => response["cvvresponse"],
+          :avs_result => { :code => response["avsresponse"] }
         )
         
       end
@@ -164,27 +169,34 @@ module ActiveMerchant #:nodoc:
       
 
       def message_from(response)
-         r=response["responsetext"]
-         case r
-         when "SUCCESS","Approved"
-           "This transaction has been approved"
-         when "DECLINE"
-           "This transaction has been declined"
-          else
-            r
-          end
+        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
+        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?(source.type) then :credit_card
+        when source.type == 'check' then :check
+        else raise ArgumentError, "Unsupported funding source provided"
+        end
+      end
     end
   end
 end

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

@@ -24,7 +24,7 @@ module ActiveMerchant #:nodoc:
       self.money_format = :cents
       self.default_currency = 'GBP'
       self.supported_countries = ['GB']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :solo, :switch]
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb, :maestro, :solo, :switch]
       self.homepage_url = 'http://www.cardstream.com/'
       self.display_name = 'CardStream'
 
@@ -53,12 +53,39 @@ module ActiveMerchant #:nodoc:
         :authorization => 'ESALE_KEYED'
       }
       
-      POST_HEADERS = { 'Content-Type' => 'application/x-www-form-urlencoded' }
-
-      attr_reader :url
-      attr_reader :response
-      attr_reader :options
-
+      CVV_CODE = {
+        '0' => 'U',  
+        '1' => 'P',
+        '2' => 'M',
+        '4' => 'N'
+      }
+      
+      # 0 - No additional information available.  
+      # 1 - Postcode not checked.  
+      # 2 - Postcode matched.  
+      # 4 - Postcode not matched.  
+      # 8 - Postcode partially matched.
+      AVS_POSTAL_MATCH = {
+        "0" => nil,
+        "1" => nil,
+        "2" => "Y",
+        "4" => "N",
+        "8" => "N"
+      }
+      
+      # 0 - No additional information available.  
+      # 1 - Address numeric not checked.  
+      # 2 - Address numeric matched.  
+      # 4 - Address numeric not matched.  
+      # 8 - Address numeric partially matched.
+      AVS_STREET_MATCH = {
+        "0" => nil,
+        "1" => nil,
+        "2" => "Y",
+        "4" => "N",
+        "8" => "N"
+      }
+      
       def initialize(options = {})
         requires!(options, :login, :password)
         @options = options
@@ -109,7 +136,7 @@ module ActiveMerchant #:nodoc:
         
         if [ 'american_express', 'diners_club' ].include?(credit_card.type.to_s)
           add_pair(post, :AEIT1Quantity,  1) 
-          add_pair(post, :AEIT1Description,  options[:description] || options[:order_id]) 
+          add_pair(post, :AEIT1Description,  (options[:description] || options[:order_id]).slice(0, 15)) 
           add_pair(post, :AEIT1GrossValue, amount(money))
         end
       end
@@ -136,15 +163,16 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters)
-        data = ssl_post(test? ? TEST_URL : LIVE_URL, post_data(action, parameters), POST_HEADERS)
-        @response = parse(data)
-
-        success = @response[:response_code] == APPROVED
-        message = message_from(@response)
+        response = parse( ssl_post(test? ? TEST_URL : LIVE_URL, post_data(action, parameters)) )
 
-        Response.new(success, message, @response,
+        Response.new(response[:response_code] == APPROVED, message_from(response), response,
           :test => test?,
-          :authorization => @response[:cross_reference]
+          :authorization => response[:cross_reference],
+          :cvv_result => CVV_CODE[ response[:avscv2_response_code].to_s[0, 1] ],
+          :avs_result => {
+            :street_match => AVS_STREET_MATCH[ response[:avscv2_response_code].to_s[2, 1] ],
+            :postal_match => AVS_POSTAL_MATCH[ response[:avscv2_response_code].to_s[1, 1] ]
+          }
         )
       end
 

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

@@ -15,11 +15,6 @@ module ActiveMerchant #:nodoc:
     # * productCode is a value in the line_items hash that is used to tell CyberSource what kind of item you are selling.  It is used when calculating tax/VAT.
     # * All transactions use dollar values.
     class CyberSourceGateway < Gateway
-
-      attr_reader :url 
-      attr_reader :response
-      attr_accessor :options
-
       TEST_URL = 'https://ics2wstest.ic3.com/commerce/1.x/transactionProcessor'
       LIVE_URL = 'https://ics2ws.ic3.com/commerce/1.x/transactionProcessor'
           
@@ -167,7 +162,7 @@ module ActiveMerchant #:nodoc:
       # Create all address hash key value pairs so that we still function if we were only provided with one or two of them 
       def setup_address_hash(options)
         options[:billing_address] = options[:billing_address] || options[:address] || {}
-        options[:shipping_address] = options[:shipping_address] || options[:billing_address]
+        options[:shipping_address] = options[:shipping_address] || {}
       end
       
       def build_auth_request(money, creditcard, options)
@@ -334,35 +329,20 @@ module ActiveMerchant #:nodoc:
       
       # Contact CyberSource, make the SOAP request, and parse the reply into a Response object
       def commit(request, options)
-        request_body = build_request(request, options)
-        
-        if test?
-          card_number = parse_credit_card_number(request_body)
-          if result = test? && test_result_from_cc_number(card_number)
-            return result
-          end
-        end
-        
-	      url = test? ? TEST_URL : LIVE_URL
-	      data = ssl_post(url, request_body)
-	      reply = parse(data)
+	      response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, build_request(request, options)))
         
-	      success = reply[:decision] == "ACCEPT"
-	      message = @@response_codes[('r' + reply[:reasonCode]).to_sym] rescue reply[:message] 
-        authorization = success ? [ options[:order_id], reply[:requestID], reply[:requestToken] ].compact.join(";") : nil
+	      success = response[:decision] == "ACCEPT"
+	      message = @@response_codes[('r' + response[:reasonCode]).to_sym] rescue response[:message] 
+        authorization = success ? [ options[:order_id], response[:requestID], response[:requestToken] ].compact.join(";") : nil
         
-        Response.new(success, message, reply, 
+        Response.new(success, message, response, 
           :test => test?, 
-          :authorization => authorization
+          :authorization => authorization,
+          :avs_result => { :code => response[:avsCode] },
+          :cvv_result => response[:cvCode]
         )
       end
       
-      def parse_credit_card_number(xml)
-        doc = REXML::Document.new(xml)
-        node = REXML::XPath.first(doc, '//card/accountNumber')
-        node && node.text
-      end
-
       # Parse the SOAP response
       # Technique inspired by the Paypal Gateway
       def parse(xml)