activemerchant 1.1.0 → 1.2.0

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

@@ -2,13 +2,20 @@
 
 module ActiveMerchant
   module Billing
-    # ActiveMerchant Datacash Gateway
-    # 
-    # Datacash allows a policy for CV2 checks. There is currently no way
-    # to modify this programatically. The policy may be changed in the
-    # add_credit_card method.
-    # 
     class DataCashGateway < Gateway
+      self.default_currency = 'GBP'
+      self.supported_countries = ['GB']
+      
+      # From the DataCash docs; Page 13, the following cards are
+      # usable:
+      # American Express, ATM, Carte Blanche, Diners Club, Discover,
+      # EnRoute, GE Capital, JCB, Laser, Maestro, Mastercard, Solo,
+      # Switch, Visa, Visa Delta, VISA Electron, Visa Purchasing  
+      self.supported_cardtypes = [ :visa, :master, :american_express, :discover, :diners_club, :jcb, 
+          :maestro, :switch, :solo, :laser ]
+          
+      self.homepage_url = 'http://www.datacash.com/'
+      self.display_name = 'DataCash'
       
       # Datacash server URLs
       TEST_URL = 'https://testserver.datacash.com/Transaction'
@@ -25,7 +32,7 @@ module ActiveMerchant
       POLICY_ACCEPT = 'accept'
       POLICY_REJECT = 'reject'
       
-      #Datacash success code
+      # Datacash success code
       DATACASH_SUCCESS = '1'
       
       # Class attributes
@@ -33,16 +40,16 @@ module ActiveMerchant
       attr_reader :response
       attr_reader :options
       
-      # Create a new DataCashGateway
+      # Creates a new DataCashGateway
       # 
-      # The gateway requires that a valid :login and :password be passed
-      # in the options hash
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
       # 
-      # Parameters:
-      #   -options:
-      #     :login - the Datacash account login
-      #     :password - the Datacash account password
-      #     :test - boolean, use the test or live Datacash url
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The Datacash account login.
+      # * <tt>:password</tt> -- The Datacash account password.
+      # * <tt>:test => +true+ or +false+</tt> -- Use the test or live Datacash url.
       #     
       def initialize(options = {})
         requires!(options, :login, :password)
@@ -50,16 +57,13 @@ module ActiveMerchant
         super
       end
       
-      # Purchase the item straight away
+      # Perform a purchase, which is essentially an authorization and capture in a single operation.
       # 
-      # Parameters:
-      #   -money: Money object for the total to be charged
-      #   -credit_card: ActiveMerchant::Billing::CreditCard details for the transaction
-      #   -options:
+      # ==== Parameters
       #
-      # Returns:
-      #   -ActiveRecord::Billing::Response object
-      #   
+      # * <tt>money</tt> -- The amount to be purchased.  Either an Integer value in cents or a Money object.
+      # * <tt>credit_card</tt> -- The CreditCard details for the transaction.
+      # * <tt>options</tt> -- A hash of optional parameters.
       def purchase(money, credit_card, options = {})
         if result = test_result_from_cc_number(credit_card.number)
           return result
@@ -70,19 +74,14 @@ module ActiveMerchant
         commit(request)
       end
       
-      # Authorize the transaction
-      # 
-      # Reserves the funds on the customer's credit card, but does not 
+      # Performs an authorization, which reserves the funds on the customer's credit card, but does not 
       # charge the card.
       # 
-      # Parameters:
-      #   -money: Money object for the total to be charged
-      #   -credit_card: ActiveMerchant::Billing::CreditCard details for the transaction
-      #   -options:
+      # ==== Parameters
       #
-      # Returns:
-      #   -ActiveRecord::Billing::Response object
-      #   
+      # * <tt>money</tt> -- The amount to be authorized.  Either an Integer value in cents or a Money object.
+      # * <tt>credit_card</tt> -- The CreditCard details for the transaction.
+      # * <tt>options</tt> -- A hash of optional parameters.   
       def authorize(money, credit_card, options = {})
         if result = test_result_from_cc_number(credit_card.number)
           return result
