fishman-activemerchant 1.18.0

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

@@ -0,0 +1,239 @@
+require 'digest/md5'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetaxeptGateway < Gateway
+      TEST_URL = 'https://epayment-test.bbs.no/'
+      LIVE_URL = 'https://epayment.bbs.no/'
+      
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['NO', 'DK', 'SE', 'FI']
+      
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master, :american_express]
+      
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.betalingsterminal.no/Netthandel-forside/'
+      
+      # The name of the gateway
+      self.display_name = 'BBS Netaxept'
+      
+      self.money_format = :cents
+      
+      self.default_currency = 'NOK'
+      
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end  
+      
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        add_credentials(post, options)
+        add_transaction(post, options)
+        add_order(post, money, options)
+        add_creditcard(post, creditcard)
+        commit('Sale', post)
+      end                       
+
+      def authorize(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        add_credentials(post, options)
+        add_transaction(post, options)
+        add_order(post, money, options)
+        add_creditcard(post, creditcard)
+        commit('Auth', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_credentials(post, options)
+        add_authorization(post, authorization, money)
+        commit('Capture', post, false)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_credentials(post, options)
+        add_authorization(post, authorization, money)
+        commit('Credit', post, false)
+      end
+
+      def credit(money, authorization, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, authorization, options)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_credentials(post, options)
+        add_authorization(post, authorization)
+        commit('Annul', post, false)
+      end
+
+      def test?
+        @options[:test] || Base.gateway_mode == :test
+      end
+
+    
+      private
+      
+      def add_credentials(post, options)
+        post[:merchantId] = @options[:login]
+        post[:token] = @options[:password]
+      end
+      
+      def add_authorization(post, authorization, money=nil)
+        post[:transactionId] = authorization
+        post[:transactionAmount] = amount(money) if money
+      end
+      
+      def add_transaction(post, options)
+        post[:transactionId] = generate_transaction_id(options)
+        post[:serviceType] = 'M'
+        post[:redirectUrl] = 'http://example.com'
+      end
+      
+      def add_order(post, money, options)
+        post[:orderNumber] = options[:order_id]
+        post[:amount] = amount(money)
+        post[:currencyCode] = (options[:currency] || currency(money))
+      end
+      
+      CARD_TYPE_PREFIXES = {
+        'visa' => 'v',
+        'master' => 'm',
+        'american_express' => 'a',
+      }
+      def add_creditcard(post, creditcard)
+        brand = Gateway.card_brand(creditcard)
+        prefix = CARD_TYPE_PREFIXES[brand]
+        unless prefix
+          raise ArgumentError.new("Card type #{brand} not supported.")
+        end
+
+        post[:creditcard] = {}
+        post[:creditcard][:"#{prefix}a"] = creditcard.number
+        post[:creditcard][:"#{prefix}m"] = format(creditcard.month, :two_digits)
+        post[:creditcard][:"#{prefix}y"] = format(creditcard.year, :two_digits)
+        post[:creditcard][:"#{prefix}c"] = creditcard.verification_value
+      end
+      
+      def commit(action, parameters, setup=true)
+        parameters[:action] = action
+
+        response = {:success => false}
+
+        catch(:exception) do
+          if setup
+            commit_transaction_setup(response, parameters)
+            commit_payment_details(response, parameters)
+            commit_process_setup(response, parameters)
+          end
+          commit_transaction(response, parameters)
+          response[:success] = true
+        end
+        
+        Response.new(response[:success], response[:message], response, :test => test?, :authorization => response[:authorization])
+      end
+      
+      def commit_transaction_setup(response, parameters)
+        response[:setup] = parse(ssl_get(build_url("REST/Setup.aspx", pick(parameters, :merchantId, :token, :serviceType, :amount, :currencyCode, :redirectUrl, :orderNumber, :transactionId))))
+        process(response, :setup)
+      end
+      
+      def commit_payment_details(response, parameters)
+        data = encode(parameters[:creditcard].merge(:BBSePay_transaction => response[:setup]['SetupString']))
+        response[:paymentDetails] = parse(ssl_post(build_url("terminal/default.aspx"), data), false)
+        process(response, :paymentDetails)
+      end
+      
+      def commit_process_setup(response, parameters)
+        result = ssl_get(build_url("REST/ProcessSetup.aspx", pick(parameters, :merchantId, :token, :transactionId).merge(:transactionString => response[:paymentDetails][:result])))
+        response[:processSetup] = parse(result)
+        process(response, :processSetup)
+      end
+      
+      def commit_transaction(response, parameters)
+        result = ssl_get(build_url("REST/#{parameters[:action]}.aspx", pick(parameters, :merchantId, :token, :transactionId, :transactionAmount)))
+        response[:action] = parse(result)
+        process(response, :action)
+      end
+
+      def process(response, step)
+        if response[step][:container] =~ /Exception|Error/
+          response[:message] = response[step]['Message']
+          throw :exception
+        else
+          message = (response[step]['ResponseText'] || response[step]['ResponseCode'])
+          response[:message] = (message || response[:message])
+          
+          response[:authorization] = response[step]['TransactionId']
+        end
+      end
+      
+      def parse(result, expects_xml=true)
+        if expects_xml || /^</ =~ result
+          doc = REXML::Document.new(result)
+          extract_xml(doc.root).merge(:container => doc.root.name)
+        else
+          {:result => result}
+        end
+      end
+      
+      def extract_xml(element)
+        if element.has_elements?
+          hash = {}
+          element.elements.each do |e|
+            hash[e.name] = extract_xml(e)
+          end
+          hash
+        else
+          element.text
+        end
+      end
+      
+      def url
+        (test? ? TEST_URL : LIVE_URL)
+      end
+      
+      def generate_transaction_id(options)
+        Digest::MD5.hexdigest("#{options.inspect}+#{Time.now}+#{rand}")
+      end
+      
+      def pick(hash, *keys)
+        keys.inject({}){|h,key| h[key] = hash[key] if hash[key]; h}
+      end
+      
+      def build_url(base, parameters=nil)
+        url = "#{test? ? TEST_URL : LIVE_URL}"
+        url << base
+        if parameters
+          url << '?'
+          url << encode(parameters)
+        end
+        url
+      end
+      
+      def encode(hash)
+        hash.collect{|(k,v)| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+      
+      class Response < Billing::Response
+        attr_reader :error_detail
+        def initialize(success, message, raw, options)
+          super
+          unless success
+            @error_detail = raw[:processSetup]['Result']['ResponseText'] if raw[:processSetup] && raw[:processSetup]['Result']
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,168 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetbillingGateway < Gateway
+      URL = 'https://secure.netbilling.com:1402/gw/sas/direct3.1'
+      
+      TRANSACTIONS = {
+        :authorization       => 'A',
+        :purchase            => 'S',
+        :referenced_credit   => 'R',
+        :unreferenced_credit => 'C',
+        :capture             => 'D'
+      }
+      
+      SUCCESS_CODES = [ '1', 'T' ]
+      SUCCESS_MESSAGE = 'The transaction was approved'
+      FAILURE_MESSAGE = 'The transaction failed'
+      TEST_LOGIN = '104901072025'
+
+      self.display_name = 'NETbilling'
+      self.homepage_url = 'http://www.netbilling.com'
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+      
+      def initialize(options = {})
+        requires!(options, :login)
+        @options = options
+        super
+      end  
+      
+      def authorize(money, credit_card, options = {})
+        post = {}
+        add_amount(post, money)
+        add_invoice(post, options)
+        add_credit_card(post, credit_card)        
+        add_address(post, credit_card, options)        
+        add_customer_data(post, options)
+        
+        commit(:authorization, money, post)
+      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, credit_card, options)        
+        add_customer_data(post, options)
+             
+        commit(:purchase, money, post)
+      end                       
+    
+      def capture(money, authorization, options = {})
+        post = {}
+        add_reference(post, authorization)
+        commit(:capture, money, post)
+      end
+      
+      def test?
+        @options[:login] == TEST_LOGIN || super
+      end
+     
+      private      
+      def add_amount(post, money)
+        post[:amount] = amount(money)
+      end
+      
+      def add_reference(post, reference)
+        post[:orig_id] = reference
+      end
+      
+      def add_customer_data(post, options)
+        post[:cust_email] = options[:email]
+        post[:cust_ip] = options[:ip]
+      end
+
+      def add_address(post, credit_card, options)
+        if billing_address = options[:billing_address] || options[:address]
+          post[:bill_street]     = billing_address[:address1]
+          post[:cust_phone]      = billing_address[:phone]
+          post[:bill_zip]        = billing_address[:zip]
+          post[:bill_city]       = billing_address[:city]
+          post[:bill_country]    = billing_address[:country]
+          post[:bill_state]      = billing_address[:state]
+        end
+        
+       if shipping_address = options[:shipping_address]
+         first_name, last_name = parse_first_and_last_name(shipping_address[:name])
+        
+         post[:ship_name1]      = first_name
+         post[:ship_name2]      = last_name
+         post[:ship_street]     = shipping_address[:address1]
+         post[:ship_zip]        = shipping_address[:zip]
+         post[:ship_city]       = shipping_address[:city]
+         post[:ship_country]    = shipping_address[:country]
+         post[:ship_state]      = shipping_address[:state]
+       end
+      end
+    
+      def add_invoice(post, options)
+        post[:description] = options[:description]
+      end
+      
+      def add_credit_card(post, credit_card)
+        post[:bill_name1] = credit_card.first_name
+        post[:bill_name2] = credit_card.last_name
+        post[:card_number] = credit_card.number
+        post[:card_expire] = expdate(credit_card)
+        post[:card_cvv2] = credit_card.verification_value
+      end
+      
+      def parse(body)
+        results = {}
+        body.split(/&/).each do |pair|
+          key,val = pair.split(/=/)
+          results[key.to_sym] = CGI.unescape(val)
+        end
+        results
+      end     
+      
+      def commit(action, money, parameters)
+        response = parse(ssl_post(URL, post_data(action, parameters)))
+        
+        Response.new(success?(response), message_from(response), response, 
+          :test => test_response?(response), 
+          :authorization => response[:trans_id],
+          :avs_result => { :code => response[:avs_code]},
+          :cvv_result => response[:cvv2_code]
+        )
+      end
+      
+      def test_response?(response)
+        !!(test? || response[:auth_msg] =~ /TEST/)
+      end
+      
+      def success?(response)
+        SUCCESS_CODES.include?(response[:status_code])
+      end
+
+      def message_from(response)
+        success?(response) ? SUCCESS_MESSAGE : (response[:auth_msg] || FAILURE_MESSAGE)
+      end
+      
+      def expdate(credit_card)
+        year  = sprintf("%.4i", credit_card.year)
+        month = sprintf("%.2i", credit_card.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+      
+      def post_data(action, parameters = {})
+        parameters[:account_id] = @options[:login]
+        parameters[:pay_type] = 'C'
+        parameters[:tran_type] = TRANSACTIONS[action]  
+        
+        parameters.reject{|k,v| v.blank?}.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+      
+      def parse_first_and_last_name(value)
+        name = value.to_s.split(' ')
+        
+        last_name = name.pop || ''
+        first_name = name.join(' ')
+        [ first_name, last_name ] 
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,13 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NmiGateway < AuthorizeNetGateway
+      self.test_url = 'https://secure.networkmerchants.com/gateway/transact.dll'
+      self.live_url = 'https://secure.networkmerchants.com/gateway/transact.dll'
+      self.homepage_url = 'http://nmi.com/'
+      self.display_name = 'NMI'
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+    end
+  end
+end
+

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

@@ -0,0 +1,292 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # = Ogone DirectLink Gateway
+    #
+    # DirectLink is the API version of the Ogone Payment Platform. It allows server to server
+    # communication between Ogone systems and your e-commerce website.
+    #
+    # This implementation follows the specification provided in the DirectLink integration
+    # guide version 2.4 (December 2008), available here:
+    # https://secure.ogone.com/ncol/Ogone_DirectLink_EN.pdf
+    #
+    # It also features aliases, which allow to store/unstore credit cards, as specified in
+    # the Alias Manager Option guide version 2.2 available here:
+    # https://secure.ogone.com/ncol/Ogone_Alias_EN.pdf
+    #
+    # It was last tested on Release 04.79 of Ogone e-Commerce (dated 11/02/2009).
+    #
+    # For any questions or comments, please contact Nicolas Jacobeus (nj@belighted.com).
+    #
+    # == Example use:
+    #
+    #   gateway = ActiveMerchant::Billing::OgoneGateway.new(
+    #               :login     => "my_ogone_psp_id",
+    #               :user      => "my_ogone_user_id",
+    #               :password  => "my_ogone_pswd",
+    #               :signature => "my_ogone_sha1_signature" # extra security, only if you configured your Ogone environment so
+    #            )
+    #
+    #   # set up credit card obj as in main ActiveMerchant example
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
+    #     :type       => 'visa',
+    #     :number     => '4242424242424242',
+    #     :month      => 8,
+    #     :year       => 2009,
+    #     :first_name => 'Bob',
+    #     :last_name  => 'Bobsen'
+    #   )
+    #
+    #   # run request
+    #   response = gateway.purchase(1000, creditcard, :order_id => "1") # charge 10 EUR
+    #
+    #   If you don't provide an :order_id, the gateway will generate a random one for you.
+    #
+    #   puts response.success?      # Check whether the transaction was successful
+    #   puts response.message       # Retrieve the message returned by Ogone
+    #   puts response.authorization # Retrieve the unique transaction ID returned by Ogone
+    #
+    #   To use the alias feature, simply add :alias in the options hash:
+    #
+    #   gateway.purchase(1000, creditcard, :order_id => "1", :alias => "myawesomecustomer") # associates the alias to that creditcard
+    #   gateway.purchase(2000, nil,        :order_id => "2", :alias => "myawesomecustomer") # don't need to know the creditcard for subsequent orders
+    #
+    class OgoneGateway < Gateway
+
+      URLS = {
+        :test =>       { :order => 'https://secure.ogone.com/ncol/test/orderdirect.asp',
+                         :maintenance => 'https://secure.ogone.com/ncol/test/maintenancedirect.asp' },
+        :production => { :order => 'https://secure.ogone.com/ncol/prod/orderdirect.asp',
+                         :maintenance => 'https://secure.ogone.com/ncol/prod/maintenancedirect.asp' }
+      }
+
+      CVV_MAPPING = { 'OK' => 'M',
+                      'KO' => 'N',
+                      'NO' => 'P' }
+
+      AVS_MAPPING = { 'OK' => 'M',
+                      'KO' => 'N',
+                      'NO' => 'R' }
+      SUCCESS_MESSAGE = "The transaction was successful"
+
+      self.supported_countries = ['BE', 'DE', 'FR', 'NL', 'AT', 'CH']
+      # also supports Airplus and UATP
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb, :maestro]
+      self.homepage_url = 'http://www.ogone.com/'
+      self.display_name = 'Ogone'
+      self.default_currency = 'EUR'
+      self.money_format = :cents
+
+      def initialize(options = {})
+        requires!(options, :login, :user, :password)
+        @options = options
+        super
+      end
+
+      # Verify and reserve the specified amount on the account, without actually doing the transaction.
+      def authorize(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)
+        add_money(post, money, options)
+        commit('RES', post)
+      end
+
+      # Verify and transfer the specified amount.
+      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)
+        add_money(post, money, options)
+        commit('SAL', post)
+      end
+
+      # Complete a previously authorized transaction.
+      def capture(money, authorization, options = {})
+        post = {}        
+        add_authorization(post, reference_from(authorization))
+        add_invoice(post, options)
+        add_customer_data(post, options)
+        add_money(post, money, options)
+        commit('SAL', post)
+      end
+
+      # Cancels a previously authorized transaction.
+      def void(identification, options = {})
+        post = {}
+        add_authorization(post, reference_from(identification))
+        commit('DES', post)
+      end
+
+      # Credit the specified account by a specific amount.
+      def credit(money, identification_or_credit_card, options = {})        
+        if reference_transaction?(identification_or_credit_card)
+          deprecated CREDIT_DEPRECATION_MESSAGE
+          # Referenced credit: refund of a settled transaction
+          refund(money, identification_or_credit_card, options)
+        else # must be a credit card or card reference
+          perform_non_referenced_credit(money, identification_or_credit_card, options)
+        end
+      end
+      
+      # Refund of a settled transaction
+      def refund(money, reference, options = {})        
+        perform_reference_credit(money, reference, options)
+      end
+
+      def test?
+        @options[:test] || super
+      end
+      
+      private
+      def reference_from(authorization)
+        authorization.split(";").first
+      end
+      
+      def reference_transaction?(identifier)
+        return false unless identifier.is_a?(String) 
+        reference, action = identifier.split(";")
+        !action.nil?
+      end
+      
+      def perform_reference_credit(money, payment_target, options = {})
+        post = {}
+        add_authorization(post, reference_from(payment_target))
+        add_money(post, money, options)
+        commit('RFD', post)        
+      end
+      
+      def perform_non_referenced_credit(money, payment_target, options = {})
+        # Non-referenced credit: acts like a reverse purchase
+        post = {}
+        add_invoice(post, options)
+        add_payment_source(post, payment_target, options)
+        add_address(post, payment_target, options)
+        add_customer_data(post, options)
+        add_money(post, money, options)
+        commit('RFD', post)
+      end
+      
+      def add_payment_source(post, payment_source, options)
+        if payment_source.is_a?(String)
+          add_alias(post, payment_source)
+          add_eci(post, '9')
+        else
+          add_alias(post, options[:store])
+          add_creditcard(post, payment_source)
+        end
+      end  
+      
+      def add_eci(post, eci)
+        add_pair post, 'ECI', eci
+      end
+      
+      def add_alias(post, _alias)
+        add_pair post, 'ALIAS',   _alias
+      end
+
+      def add_authorization(post, authorization)
+        add_pair post, 'PAYID',   authorization
+      end
+
+      def add_money(post, money, options)
+        add_pair post, 'currency', options[:currency] || currency(money)
+        add_pair post, 'amount',   amount(money)
+      end
+
+      def add_customer_data(post, options)
+        add_pair post, 'EMAIL',       options[:email]
+        add_pair post, 'REMOTE_ADDR', options[:ip]
+      end
+
+      def add_address(post, creditcard, options)
+        return unless options[:billing_address]
+        add_pair post, 'Owneraddress', options[:billing_address][:address1]
+        add_pair post, 'OwnerZip',     options[:billing_address][:zip]
+        add_pair post, 'ownertown',    options[:billing_address][:city]
+        add_pair post, 'ownercty',     options[:billing_address][:country]
+        add_pair post, 'ownertelno',   options[:billing_address][:phone]
+      end
+
+      def add_invoice(post, options)
+        add_pair post, 'orderID', options[:order_id] || generate_unique_id[0...30]
+        add_pair post, 'COM',     options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        add_pair post, 'CN',     creditcard.name
+        add_pair post, 'CARDNO', creditcard.number
+        add_pair post, 'ED',     "%02d%02s" % [creditcard.month, creditcard.year.to_s[-2..-1]]
+        add_pair post, 'CVC',    creditcard.verification_value
+      end
+
+      def parse(body)
+        xml = REXML::Document.new(body)
+        convert_attributes_to_hash(xml.root.attributes)
+      end
+
+      def commit(action, parameters)
+        add_pair parameters, 'PSPID',      @options[:login]
+        add_pair parameters, 'USERID',     @options[:user]
+        add_pair parameters, 'PSWD',       @options[:password]
+        url = URLS[test? ? :test : :production][parameters['PAYID'] ? :maintenance : :order ]
+        response = parse(ssl_post(url, post_data(action, parameters)))
+        options = { :authorization => [response["PAYID"], action].join(";"),
+                    :test => test?,
+                    :avs_result => { :code => AVS_MAPPING[response["AAVCheck"]] },
+                    :cvv_result => CVV_MAPPING[response["CVCCheck"]] }
+        Response.new(successful?(response), message_from(response), response, options)
+      end
+      
+      def successful?(response)
+        response["NCERROR"] == "0"
+      end
+
+      def message_from(response)
+        if successful?(response) 
+          SUCCESS_MESSAGE
+        else
+          format_error_message(response["NCERRORPLUS"])
+        end
+      end
+      
+      def format_error_message(message)
+        raw_message = message.to_s.strip
+        case raw_message
+        when /\|/
+          raw_message.split("|").join(", ").capitalize
+        when /\//
+          raw_message.split("/").first.to_s.capitalize
+        else
+          raw_message.to_s.capitalize
+        end
+      end
+
+      def post_data(action, parameters = {})
+        add_pair parameters, 'Operation' , action
+        if @options[:signature] # the user wants a SHA-1 signature
+          string = ['orderID','amount','currency','CARDNO','PSPID','Operation','ALIAS'].map{|s|parameters[s]}.join + @options[:signature]
+          add_pair parameters, 'SHASign' , Digest::SHA1.hexdigest(string)
+        end
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def add_pair(post, key, value, options = {})
+        post[key] = value if !value.blank? || options[:required]
+      end
+
+      def convert_attributes_to_hash(rexml_attributes)
+        response_hash = {}
+        rexml_attributes.each do |key, value|
+          response_hash[key] = value
+        end
+        response_hash
+      end
+    end
+  end
+end