n8_activemerchant 1.9.3

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.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? ? 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
+

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

@@ -0,0 +1,222 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class GarantiGateway < Gateway
+      URL = 'https://ccpos.garanti.com.tr/servlet/cc5ApiServer'
+
+      # 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/gvpsui/login/LoginStart.jsp'
+
+      # The name of the gateway
+      self.display_name = 'Garanti Sanal POS'
+
+      self.default_currency = 'TRL'
+
+      CURRENCY_CODES = {
+        'YTL' => 949,
+        'TRL' => 949,
+        'USD' => 840,
+        'EUR' => 978
+      }
+
+
+      def initialize(options = {})
+        requires!(options, :login, :password, :client_id)
+        @options = options
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        commit(money, build_sale_request(money, credit_card, options))
+      end
+
+      def authorize(money, credit_card, options = {})
+        commit(money, build_authorize_request(money, credit_card, options))
+      end
+
+      def capture(money, reference, options = {})
+        commit(money, build_capture_request(money,reference,options))
+      end
+
+      private
+
+      def build_xml_request(transaction_type,&block)
+        xml = Builder::XmlMarkup.new
+        xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+
+        xml.tag! 'CC5Request' do
+          xml.tag! 'Name', @options[:login]
+          xml.tag! 'Password', @options[:password]
+          xml.tag! 'ClientId', @options[:client_id]
+          xml.tag! 'Mode', if test? then 'R' else 'P' end
+          xml.tag! 'Type', transaction_type
+
+          if block_given?
+            yield xml
+          else
+            xml.target!
+          end
+        end
+      end
+
+      def build_sale_request(money, credit_card, options)
+        build_xml_request('Auth') do |xml|
+          add_customer_data(xml,options)
+          add_order_data(xml,options)
+          add_credit_card(xml, credit_card)
+          add_addresses(xml, options)
+
+          xml.tag! 'Total', amount(money)
+          xml.tag! 'Currency', currency_code(options[:currency])
+
+          xml.target!
+        end
+      end
+
+      def build_authorize_request(money, credit_card, options)
+         build_xml_request('PreAuth') do |xml|
+          add_customer_data(xml,options)
+          add_order_data(xml,options)
+          add_credit_card(xml, credit_card)
+          add_addresses(xml, options)
+
+          xml.tag! 'Total', amount(money)
+          xml.tag! 'Currency', currency_code(options[:currency])
+
+          xml.target!
+
+        end
+      end
+
+      def build_capture_request(money, reference, options = {})
+        build_xml_request('PostAuth') do |xml|
+          add_customer_data(xml,options)
+          xml.tag! 'OrderId', reference
+          xml.tag! 'Total', amount(money)
+          xml.tag! 'Currency', currency_code(options[:currency])
+
+          xml.target!
+        end
+      end
+
+      def build_void_request(reference, options = {})
+         build_xml_request('Void') do |xml|
+          add_customer_data(xml,options)
+          xml.tag! 'OrderId', reference
+          xml.tag! 'Total', amount(money)
+          xml.tag! 'Currency', currency_code(options[:currency])
+
+          xml.target!
+        end
+      end
+
+      def build_credit_request(money, reference, options = {})
+        build_xml_request('Credit') do |xml|
+          add_customer_data(xml,options)
+          xml.tag! 'OrderId', reference
+          xml.tag! 'Total', amount(money)
+          xml.tag! 'Currency', currency_code(options[:currency])
+
+          xml.target!
+        end
+      end
+
+      def add_customer_data(xml, options)
+        xml.tag! 'IPAddress', options[:ip_]
+        xml.tag! 'Email', options[:email]
+      end
+
+      def add_order_data(xml,options)
+        xml.tag! 'OrderId', options[:order_id]
+        xml.tag! 'GroupId', nil
+        xml.tag! 'TransId', nil
+      end
+
+      def add_credit_card(xml, credit_card)
+        xml.tag! 'Number', credit_card.number
+        xml.tag! 'Expires', [format_exp(credit_card.month),format_exp(credit_card.year)].join('/')
+        xml.tag! 'Cvv2Val', credit_card.verification_value
+      end
+
+      def format_exp(value)
+        format(value, :two_digits)
+      end
+
+      def add_addresses(xml,options)
+        if billing_address = options[:billing_address] || options[:address]
+          xml.tag! 'BillTo' do
+            xml.tag! 'Name', billing_address[:name]
+            xml.tag! 'Street1', billing_address[:address1]
+            xml.tag! 'Street2', billing_address[:address2]
+            xml.tag! 'City', billing_address[:city]
+            xml.tag! 'StateProv', billing_address[:state]
+            xml.tag! 'PostalCode', billing_address[:zip]
+            xml.tag! 'Country', billing_address[:country]
+            xml.tag! 'Company', billing_address[:company]
+            xml.tag! 'TelVoice', billing_address[:phone]
+          end
+        end
+
+        if shipping_address = options[:shipping_address]
+          xml.tag! 'ShipTo' do
+            xml.tag! 'Name', shipping_address[:name]
+            xml.tag! 'Street1', shipping_address[:address1]
+            xml.tag! 'Street2', shipping_address[:address2]
+            xml.tag! 'City', shipping_address[:city]
+            xml.tag! 'StateProv',shipping_address[:state]
+            xml.tag! 'PostalCode',shipping_address[:zip]
+            xml.tag! 'Country', shipping_address[:country]
+            xml.tag! 'Company', shipping_address[:company]
+            xml.tag! 'TelVoice', shipping_address[:phone]
+          end
+        end
+      end
+
+      def currency_code(currency)
+        CURRENCY_CODES[currency] || CURRENCY_CODES[default_currency]
+      end
+
+      def commit(money,request)
+        raw_response = ssl_post(URL,"DATA=" + request)
+        response = parse(raw_response)
+
+        success = success?(response)
+
+        Response.new(success,
+                     success ? 'Approved' : 'Declined',
+                     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[:response] == "Approved"
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,221 @@
+require File.join(File.dirname(__FILE__), '..', 'check.rb')
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class InspireGateway < Gateway
+      URL = 'https://secure.inspiregateway.net/api/transact.php'
+    
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.homepage_url = 'http://www.inspiregateway.com'
+      self.display_name = 'Inspire Commerce'
+      # Creates a new InspireGateway 
+      # 
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      # 
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The Inspire Username.
+      # * <tt>:password</tt> -- The Inspire Passowrd.
+      # See the Inspire Integration Guide for details. (default: +false+)
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      # Pass :store => true in the options to store the 
+      # payment info at Inspire Gateway and get a generated 
+      # customer_vault_id in the response.  
+      # Pass :store => some_number_or_string to specify the
+      # customer_vault_id InspireGateway should use (make sure it's
+      # unique).
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, creditcard,options)        
+        add_address(post, creditcard, 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
+      # InspireGateway.  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(creditcard, options = {})
+        billing_id = options.delete(:billing_id).to_s || true
+        authorize(100, creditcard, options.merge(:store => billing_id))
+      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.]/, '')
+        post[:orderdescription] = options[:description]
+      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
+    end
+  end
+end
+