@@ -93,24 +92,12 @@ module ActiveMerchant
         commit(request)
       end
       
-      # Datacash requires both the reference and the authcode of the original
-      # authorization.  To maintain the same interface as the other
-      # gateways the two numbers are concatenated together with an ; separator as
-      # the authorization number returned by authorization
-      
-      # Captures the funds from an authorized transaction. 
-      # authorization must be a valid Datacash reference and :authcode must be
-      # a valid Datacash authcode from a prior authorized transaction.
+      # Captures the funds from an authorized transaction.
       # 
-      # This needs to create a 'historic txn' to fulfill
-      # 
-      # Parameters:
-      #   -money: Money object for the total to be charged
-      #   -authorization: the Datacash reference and authcode from the previous authorization
+      # ==== Parameters
       #
-      # Returns:
-      #   -ActiveRecord::Billing::Response object
-      #   
+      # * <tt>money</tt> -- The amount to be captured.  Either an Integer value in cents or a Money object.
+      # * <tt>authorization</tt> -- The authorization returned from the previous authorize request.   
       def capture(money, authorization, options = {})
         request = build_void_or_capture_request(FULFILL_TYPE, money, authorization, options)
 
@@ -119,46 +106,16 @@ module ActiveMerchant
       
       # Void a previous transaction
       # 
-      # This needs to create a 'historic txn' to fulfil
-      # 
-      # Parameters:
-      #   -authorization: the Datacash reference from the previous authorization
+      # ==== Parameters
       #
-      # Returns:
-      #   -ActiveRecord::Billing::Response object
-      #   
+      # * <tt>authorization</tt> - The authorization returned from the previous authorize request.   
       def void(authorization, options = {})
         request = build_void_or_capture_request(CANCEL_TYPE, nil, authorization, options)
         
         commit(request)
       end
       
-      # From the DataCash docs; Page 13, the following cards are
-      # usable
-      # 
-      # American Express, ATM, Carte Blanche, Diners Club, Discover,
-      # EnRoute, GE Capital, JCB, Laser, Maestro, Mastercard, Solo,
-      # Switch, Unknown, Visa, Visa Delta, VISA Electron, Visa Purchasing
-      # 
-      # Parameters:
-      #   -none
-      # 
-      # Returns:
-      #   -the list of all supported cards
-      #   
-      def self.supported_cardtypes
-        [ :visa, :master, :american_express, :discover, :diners_club, :jcb, 
-          :switch, :solo ]
-      end
-      
-      # Return whether or not the gateway is in test mode
-      # 
-      # Parameters:
-      #   -none
-      # 
-      # Returns:
-      #   -boolean
-      #   
+      # Is the gateway running in test mode?
       def test?
         @options[:test] || Base.gateway_mode == :test
       end
@@ -213,7 +170,7 @@ module ActiveMerchant
             if money
               xml.tag! :TxnDetails do
                 xml.tag! :merchantreference, format_reference_number(options[:order_id])
-                xml.tag! :amount, amount(money), :currency => currency(money)
+                xml.tag! :amount, amount(money), :currency => options[:currency] || currency(money)
               end
             end
           end
@@ -296,7 +253,7 @@ module ActiveMerchant
             end
             xml.tag! :TxnDetails do
               xml.tag! :merchantreference, format_reference_number(options[:order_id])
-              xml.tag! :amount, amount(money), :currency => currency(money)
+              xml.tag! :amount, amount(money), :currency => options[:currency] || currency(money)
             end
           end
         end
@@ -404,19 +361,6 @@ module ActiveMerchant
         )
       end
       
-      # Find the currency of the Money object passed
-      # 
-      # Parameters:
-      #   -money: The money object that we are looking at
-      #   
-      # Returns:
-      #   -string: The three digit currency code (These are
-      #            ISO 4217 codes)
-      #            
-      def currency(money)
-        money.respond_to?(:currency) ? money.currency : 'GBP'
-      end
-      
       # Returns a date string in the format Datacash expects
       # 
       # Parameters:

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

