aktivemerchant 2.0.0

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

@@ -0,0 +1,257 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class GarantiGateway < Gateway
+      self.live_url = self.test_url = 'https://sanalposprov.garanti.com.tr/VPServlet'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US','TR']
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'https://sanalposweb.garanti.com.tr'
+
+      # The name of the gateway
+      self.display_name = 'Garanti Sanal POS'
+
+      self.default_currency = 'TRL'
+
+      self.money_format = :cents
+
+      CURRENCY_CODES = {
+        'YTL' => 949,
+        'TRL' => 949,
+        'TL'  => 949,
+        'USD' => 840,
+        'EUR' => 978,
+        'GBP' => 826,
+        'JPY' => 392
+      }
+
+
+      def initialize(options = {})
+        requires!(options, :login, :password, :terminal_id, :merchant_id)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        options = options.merge(:gvp_order_type => "sales")
+        commit(money, build_sale_request(money, credit_card, options))
+      end
+
+      def authorize(money, credit_card, options = {})
+        options = options.merge(:gvp_order_type => "preauth")
+        commit(money, build_authorize_request(money, credit_card, options))
+      end
+
+      def capture(money, ref_id, options = {})
+        options = options.merge(:gvp_order_type => "postauth")
+        commit(money, build_capture_request(money, ref_id, options))
+      end
+
+      private
+
+      def security_data
+        rjusted_terminal_id = @options[:terminal_id].to_s.rjust(9, "0")
+        Digest::SHA1.hexdigest(@options[:password].to_s + rjusted_terminal_id).upcase
+      end
+
+      def generate_hash_data(order_id, terminal_id, credit_card_number, amount, security_data)
+        data = [order_id, terminal_id, credit_card_number, amount, security_data].join
+        Digest::SHA1.hexdigest(data).upcase
+      end
+
+      def build_xml_request(money, credit_card, options, &block)
+        card_number = credit_card.respond_to?(:number) ? credit_card.number : ''
+        hash_data   = generate_hash_data(format_order_id(options[:order_id]), @options[:terminal_id], card_number, amount(money), security_data)
+
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
+
+        xml.tag! 'GVPSRequest' do
+          xml.tag! 'Mode', test? ? 'TEST' : 'PROD'
+          xml.tag! 'Version', 'V0.01'
+          xml.tag! 'Terminal' do
+            xml.tag! 'ProvUserID', 'PROVAUT'
+            xml.tag! 'HashData', hash_data
+            xml.tag! 'UserID', @options[:login]
+            xml.tag! 'ID', @options[:terminal_id]
+            xml.tag! 'MerchantID', @options[:merchant_id]
+          end
+
+          if block_given?
+            yield xml
+          else
+            xml.target!
+          end
+        end
+      end
+
+      def build_sale_request(money, credit_card, options)
+        build_xml_request(money, credit_card, options) do |xml|
+          add_customer_data(xml, options)
+          add_order_data(xml, options) do
+            add_addresses(xml, options)
+          end
+          add_credit_card(xml, credit_card)
+          add_transaction_data(xml, money, options)
+
+          xml.target!
+        end
+      end
+
+      def build_authorize_request(money, credit_card, options)
+         build_xml_request(money, credit_card, options) do |xml|
+          add_customer_data(xml, options)
+          add_order_data(xml, options)  do
+            add_addresses(xml, options)
+          end
+          add_credit_card(xml, credit_card)
+          add_transaction_data(xml, money, options)
+
+          xml.target!
+        end
+      end
+
+      def build_capture_request(money, ref_id, options)
+        options = options.merge(:order_id => ref_id)
+         build_xml_request(money, ref_id, options) do |xml|
+          add_customer_data(xml, options)
+          add_order_data(xml, options)
+          add_transaction_data(xml, money, options)
+
+          xml.target!
+        end
+      end
+
+      def add_customer_data(xml, options)
+        xml.tag! 'Customer' do
+          xml.tag! 'IPAddress', options[:ip] || '1.1.1.1'
+          xml.tag! 'EmailAddress', options[:email]
+        end
+      end
+
+      def add_order_data(xml, options, &block)
+        xml.tag! 'Order' do
+          xml.tag! 'OrderID', format_order_id(options[:order_id])
+          xml.tag! 'GroupID'
+
+          if block_given?
+            yield xml
+          end
+        end
+      end
+
+      def add_credit_card(xml, credit_card)
+        xml.tag! 'Card' do
+          xml.tag! 'Number', credit_card.number
+          xml.tag! 'ExpireDate', [format_exp(credit_card.month), format_exp(credit_card.year)].join
+          xml.tag! 'CVV2', credit_card.verification_value
+        end
+      end
+
+      def format_exp(value)
+        format(value, :two_digits)
+      end
+
+      # OrderId field must be A-Za-z0-9_ format and max 36 char
+      def format_order_id(order_id)
+        order_id.to_s.gsub(/[^A-Za-z0-9_]/, '')[0...36]
+      end
+
+      def add_addresses(xml, options)
+        xml.tag! 'AddressList' do
+          if billing_address = options[:billing_address] || options[:address]
+            xml.tag! 'Address' do
+              xml.tag! 'Type', 'B'
+              add_address(xml, billing_address)
+            end
+          end
+
+          if options[:shipping_address]
+            xml.tag! 'Address' do
+              xml.tag! 'Type', 'S'
+              add_address(xml, options[:shipping_address])
+            end
+          end
+        end
+      end
+
+      def add_address(xml, address)
+        xml.tag! 'Name', normalize(address[:name])
+        address_text = address[:address1]
+        address_text << " #{ address[:address2]}" if address[:address2]
+        xml.tag! 'Text', normalize(address_text)
+        xml.tag! 'City', normalize(address[:city])
+        xml.tag! 'District', normalize(address[:state])
+        xml.tag! 'PostalCode', address[:zip]
+        xml.tag! 'Country', normalize(address[:country])
+        xml.tag! 'Company', normalize(address[:company])
+        xml.tag! 'PhoneNumber', address[:phone].to_s.gsub(/[^0-9]/, '') if address[:phone]
+      end
+
+      def normalize(text)
+        return unless text
+
+        if ActiveSupport::Inflector.method(:transliterate).arity == -2
+          ActiveSupport::Inflector.transliterate(text,'')
+        elsif RUBY_VERSION >= '1.9'
+          text.gsub(/[^\x00-\x7F]+/, '')
+        else
+          ActiveSupport::Inflector.transliterate(text).to_s
+        end
+      end
+
+      def add_transaction_data(xml, money, options)
+        xml.tag! 'Transaction' do
+          xml.tag! 'Type', options[:gvp_order_type]
+          xml.tag! 'Amount', amount(money)
+          xml.tag! 'CurrencyCode', currency_code(options[:currency] || currency(money))
+          xml.tag! 'CardholderPresentCode', 0
+        end
+      end
+
+      def currency_code(currency)
+        CURRENCY_CODES[currency] || CURRENCY_CODES[default_currency]
+      end
+
+      def commit(money,request)
+        raw_response = ssl_post(self.live_url, "data=" + request)
+        response = parse(raw_response)
+
+        success = success?(response)
+
+        Response.new(success,
+                     success ? 'Approved' : "Declined (Reason: #{response[:reason_code]} - #{response[:error_msg]} - #{response[:sys_err_msg]})",
+                     response,
+                     :test => test?,
+                     :authorization => response[:order_id])
+      end
+
+      def parse(body)
+        xml = REXML::Document.new(body)
+
+        response = {}
+        xml.root.elements.to_a.each do |node|
+          parse_element(response, node)
+        end
+        response
+      end
+
+      def parse_element(response, node)
+        if node.has_elements?
+          node.elements.each{|element| parse_element(response, element) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+
+      def success?(response)
+        response[:message] == "Approved"
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,183 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class GlobalTransportGateway < Gateway
+      self.test_url = 'https://certapia.globalpay.com/GlobalPay/transact.asmx/ProcessCreditCard'
+      self.live_url = 'https://api.globalpay.com/GlobalPay/transact.asmx/ProcessCreditCard'
+
+      self.supported_countries = %w(CA PR US)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      self.homepage_url = 'https://www.globalpaymentsinc.com'
+      self.display_name = 'Global Transport'
+
+      # Public: Create a new Global Transport gateway.
+      #
+      # options - A hash of options:
+      #           :global_user_name - Your Global user name
+      #           :global_password  - Your Global password
+      #           :term_type        - 3 character field assigned by Global Transport after
+      #                             - your application is certified.
+      def initialize(options={})
+        requires!(options, :global_user_name, :global_password, :term_type)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+
+        commit('Sale', post, options)
+      end
+
+      def authorize(money, payment_method, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+
+        commit('Auth', post, options)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_auth(post, authorization)
+
+        commit('Force', post, options)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_auth(post, authorization)
+
+        commit('Return', post, options)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_auth(post, authorization)
+
+        commit('Void', post, options)
+      end
+
+      def verify(payment_method, options={})
+        post = {}
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+
+        commit('CardVerify', post, options)
+      end
+
+      private
+
+      def add_address(post, options)
+        if address = (options[:billing_address] || options[:address])
+          post[:Street] = address[:address1]
+          post[:Zip] = address[:zip]
+        end
+      end
+
+      def add_auth(post, authorization)
+        post[:PNRef] = authorization
+      end
+
+      def add_invoice(post, money, options)
+        currency = (options[:currency] || currency(money))
+
+        post[:Amount] = localized_amount(money, currency)
+        post[:InvNum] = truncate(options[:order_id], 16)
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:CardNum] = payment_method.number
+        post[:ExpDate] = expdate(payment_method)
+        post[:NameOnCard] = payment_method.name
+        post[:CVNum] = payment_method.verification_value
+      end
+
+      def parse(body)
+        response = {}
+
+        Nokogiri::XML(body).root.xpath('*').each do |node|
+          response[node.name.downcase.to_sym] = node.text
+        end
+
+        response
+      end
+
+      def commit(action, parameters, options)
+        raw = parse(ssl_post(url, post_data(action, parameters, options)))
+        Response.new(
+          success_from(raw),
+          message_from(raw),
+          raw,
+          authorization: authorization_from(raw),
+          test: test?,
+          avs_result: avs_from(raw),
+          cvv_result: cvv_from(raw)
+        )
+      end
+
+      def post_data(action, params, options)
+        post = default_params
+        post[:GlobalUserName] = @options[:global_user_name]
+        post[:GlobalPassword] = @options[:global_password]
+        post[:TransType] = action
+        post[:ExtData] = "<TermType>#{@options[:term_type]}</TermType>"
+
+        post.merge(params).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def url
+        (test? ? test_url : live_url)
+      end
+
+      def success_from(response)
+        (response[:result] == "0")
+      end
+
+      def message_from(response)
+        response[:respmsg]
+      end
+
+      def authorization_from(response)
+        response[:pnref]
+      end
+
+      def avs_from(response)
+        { code: response[:getavsresult] }
+      end
+
+      def cvv_from(response)
+        response[:getcvresult]
+      end
+
+      def default_params
+        {
+          CardNum: '',
+          ExpDate: '',
+          NameOnCard: '',
+          Amount: '',
+          PNRef: '',
+          Zip: '',
+          Street: '',
+          CVNum: '',
+          MagData: '',
+          InvNum: '',
+          ExtData: ''
+        }
+      end
+
+      def truncate(value, max_size)
+        return nil unless value
+        value.to_s[0, max_size]
+      end
+    end
+  end
+end

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
+