activemerchant 1.28.0 → 1.29.0

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

@@ -22,7 +22,6 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
       end
 
@@ -101,7 +100,7 @@ module ActiveMerchant #:nodoc:
         post[:orderid] = options[:order_id]
         post[:orderdescription] = options[:description]
       end
-      
+
       def add_creditcard(post, creditcard)
         post[:ccnumber] = creditcard.number
         post[:ccexp] = expdate(creditcard)
@@ -121,7 +120,7 @@ module ActiveMerchant #:nodoc:
           memo
         end
       end
-      
+
       def commit(action, money, parameters)
         parameters[:amount] = amount(money)
         data = ssl_post(self.live_url, post_data(action, parameters))
@@ -129,7 +128,7 @@ module ActiveMerchant #:nodoc:
         message = message_from(response)
         test_mode = test?
 
-        Response.new(success?(response), message, response, 
+        Response.new(success?(response), message, response,
           :test => test?,
           :authorization => response['transactionid'],
           :avs_result => {:code =>  response['avsresponse']},

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

@@ -1,52 +1,51 @@
 module ActiveMerchant #:nodoc:
-  module Billing #: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 ]   
+        self.required_fields = [ :action, :amount, :trackid ]
       end
 
       # both URLs are IP restricted
       self.test_url = 'https://apgcert.first-pay.com/AcqENGIN/SecureCapture'
       self.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  
-      
+      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                       
-      
+      end
+
       def refund(money, reference, options = {})
         requires!(options, :credit_card)
 
@@ -56,7 +55,7 @@ module ActiveMerchant #:nodoc:
         add_address(post, options)
         add_customer_data(post, options)
         add_credit_data(post, reference)
-      
+
         commit('credit', money, post)
       end
 
@@ -64,73 +63,73 @@ module ActiveMerchant #:nodoc:
         deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, reference, options)
       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[:zip]      = billing_address[:zip]
           post[:country]  = billing_address[:country]
         end
       end
-      
+
       def add_invoice(post, options)
         post[:trackid] = rand(Time.now.to_i)
       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? ? self.test_url : self.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'
@@ -139,7 +138,7 @@ module ActiveMerchant #:nodoc:
           # 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'
@@ -154,21 +153,21 @@ module ActiveMerchant #:nodoc:
             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[:vid]        = @options[:login]
         post[:password]   = @options[:password]
         post[:action]     = ACTIONS[action]
         post[:amount]     = amount(money)
-        
+
         return post.to_post_data
       end
     end

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

@@ -36,7 +36,6 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login, :password, :terminal_id, :merchant_id)
-        @options = options
         super
       end
 
@@ -198,7 +197,7 @@ module ActiveMerchant #:nodoc:
 
       def normalize(text)
         return unless text
-        
+
         if ActiveSupport::Inflector.method(:transliterate).arity == -2
           ActiveSupport::Inflector.transliterate(text,'')
         elsif RUBY_VERSION >= '1.9'

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

@@ -0,0 +1,207 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class HdfcGateway < Gateway
+      self.display_name = "HDFC"
+      self.homepage_url = "http://www.hdfcbank.com/sme/sme-details/merchant-services/guzh6m0i"
+
+      self.test_url = "https://securepgtest.fssnet.co.in/pgway/servlet/"
+      self.live_url = "https://securepg.fssnet.co.in/pgway/servlet/"
+
+      self.supported_countries = ["IN"]
+      self.default_currency = "INR"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :discover, :diners_club]
+
+      def initialize(options={})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit("purchase", post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit("authorize", post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit("capture", post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit("refund", post)
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}")}
+      CURRENCY_CODES["AED"] = "784"
+      CURRENCY_CODES["AUD"] = "036"
+      CURRENCY_CODES["CAD"] = "124"
+      CURRENCY_CODES["EUR"] = "978"
+      CURRENCY_CODES["GBP"] = "826"
+      CURRENCY_CODES["INR"] = "356"
+      CURRENCY_CODES["OMR"] = "512"
+      CURRENCY_CODES["QAR"] = "634"
+      CURRENCY_CODES["SGD"] = "702"
+      CURRENCY_CODES["USD"] = "840"
+
+      def add_invoice(post, amount, options)
+        post[:amt] = amount(amount)
+        post[:currencycode] = CURRENCY_CODES[options[:currency] || currency(amount)]
+        post[:trackid] = escape(options[:order_id], 40) if options[:order_id]
+        post[:udf1] = escape(options[:description]) if options[:description]
+        post[:eci] = options[:eci] if options[:eci]
+      end
+
+      def add_customer_data(post, options)
+        post[:udf2] = escape(options[:email]) if options[:email]
+        if address = (options[:billing_address] || options[:address])
+          post[:udf3] = escape(address[:phone]) if address[:phone]
+          post[:udf4] = escape(<<EOA)
+#{address[:name]}
+#{address[:company]}
+#{address[:address1]}
+#{address[:address2]}
+#{address[:city]} #{address[:state]} #{address[:zip]}
+#{address[:country]}
+EOA
+        end
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:member] = escape(payment_method.name, 30)
+        post[:card] = escape(payment_method.number)
+        post[:cvv2] = escape(payment_method.verification_value)
+        post[:expyear] = format(payment_method.year, :four_digits)
+        post[:expmonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_reference(post, authorization)
+        tranid, member = split_authorization(authorization)
+        post[:transid] = tranid
+        post[:member] = member
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML.fragment(fix_xml(xml))
+        doc.children.each do |node|
+          if node.text?
+            next
+          elsif (node.elements.size == 0)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.downcase}_#{childnode.name.downcase}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end
+
+        response
+      end
+
+      def fix_xml(xml)
+        xml.gsub(/&(?!(?:amp|quot|apos|lt|gt);)/, "&amp;")
+      end
+
+      ACTIONS = {
+        "purchase" => "1",
+        "refund" => "2",
+        "authorize" => "4",
+        "capture" => "5",
+      }
+
+      def commit(action, post)
+        post[:id] = @options[:login]
+        post[:password] = @options[:password]
+        post[:action] = ACTIONS[action] if ACTIONS[action]
+
+        raw = parse(ssl_post(url(action), build_request(post)))
+
+        succeeded = success_from(raw[:result])
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          :authorization => authorization_from(post, raw),
+          :test => test?
+        )
+      end
+
+      def build_request(post)
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        post.each do |field, value|
+          xml.tag!(field, value)
+        end
+        xml.target!
+      end
+
+      def url(action)
+        endpoint = "TranPortalXMLServlet"
+        (test? ? test_url : live_url) + endpoint
+      end
+
+      def success_from(result)
+        case result
+        when "CAPTURED", "APPROVED", "NOT ENROLLED", "ENROLLED"
+          true
+        else
+          false
+        end
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          (response[:error_text] || response[:result] || "Unable to read error message").split("-").last
+        end
+      end
+
+      def authorization_from(request, response)
+        [response[:tranid], request[:member]].join("|")
+      end
+
+      def split_authorization(authorization)
+        tranid, member = authorization.split("|")
+        [tranid, member]
+      end
+
+      def escape(string, max_length=250)
+        return "" unless string
+        if max_length
+          string = string[0...max_length]
+        end
+        string.gsub(/[^A-Za-z0-9 \-_@\.\n]/, '')
+      end
+    end
+  end
+end
+