activemerchant 1.1.0 → 1.2.0

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

@@ -0,0 +1,197 @@
+require 'rexml/document'
+require 'digest/md5'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class QuickpayGateway < Gateway
+      URL = 'https://secure.quickpay.dk/transaction.php'
+      
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+    
+      self.default_currency = 'DKK'  
+      self.money_format = :cents
+      self.supported_cardtypes = [ :dankort, :forbrugsforeningen, :visa, :master, :american_express, :diners_club, :jcb, :maestro ]
+      self.supported_countries = ['DK']
+      self.homepage_url = 'http://quickpay.dk/'
+      self.display_name = 'Quickpay'
+      
+      TRANSACTIONS = {
+        :authorization          => '1100',
+        :capture       => '1220',
+        :void          => '1420',
+        :credit        => 'credit'
+      }
+      
+      POS_CODES = {
+        :mail               => '100020100110',
+        :phone              => '100030100110',
+        :internet           => 'L00500L00130',
+        :internet_secure    => 'K00500K00130',
+        :internet_edankort  => 'KM0500R00130',
+        :internet_recurring => 'K00540K00130' 
+      }
+      
+      MD5_CHECK_FIELDS = {
+        :authorization    => [:msgtype, :cardnumber, :amount, :expirationdate, :posc, :ordernum, :currency, :cvd, :merchant, :authtype, :reference, :transaction],
+        :capture => [:msgtype, :amount, :merchant, :transaction],
+        :void    => [:msgtype, :merchant, :transaction],
+        :credit  => [:msgtype, :amount, :merchant, :transaction]
+      }
+      
+      CURRENCIES = [ 'DKK', 'EUR', 'NOK', 'GBP', 'USD' ]
+      
+      APPROVED = '000'
+      
+      # The login is the QuickpayId
+      # The password is the md5checkword from the Quickpay admin interface
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      def authorize(money, creditcard, options = {})
+        post = {}
+        
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard)        
+        add_invoice(post, options)
+
+        commit(:authorization, post)
+      end
+      
+      def purchase(money, creditcard, options = {})
+        if result = test_result_from_cc_number(creditcard.number)
+          return result
+        end
+        
+        auth = authorize(money, creditcard, options)
+        auth.success? ? capture(money, auth.authorization) : auth
+      end                       
+    
+      def capture(money, authorization, options = {})
+        post = {}
+        
+        add_reference(post, authorization)
+        add_amount(post, money)
+        
+        commit(:capture, post)
+      end
+      
+      def void(identification, options = {})
+        post = {}
+        
+        add_reference(post, identification)
+        
+        commit(:void, post)
+      end
+      
+      def credit(money, identification, options = {})
+        post = {}
+        
+        add_amount(post, money)
+        add_reference(post, identification)
+        
+        commit(:credit, post)
+      end
+    
+      private                       
+  
+      def add_amount(post, money, options = {})
+        post[:amount]   = amount(money)
+        post[:currency] = options[:currency] || currency(money)
+      end
+      
+      def add_invoice(post, options)
+        post[:ordernum] = format_order_number(options[:order_id])
+        post[:posc]   = POS_CODES[:internet_secure]
+      end
+      
+      def add_creditcard(post, credit_card)
+        post[:cardnumber]     = credit_card.number   
+        post[:cvd]            = credit_card.verification_value
+        post[:expirationdate] = expdate(credit_card) 
+      end
+      
+      def add_reference(post, identification)
+        post[:transaction] = identification
+      end
+      
+      def commit(action, params)
+        
+        if result = test_result_from_cc_number(params[:cardnumber])
+          return result
+        end
+        
+        data = ssl_post URL, post_data(action, params)
+
+        @response = parse(data)
+        
+        success = @response[:qpstat] == APPROVED
+        message = message_from(@response)
+        
+        Response.new(success, message, @response, 
+            :test => test?, 
+            :authorization => @response[:transaction]
+        )
+      end
+
+      def parse(data)
+        response = {}
+        
+        doc = REXML::Document.new(data)
+        
+        doc.root.attributes.each do |name, value|
+          response[name.to_sym] = value
+        end
+        
+        response
+      end
+
+      def message_from(response)
+        case response[:qpstat]
+        when '008'
+          response[:qpstatmsg].to_s.scan(/[A-Z][a-z0-9 \/]+/).to_sentence
+        else
+          response[:qpstatmsg].to_s
+        end
+      end
+      
+      def post_data(action, params = {})
+        params[:merchant]   = @options[:login]
+        params[:msgtype]    = TRANSACTIONS[action]
+        
+        check_field = (action == :authorization) ? :md5checkV2 : :md5check
+        params[check_field] = generate_check_hash(action, params)
+        
+        request = params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+  
+      def generate_check_hash(action, params)
+        string = MD5_CHECK_FIELDS[action].collect do |key|
+          params[key]
+        end.join('')
+        
+        # Add the md5checkword
+        string << @options[:password].to_s
+        
+        Digest::MD5.hexdigest(string)
+      end
+      
+      def expdate(credit_card)
+        year  = format(credit_card.year, :two_digits)
+        month = format(credit_card.month, :two_digits)
+
+        "#{year}#{month}"
+      end
+      
+      def format_order_number(number)
+        number.to_s.gsub(/[^0-9]/, '').rjust(4, "0")
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,212 @@
+require 'rexml/document'
+require 'digest/sha1'
+
+module ActiveMerchant
+  module Billing
+    # Realex us the leading CC gateway in Ireland
+    # see http://www.realexpayments.com
+    # Contributed by John Ward (john@ward.name)
+    # see http://thinedgeofthewedge.blogspot.com
+    # 
+    # Realex works using the following
+    # login - The unique id of the merchant
+    # password - The secret is used to digitally sign the request
+    # account - This is an optional third part of the authentication process
+    # and is used if the merchant wishes do distuinguish cc traffic from the different sources
+    # by using a different account. This must be created in advance
+    #
+    # the Realex team decided to make the orderid unique per request, 
+    # so if validation fails you can not correct and resend using the 
+    # same order id
+    class RealexGateway < Gateway
+      URL = 'https://epage.payandshop.com/epage-remote.cgi'
+                  
+      CARD_MAPPING = {
+        'master'            => 'MC',
+        'visa'              => 'VISA',
+        'american_express'  => 'AMEX',
+        'diners_club'       => 'DINERS',
+        'switch'            => 'SWITCH',
+        'solo'              => 'SWITCH',
+        'laser'             => 'LASER'
+      }
+      
+      self.money_format = :cents
+      self.default_currency = 'EUR'
+      self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :switch, :solo, :laser ]
+      self.supported_countries = [ 'IE', 'GB' ]
+      self.homepage_url = 'http://www.realexpayments.com/'
+      self.display_name = 'Realex'
+           
+      SUCCESS, DECLINED          = "Successful", "Declined"
+      BANK_ERROR = REALEX_ERROR  = "Gateway is in maintenance. Please try again later."
+      ERROR = CLIENT_DEACTIVATED = "Gateway Error"
+      
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+  
+      def purchase(money, credit_card, options = {})
+        requires!(options, :order_id)
+        
+        request = build_purchase_or_authorization_request(:purchase, money, credit_card, options) 
+        commit(request)
+      end     
+      
+      private           
+      def commit(request)
+        if result = test_result_from_cc_number(parse_credit_card_number(request))
+          return result
+        end
+        
+        data = ssl_post(URL, request)
+        
+        @response = parse(data)
+
+        success = @response[:result] == "00"
+        test = response[:message] =~ /\[ test system \]/
+        
+        Response.new(success, message_from(@response), @response,
+          :test => test,
+          :authorization => @response[:authcode]
+        )      
+      end
+
+      def parse(xml)
+        response = {}
+        
+        xml = REXML::Document.new(xml)          
+        xml.elements.each('//response/*') do |node|
+
+          if (node.elements.size == 0)
+            response[node.name.downcase.to_sym] = normalize(node.text)
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.downcase}_#{childnode.name.downcase}"
+              response[name.to_sym] = normalize(childnode.text)
+            end              
+          end
+
+        end unless xml.root.nil?
+
+        response
+      end
+      
+      def parse_credit_card_number(request)
+        xml = REXML::Document.new(request)
+        card_number = REXML::XPath.first(xml, '/request/card/number')
+        card_number && card_number.text
+      end
+
+      def build_purchase_or_authorization_request(action, money, credit_card, options)
+        timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+        
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.tag! 'request', 'timestamp' => timestamp, 'type' => 'auth' do
+      
+          xml.tag! 'merchantid', @options[:login] 
+          xml.tag! 'account', @options[:account]
+      
+          xml.tag! 'orderid', sanitize_order_id(options[:order_id])
+          xml.tag! 'amount', amount(money), 'currency' => options[:currency] || currency(money)
+
+          xml.tag! 'card' do
+            xml.tag! 'number', credit_card.number
+            xml.tag! 'expdate', expiry_date(credit_card)
+            xml.tag! 'type', CARD_MAPPING[credit_card.type.to_s]
+            xml.tag! 'chname', credit_card.name
+            xml.tag! 'issueno', credit_card.issue_number
+            
+            xml.tag! 'cvn' do
+              xml.tag! 'number', credit_card.verification_value
+              xml.tag! 'presind', credit_card.verification_value? ? 1 : nil
+            end
+          end
+          
+          xml.tag! 'autosettle', 'flag' => auto_settle_flag(action)
+          xml.tag! 'sha1hash', sha1from("#{timestamp}.#{@options[:login]}.#{sanitize_order_id(options[:order_id])}.#{amount(money)}.#{options[:currency] || currency(money)}.#{credit_card.number}")
+          xml.tag! 'comments' do
+            xml.tag! 'comment', options[:description], 'id' => 1 
+            xml.tag! 'comment', 'id' => 2
+          end
+          
+          billing_address = options[:billing_address] || options[:address] || {}
+          shipping_address = options[:shipping_address] || billing_address
+          
+          xml.tag! 'tssinfo' do
+            xml.tag! 'address', 'type' => 'billing' do
+              xml.tag! 'code', billing_address[:zip]
+              xml.tag! 'country', billing_address[:country]
+            end
+
+            xml.tag! 'address', 'type' => 'shipping' do
+              xml.tag! 'code', shipping_address[:zip]
+              xml.tag! 'country', shipping_address[:country]
+            end
+            
+            xml.tag! 'custnum', options[:customer]
+            
+            xml.tag! 'prodid', options[:invoice]
+            xml.tag! 'varref'
+          end
+        end
+
+        xml.target!
+      end
+      
+      def auto_settle_flag(action)
+        action == :authorization ? '0' : '1'
+      end
+      
+      def expiry_date(credit_card)
+        "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
+      end
+      
+      def sha1from(string)
+        Digest::SHA1.hexdigest("#{Digest::SHA1.hexdigest(string)}.#{@options[:password]}")
+      end
+      
+      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 message_from(response)
+        message = nil
+        case response[:result]                
+        when "00"
+          message = SUCCESS
+        when "101"
+          message = response[:message]
+        when "102", "103"
+          message = DECLINED
+        when /^2[0-9][0-9]/
+          message = BANK_ERROR
+        when /^3[0-9][0-9]/
+          message = REALEX_ERROR
+        when /^5[0-9][0-9]/
+          message = ERROR
+        when "666"
+          message = CLIENT_DEACTIVATED
+        else
+          message = DECLINED
+        end  
+      end
+      
+      def sanitize_order_id(order_id)
+        order_id.to_s.gsub(/[^a-zA-Z0-9\-_]/, '')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/authorize_net'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SecurePayGateway < AuthorizeNetGateway
+      self.live_url = self.test_url = 'https://www.securepay.com/AuthSpayAdapter/process.aspx'
+      
+      self.homepage_url = 'http://www.securepay.com/'
+      self.display_name = 'SecurePay'
+      
+      # Limit support to purchase() for the time being
+      # JRuby chokes here
+      # undef_method :authorize, :capture, :void, :credit
+      
+      undef_method :authorize
+      undef_method :capture
+      undef_method :void
+      undef_method :credit
+      
+      def test?
+        Base.gateway_mode == :test
+      end
+      
+      private
+      def split(response)
+        response.split('%')
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,136 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class TransFirstGateway < Gateway
+      URL = 'https://webservices.primerchants.com/creditcard.asmx/CCSale'
+      
+      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.transfirst.com/'
+      self.display_name = 'TransFirst'
+      
+      UNUSED_FIELDS = %w(ECIValue UserId CAVVData TrackData POSInd EComInd MerchZIP MerchCustPNum MCC InstallmentNum InstallmentOf POSEntryMode POSConditionCode AuthCharInd CardCertData)
+
+      DECLINED = 'The transaction was declined'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+  
+      def purchase(money, credit_card, options = {})
+        post = {}
+        
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)        
+        add_address(post, options)   
+             
+        commit(post)
+      end                       
+  
+      private                       
+      def add_amount(post, money)
+        add_pair(post, :Amount, amount(money), :required => true)
+      end
+      
+      def add_address(post, options)
+        address = options[:billing_address] || options[:address]
+        
+        if address
+          add_pair(post, :Address, address[:address1])
+          add_pair(post, :ZipCode, address[:zip])
+        end
+      end
+
+      def add_invoice(post, options)
+        add_pair(post, :RefID, options[:order_id], :required => true)
+        add_pair(post, :PONumber, options[:invoice], :required => true)
+        add_pair(post, :SaleTaxAmount, amount(options[:tax] || 0))
+        add_pair(post, :PaymentDesc, options[:description], :required => true)
+        add_pair(post, :TaxIndicator, 0)
+      end
+      
+      def add_credit_card(post, credit_card)
+        add_pair(post, :CardHolderName, credit_card.name, :required => true)
+        add_pair(post, :CardNumber, credit_card.number, :required => true)
+        
+        add_pair(post, :Expiration, expdate(credit_card), :required => true)
+        add_pair(post, :CVV2, credit_card.verification_value)
+      end
+      
+      def add_unused_fields(post)
+        UNUSED_FIELDS.each do |f|
+          post[f] = ""
+        end
+      end
+      
+      def expdate(credit_card)
+        year  = format(credit_card.year, :two_digits)
+        month = format(credit_card.month, :two_digits)
+
+        "#{month}#{year}"
+      end
+      
+      def parse(data)
+        response = {}
+        
+        xml = REXML::Document.new(data)
+        root = REXML::XPath.first(xml, "//CCSaleDebitResponse")
+        
+        if root.nil?
+          response[:message] = data.to_s.strip
+        else
+          root.elements.to_a.each do |node|
+            response[node.name.underscore.to_sym] = node.text
+          end
+        end
+      
+        response
+      end
+      
+      def commit(params) 
+        if result = test_result_from_cc_number(params[:CardNumber])
+          return result
+        end
+  
+        data = ssl_post URL, post_data(params)
+        
+        @response = parse(data)  
+        success = @response[:status] == "Authorized"
+
+        Response.new(success, message_from(@response), @response, 
+          :test => test?, 
+          :authorization => @response[:trans_id]
+        )
+      end
+      
+      def message_from(response)
+        case response[:message]
+        when 'Call Voice Center'
+          DECLINED
+        else
+          response[:message]
+        end
+      end
+      
+      def post_data(params = {})
+        add_unused_fields(params)
+        params[:MerchantID] = @options[:login]
+        params[:RegKey] = @options[:password]
+        
+        request = params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+      
+      def add_pair(post, key, value, options = {})
+        post[key] = value if !value.blank? || options[:required]
+      end
+    end
+  end
+end
+