@@ -0,0 +1,256 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+
+    class EfsnetGateway < Gateway
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+ 
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.concordefsnet.com/'
+      self.display_name = 'Efsnet'
+     
+      TEST_URL = 'https://testefsnet.concordebiz.com/efsnet.dll'
+      LIVE_URL = 'https://efsnet.concordebiz.com/efsnet.dll'
+      
+      # login is your Store ID
+      # password is your Store Key
+      def initialize(options = {})
+        requires!(options, :login, :password)
+      
+        @options = options
+        @url = test? ? TEST_URL : LIVE_URL      
+        
+        super      
+      end
+      
+      def test?
+        @options[:test] || Base.gateway_mode == :test
+      end
+      
+      def authorize(money, creditcard, options = {})
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_authorize, request)
+      end
+
+      def purchase(money, creditcard, options = {})
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_charge, request)
+      end
+     
+      def capture(money, identification, options = {})
+        request = build_refund_or_settle_request(money, identification, options)
+        commit(:credit_card_settle, request)
+      end
+
+      def credit(money, identification_or_credit_card, options = {})
+        if identification_or_credit_card.is_a?(String)
+          # Perform authorization reversal
+          request = build_refund_or_settle_request(money, identification_or_credit_card, options)
+          commit(:credit_card_refund, request)
+        else
+          # Perform credit
+          request = build_credit_card_request(money, identification_or_credit_card, options)
+          commit(:credit_card_credit, request)
+        end
+      end
+
+      def void(identification, options = {})
+        requires!(options, :order_id)
+        original_transaction_id, original_transaction_amount = identification.split(";")
+        commit(:void_transaction, {:reference_number => options[:order_id], :transaction_ID => original_transaction_id})
+      end
+      
+      def voice_authorize(money, authorization_code, creditcard, options = {})
+        options[:authorization_number] = authorization_code
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_voice_authorize, request)
+      end
+      
+      def force(money, authorization_code, creditcard, options = {})
+        options[:authorization_number] = authorization_code
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_capture, request)
+      end
+      
+      def system_check
+        commit(:system_check, {})      
+      end
+
+      private
+
+      def build_refund_or_settle_request(money, identification, options = {})
+        original_transaction_id, original_transaction_amount = identification.split(";")
+        
+        requires!(options, :order_id)
+
+        post = {
+          :reference_number => options[:order_id],
+          :transaction_amount => amount(money),
+          :original_transaction_amount => original_transaction_amount,
+          :original_transaction_ID => original_transaction_id,
+          :client_ip_address => options[:ip]
+        }
+      end
+    
+      def build_credit_card_request(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {
+          :reference_number => options[:order_id],
+          :authorization_number => options[:authorization_number],
+          :transaction_amount => amount(money),
+          :client_ip_address => options[:ip]
+          
+        }
+        add_creditcard(post,creditcard)
+        add_address(post,options)
+        post
+      end
+    
+      def add_address(post,options)
+        if address = options[:billing_address] || options[:address]
+          if address[:address2]
+            post[:billing_address]    = address[:address1].to_s << ' ' <<  address[:address2].to_s
+          else
+            post[:billing_address]    = address[:address1].to_s
+          end
+          post[:billing_city]         = address[:city].to_s
+          post[:billing_state]        = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:billing_postal_code]  = address[:zip].to_s       
+          post[:billing_country]      = address[:country].to_s
+        end
+
+        if address = options[:shipping_address]
+          if address[:address2]
+            post[:shipping_address]   = address[:address1].to_s << ' ' <<  address[:address2].to_s
+          else
+            post[:shipping_address]   = address[:address1].to_s
+          end
+          post[:shipping_city]        = address[:city].to_s
+          post[:shipping_state]       = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:shipping_postal_code] = address[:zip].to_s       
+          post[:shipping_country]     = address[:country].to_s
+        end
+      end
+
+      def add_creditcard(post, creditcard)      
+        post[:billing_name]  = creditcard.name if creditcard.name
+        post[:account_number]  = creditcard.number
+        post[:card_verification_value] = creditcard.verification_value if creditcard.verification_value?
+        post[:expiration_month]  = sprintf("%.2i", creditcard.month)
+        post[:expiration_year]  = sprintf("%.4i", creditcard.year)[-2..-1]
+      end
+
+  
+      def commit(action, parameters)                                 
+        if result = test_result_from_cc_number(parameters[:account_number])
+          return result
+        end
+
+        parameters.delete_if {|key,value| value.blank?}       
+
+        headers = { 'Content-Type' => 'text/xml' }
+        data = ssl_post @url, post_data(action, parameters), headers
+
+        @response = parse(data)
+
+        success = (response[:response_code] and response[:response_code] == '0')
+        message = message_form(response[:result_message])
+        
+        authorization = [ response[:transaction_id], parameters[:transaction_amount] ].compact.join(';')
+        
+        Response.new(success, message, @response,
+          :test => test?,
+          :authorization => authorization
+        )
+      end
+                                               
+      # Parse response xml into a convinient hash
+      def parse(xml)
+        #<Reply>
+        #<TransactionReply>
+        #<ResponseCode>0</ResponseCode>
+        #<ResultCode>00</ResultCode>
+        #<ResultMessage>APPROVED</ResultMessage>
+        #<TransactionID>200011125443</TransactionID>
+        #<AVSResponseCode>N</AVSResponseCode>
+        #<CVVResponseCode></CVVResponseCode>
+        #<ApprovalNumber>123456</ApprovalNumber>
+        #<AuthorizationNumber>123456</AuthorizationNumber>
+        #<TransactionDate>070728</TransactionDate>
+        #<TransactionTime>024734</TransactionTime>
+        #<ReferenceNumber>19786</ReferenceNumber>
+        #<AccountNumber>XXXXXXXXXXXX5454</AccountNumber>
+        #<TransactionAmount>1.00</TransactionAmount>
+        #</TransactionReply>
+        #</Reply>
+
+        response = {}
+
+        xml = REXML::Document.new(xml)          
+
+        xml.elements.each('//Reply//TransactionReply/*') do |node|
+
+          response[node.name.underscore.to_sym] = normalize(node.text)
+
+        end unless xml.root.nil?
+
+        response
+      end     
+
+      def post_data(action, parameters = {})
+        xml   = REXML::Document.new("<?xml version='1.0' encoding='UTF-8'?>")
+        root  = xml.add_element("Request")
+        root.attributes["StoreID"] = options[:login]
+        root.attributes["StoreKey"] = options[:password]
+        root.attributes["ApplicationID"] = 'ot 1.0'
+        transaction = root.add_element(action.to_s.camelize)
+
+        actions[action].each do |key|
+          transaction.add_element(key.to_s.camelize).text = parameters[key] unless parameters[key].blank?
+        end
+
+        xml.to_s
+      end
+    
+      def message_form(message)
+        return 'Unspecified error' if message.blank?
+        message.gsub(/[^\w]/, ' ').split.join(" ").capitalize
+      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 actions
+        ACTIONS
+      end
+
+
+      CREDIT_CARD_FIELDS =  [:authorization_number, :client_ip_address, :billing_address, :billing_city, :billing_state, :billing_postal_code, :billing_country, :billing_name, :card_verification_value, :expiration_month, :expiration_year, :reference_number, :transaction_amount, :account_number ]
+
+      ACTIONS = {
+           :credit_card_authorize		=> CREDIT_CARD_FIELDS,
+           :credit_card_charge			=> CREDIT_CARD_FIELDS,
+           :credit_card_voice_authorize		=> CREDIT_CARD_FIELDS,
+           :credit_card_capture			=> CREDIT_CARD_FIELDS,
+           :credit_card_credit			=> CREDIT_CARD_FIELDS << :original_transaction_amount,
+           :credit_card_refund			=> [:reference_number, :transaction_amount, :original_transaction_amount, :original_transaction_ID, :client_ip_address],
+           :void_transaction			=> [:reference_number, :transaction_ID],
+           :credit_card_settle			=> [:reference_number, :transaction_amount, :original_transaction_amount, :original_transaction_ID, :client_ip_address],
+           :system_check			=> [:system_check],
+      }    
+    end
+  end
+end