tlconnor-activemerchant 1.20.4

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

@@ -0,0 +1,235 @@
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+
+    class EfsnetGateway < Gateway
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.concordefsnet.com/'
+      self.display_name = 'Efsnet'
+     
+      TEST_URL = 'https://testefsnet.concordebiz.com/efsnet.dll'
+      LIVE_URL = 'https://efsnet.concordebiz.com/efsnet.dll'
+      
+      # login is your Store ID
+      # password is your Store Key
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super      
+      end
+      
+      def test?
+        @options[:test] || super
+      end
+      
+      def authorize(money, creditcard, options = {})
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_authorize, request)
+      end
+
+      def purchase(money, creditcard, options = {})
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_charge, request)
+      end
+     
+      def capture(money, identification, options = {})
+        request = build_refund_or_settle_request(money, identification, options)
+        commit(:credit_card_settle, request)
+      end
+
+      def credit(money, identification_or_credit_card, options = {})
+        if identification_or_credit_card.is_a?(String)
+          deprecated CREDIT_DEPRECATION_MESSAGE
+          # Perform authorization reversal
+          refund(money, identification_or_credit_card, options)
+        else
+          # Perform credit
+          request = build_credit_card_request(money, identification_or_credit_card, options)
+          commit(:credit_card_credit, request)
+        end
+      end
+
+      def refund(money, reference, options = {})
+        # Perform authorization reversal
+        request = build_refund_or_settle_request(money, reference, options)
+        commit(:credit_card_refund, request)
+      end
+
+      def void(identification, options = {})
+        requires!(options, :order_id)
+        original_transaction_id, original_transaction_amount = identification.split(";")
+        commit(:void_transaction, {:reference_number => format_reference_number(options[:order_id]), :transaction_id => original_transaction_id})
+      end
+      
+      def voice_authorize(money, authorization_code, creditcard, options = {})
+        options[:authorization_number] = authorization_code
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_voice_authorize, request)
+      end
+      
+      def force(money, authorization_code, creditcard, options = {})
+        options[:authorization_number] = authorization_code
+        request = build_credit_card_request(money, creditcard, options)
+        commit(:credit_card_capture, request)
+      end
+      
+      def system_check
+        commit(:system_check, {})      
+      end
+
+      private
+
+      def build_refund_or_settle_request(money, identification, options = {})
+        original_transaction_id, original_transaction_amount = identification.split(";")
+        
+        requires!(options, :order_id)
+
+        post = {
+          :reference_number => format_reference_number(options[:order_id]),
+          :transaction_amount => amount(money),
+          :original_transaction_amount => original_transaction_amount,
+          :original_transaction_id => original_transaction_id,
+          :client_ip_address => options[:ip]
+        }
+      end
+    
+      def build_credit_card_request(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {
+          :reference_number => format_reference_number(options[:order_id]),
+          :authorization_number => options[:authorization_number],
+          :transaction_amount => amount(money),
+          :client_ip_address => options[:ip]
+          
+        }
+        add_creditcard(post,creditcard)
+        add_address(post,options)
+        post
+      end
+      
+      def format_reference_number(number)
+        number.to_s.slice(0,12)
+      end
+    
+      def add_address(post,options)
+        if address = options[:billing_address] || options[:address]
+          if address[:address2]
+            post[:billing_address]    = address[:address1].to_s << ' ' <<  address[:address2].to_s
+          else
+            post[:billing_address]    = address[:address1].to_s
+          end
+          post[:billing_city]         = address[:city].to_s
+          post[:billing_state]        = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:billing_postal_code]  = address[:zip].to_s       
+          post[:billing_country]      = address[:country].to_s
+        end
+
+        if address = options[:shipping_address]
+          if address[:address2]
+            post[:shipping_address]   = address[:address1].to_s << ' ' <<  address[:address2].to_s
+          else
+            post[:shipping_address]   = address[:address1].to_s
+          end
+          post[:shipping_city]        = address[:city].to_s
+          post[:shipping_state]       = address[:state].blank?  ? 'n/a' : address[:state]
+          post[:shipping_postal_code] = address[:zip].to_s       
+          post[:shipping_country]     = address[:country].to_s
+        end
+      end
+
+      def add_creditcard(post, creditcard)      
+        post[:billing_name]  = creditcard.name if creditcard.name
+        post[:account_number]  = creditcard.number
+        post[:card_verification_value] = creditcard.verification_value if creditcard.verification_value?
+        post[:expiration_month]  = sprintf("%.2i", creditcard.month)
+        post[:expiration_year]  = sprintf("%.4i", creditcard.year)[-2..-1]
+      end
+
+  
+      def commit(action, parameters)  
+        response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, post_data(action, parameters), 'Content-Type' => 'text/xml'))
+
+        Response.new(success?(response), message_from(response[:result_message]), response,
+          :test => test?,
+          :authorization => authorization_from(response, parameters),
+          :avs_result => { :code => response[:avs_response_code] },
+          :cvv_result => response[:cvv_response_code]
+        )
+      end
+      
+      def success?(response)
+        response[:response_code] == '0'
+      end
+      
+      def authorization_from(response, params)
+        [ response[:transaction_id], params[:transaction_amount] ].compact.join(';')
+      end
+                                               
+      def parse(xml)
+        response = {}
+
+        xml = REXML::Document.new(xml)          
+
+        xml.elements.each('//Reply//TransactionReply/*') do |node|
+
+          response[node.name.underscore.to_sym] = normalize(node.text)
+
+        end unless xml.root.nil?
+
+        response
+      end     
+
+      def post_data(action, parameters = {})
+        xml   = REXML::Document.new("<?xml version='1.0' encoding='UTF-8'?>")
+        root  = xml.add_element("Request")
+        root.attributes["StoreID"] = options[:login]
+        root.attributes["StoreKey"] = options[:password]
+        root.attributes["ApplicationID"] = 'ot 1.0'
+        transaction = root.add_element(action.to_s.camelize)
+
+        actions[action].each do |key|
+          transaction.add_element(key).text = parameters[key.underscore.to_sym] unless parameters[key.underscore.to_sym].blank?
+        end
+
+        xml.to_s
+      end
+    
+      def message_from(message)
+        return 'Unspecified error' if message.blank?
+        message.gsub(/[^\w]/, ' ').split.join(" ").capitalize
+      end
+
+      # Make a ruby type out of the response string
+      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 actions
+        ACTIONS
+      end
+
+      CREDIT_CARD_FIELDS =  %w(AuthorizationNumber ClientIpAddress BillingAddress BillingCity BillingState BillingPostalCode BillingCountry BillingName CardVerificationValue ExpirationMonth ExpirationYear ReferenceNumber TransactionAmount AccountNumber )
+
+      ACTIONS = {
+           :credit_card_authorize		=> CREDIT_CARD_FIELDS,
+           :credit_card_charge			=> CREDIT_CARD_FIELDS,
+           :credit_card_voice_authorize		=> CREDIT_CARD_FIELDS,
+           :credit_card_capture			=> CREDIT_CARD_FIELDS,
+           :credit_card_credit			=> CREDIT_CARD_FIELDS + ["OriginalTransactionAmount"],
+           :credit_card_refund			=> %w(ReferenceNumber TransactionAmount OriginalTransactionAmount OriginalTransactionID ClientIpAddress),
+           :void_transaction			=> %w(ReferenceNumber TransactionID),
+           :credit_card_settle			=> %w(ReferenceNumber TransactionAmount OriginalTransactionAmount OriginalTransactionID ClientIpAddress),
+           :system_check			=> %w(SystemCheck),
+      }    
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + '/viaklix'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # = Elavon Virtual Merchant Gateway
+    #
+    # == Example use:
+    #
+    #   gateway = ActiveMerchant::Billing::ElavonGateway.new(
+    #               :login     => "my_virtual_merchant_id",
+    #               :password  => "my_virtual_merchant_pin",
+    #               :user      => "my_virtual_merchant_user_id" # optional
+    #            )
+    #
+    #   # set up credit card obj as in main ActiveMerchant example
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
+    #     :type       => 'visa',
+    #     :number     => '41111111111111111',
+    #     :month      => 10,
+    #     :year       => 2011,
+    #     :first_name => 'Bob',
+    #     :last_name  => 'Bobsen'
+    #   )
+    #
+    #   # run request
+    #   response = gateway.purchase(1000, creditcard) # authorize and capture 10 USD
+    #
+    #   puts response.success?      # Check whether the transaction was successful
+    #   puts response.message       # Retrieve the message returned by Elavon
+    #   puts response.authorization # Retrieve the unique transaction ID returned by Elavon
+    #
+    class ElavonGateway < ViaklixGateway
+      self.test_url = 'https://demo.myvirtualmerchant.com/VirtualMerchantDemo/process.do'
+      self.live_url = 'https://www.myvirtualmerchant.com/VirtualMerchant/process.do'
+
+      self.display_name = 'Elavon MyVirtualMerchant'
+      self.supported_countries = ['US', 'CA']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.elavon.com/'
+
+      self.delimiter = "\n"
+      self.actions = {
+        :purchase => 'CCSALE',
+        :credit => 'CCCREDIT',
+        :authorize => 'CCAUTHONLY',
+        :capture => 'CCFORCE'
+      }
+      
+      # Authorize a credit card for a given amount.
+      # 
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be authorized as an Integer value in cents.
+      # * <tt>credit_card</tt> - The CreditCard details for the transaction.
+      # * <tt>options</tt>
+      #   * <tt>:billing_address</tt> - The billing address for the cardholder.      
+      def authorize(money, creditcard, options = {})
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)        
+        add_address(form, options)   
+        add_customer_data(form, options)
+        commit(:authorize, money, form)
+      end
+      
+      # Capture authorized funds from a credit card.
+      # 
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be captured as an Integer value in cents.
+      # * <tt>authorization</tt> - The approval code returned from the initial authorization.
+      # * <tt>options</tt>
+      #   * <tt>:credit_card</tt> - The CreditCard details from the initial transaction (required).
+      def capture(money, authorization, options = {})
+        requires!(options, :credit_card)
+        
+        form = {}
+        add_reference(form, authorization)
+        add_invoice(form, options)
+        add_creditcard(form, options[:credit_card])
+        add_customer_data(form, options)
+        commit(:capture, money, form)
+      end
+      
+      private
+      def add_reference(form, authorization)
+        form[:approval_code] = authorization
+      end
+      
+      def authorization_from(response)
+        response['approval_code']
+      end
+      
+      def add_verification_value(form, creditcard)
+        form[:cvv2cvc2] = creditcard.verification_value 
+        form[:cvv2cvc2_indicator] = '1'
+      end
+
+      def add_address(form,options)
+        billing_address = options[:billing_address] || options[:address] 
+        
+        if billing_address
+          form[:avs_address]    = billing_address[:address1].to_s.slice(0, 30)
+          form[:address2]       = billing_address[:address2].to_s.slice(0, 30)
+          form[:avs_zip]        = billing_address[:zip].to_s.slice(0, 10)
+          form[:city]           = billing_address[:city].to_s.slice(0, 30)
+          form[:state]          = billing_address[:state].to_s.slice(0, 10)
+          form[:company]        = billing_address[:company].to_s.slice(0, 50)
+          form[:phone]          = billing_address[:phone].to_s.slice(0, 20)
+          form[:country]        = billing_address[:country].to_s.slice(0, 50)
+        end
+                
+        if shipping_address = options[:shipping_address]
+          first_name, last_name = parse_first_and_last_name(shipping_address[:name])
+          form[:ship_to_first_name]     = first_name.to_s.slice(0, 20)
+          form[:ship_to_last_name]      = last_name.to_s.slice(0, 30)
+          form[:ship_to_address1]       = shipping_address[:address1].to_s.slice(0, 30)
+          form[:ship_to_address2]       = shipping_address[:address2].to_s.slice(0, 30)
+          form[:ship_to_city]           = shipping_address[:city].to_s.slice(0, 30)
+          form[:ship_to_state]          = shipping_address[:state].to_s.slice(0, 10)
+          form[:ship_to_company]        = shipping_address[:company].to_s.slice(0, 50)
+          form[:ship_to_country]        = shipping_address[:country].to_s.slice(0, 50)
+          form[:ship_to_zip]            = shipping_address[:zip].to_s.slice(0, 10)
+        end
+      end
+      
+      def message_from(response)
+        success?(response) ? response['result_message'] : response['errorMessage']
+      end
+      
+      def success?(response)
+        !response.has_key?('errorMessage')
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,274 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class EpayGateway < Gateway
+      API_HOST = 'ssl.ditonlinebetalingssystem.dk'
+      SOAP_URL = 'https://' + API_HOST + '/remote/payment'
+
+      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', 'SE', 'NO']
+      self.homepage_url = 'http://epay.dk/'
+      self.display_name = 'ePay'
+
+      CURRENCY_CODES = {
+        :ADP => '020', :AED => '784', :AFA => '004', :ALL => '008', :AMD => '051',
+        :ANG => '532', :AOA => '973', :ARS => '032', :AUD => '036', :AWG => '533',
+        :AZM => '031', :BAM => '977', :BBD => '052', :BDT => '050', :BGL => '100',
+        :BGN => '975', :BHD => '048', :BIF => '108', :BMD => '060', :BND => '096',
+        :BOB => '068', :BOV => '984', :BRL => '986', :BSD => '044', :BTN => '064',
+        :BWP => '072', :BYR => '974', :BZD => '084', :CAD => '124', :CDF => '976',
+        :CHF => '756', :CLF => '990', :CLP => '152', :CNY => '156', :COP => '170',
+        :CRC => '188', :CUP => '192', :CVE => '132', :CYP => '196', :CZK => '203',
+        :DJF => '262', :DKK => '208', :DOP => '214', :DZD => '012', :ECS => '218',
+        :ECV => '983', :EEK => '233', :EGP => '818', :ERN => '232', :ETB => '230',
+        :EUR => '978', :FJD => '242', :FKP => '238', :GBP => '826', :GEL => '981',
+        :GHC => '288', :GIP => '292', :GMD => '270', :GNF => '324', :GTQ => '320',
+        :GWP => '624', :GYD => '328', :HKD => '344', :HNL => '340', :HRK => '191',
+        :HTG => '332', :HUF => '348', :IDR => '360', :ILS => '376', :INR => '356',
+        :IQD => '368', :IRR => '364', :ISK => '352', :JMD => '388', :JOD => '400',
+        :JPY => '392', :KES => '404', :KGS => '417', :KHR => '116', :KMF => '174',
+        :KPW => '408', :KRW => '410', :KWD => '414', :KYD => '136', :KZT => '398',
+        :LAK => '418', :LBP => '422', :LKR => '144', :LRD => '430', :LSL => '426',
+        :LTL => '440', :LVL => '428', :LYD => '434', :MAD => '504', :MDL => '498',
+        :MGF => '450', :MKD => '807', :MMK => '104', :MNT => '496', :MOP => '446',
+        :MRO => '478', :MTL => '470', :MUR => '480', :MVR => '462', :MWK => '454',
+        :MXN => '484', :MXV => '979', :MYR => '458', :MZM => '508', :NAD => '516',
+        :NGN => '566', :NIO => '558', :NOK => '578', :NPR => '524', :NZD => '554',
+        :OMR => '512', :PAB => '590', :PEN => '604', :PGK => '598', :PHP => '608',
+        :PKR => '586', :PLN => '985', :PYG => '600', :QAR => '634', :ROL => '642',
+        :RUB => '643', :RUR => '810', :RWF => '646', :SAR => '682', :SBD => '090',
+        :SCR => '690', :SDD => '736', :SEK => '752', :SGD => '702', :SHP => '654',
+        :SIT => '705', :SKK => '703', :SLL => '694', :SOS => '706', :SRG => '740',
+        :STD => '678', :SVC => '222', :SYP => '760', :SZL => '748', :THB => '764',
+        :TJS => '972', :TMM => '795', :TND => '788', :TOP => '776', :TPE => '626',
+        :TRL => '792', :TRY => '949', :TTD => '780', :TWD => '901', :TZS => '834',
+        :UAH => '980', :UGX => '800', :USD => '840', :UYU => '858', :UZS => '860',
+        :VEB => '862', :VND => '704', :VUV => '548', :XAF => '950', :XCD => '951',
+        :XOF => '952', :XPF => '953', :YER => '886', :YUM => '891', :ZAR => '710',
+        :ZMK => '894', :ZWD => '716'
+      }
+
+      # login: merchant number
+      # password: referrer url (for authorize authentication)
+      def initialize(options = {})
+        requires!(options, :login)
+        @options = options
+        super
+      end
+
+      def authorize(money, credit_card_or_reference, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_invoice(post, options)
+        add_creditcard_or_reference(post, credit_card_or_reference)
+        add_instant_capture(post, false)
+
+        commit(:authorize, post)
+      end
+
+      def purchase(money, credit_card_or_reference, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard_or_reference(post, credit_card_or_reference)
+        add_invoice(post, options)
+        add_instant_capture(post, true)
+
+        commit(:authorize, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+
+        add_reference(post, authorization)
+        add_amount_without_currency(post, money)
+
+        commit(:capture, post)
+      end
+
+      def void(identification, options = {})
+        post = {}
+
+        add_reference(post, identification)
+
+        commit(:void, post)
+      end
+
+      def refund(money, identification, options = {})
+        post = {}
+
+        add_amount_without_currency(post, money)
+        add_reference(post, identification)
+
+        commit(:credit, post)
+      end
+
+      def credit(money, identification, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+
+      private
+
+      def add_amount(post, money, options)
+        post[:amount]   = amount(money)
+        post[:currency] = CURRENCY_CODES[(options[:currency] || currency(money)).to_sym]
+      end
+
+      def add_amount_without_currency(post, money)
+        post[:amount] = amount(money)
+      end
+
+      def add_reference(post, identification)
+        post[:transaction] = identification
+      end
+
+      def add_invoice(post, options)
+        post[:orderid] = format_order_number(options[:order_id])
+      end
+
+      def add_creditcard(post, credit_card)
+        post[:cardno]   = credit_card.number
+        post[:cvc]      = credit_card.verification_value
+        post[:expmonth] = credit_card.month
+        post[:expyear]  = credit_card.year
+      end
+
+      def add_creditcard_or_reference(post, credit_card_or_reference)
+        if credit_card_or_reference.respond_to?(:number)
+          add_creditcard(post, credit_card_or_reference)
+        else
+          add_reference(post, credit_card_or_reference.to_s)
+        end
+      end
+
+      def add_instant_capture(post, option)
+        post[:instantcapture] = option ? 1 : 0
+      end
+
+      def commit(action, params)
+        response = send("do_#{action}", params)
+
+        if action == :authorize
+          Response.new response['accept'].to_i == 1,
+                       response['errortext'],
+                       response,
+                       :test => test?,
+                       :authorization => response['tid']
+        else
+          Response.new response['result'] == 'true',
+                       messages(response['epay'], response['pbs']),
+                       response,
+                       :test => test?,
+                       :authorization => params[:transaction]
+        end
+      end
+
+      def messages(epay, pbs = nil)
+        response = "ePay: #{epay}"
+        response << " PBS: #{pbs}" if pbs
+        return response
+      end
+
+      def soap_post(method, params)
+        data = xml_builder(params, method)
+        headers = make_headers(data, method)
+        REXML::Document.new(ssl_post('https://' + API_HOST + '/remote/payment.asmx', data, headers))
+      end
+
+      def do_authorize(params)
+        headers = {}
+        headers['Referer'] = (options[:password] || "activemerchant.org")
+
+        response = raw_ssl_request(:post, 'https://' + API_HOST + '/auth/default.aspx', authorize_post_data(params), headers)
+
+        # Authorize gives the response back by redirecting with the values in
+        # the URL query
+        if location = response['Location']
+          query = CGI::parse(URI.parse(location.gsub(' ', '%20')).query)
+        else
+          return {
+            'accept' => '0',
+            'errortext' => 'No Location header returned.'
+          }
+        end
+
+        result = {}
+        query.each_pair do |k,v|
+          result[k] = v.is_a?(Array) && v.size == 1 ? v[0] : v # make values like ['v'] into 'v'
+        end
+        result
+      end
+
+      def do_capture(params)
+        response = soap_post('capture', params)
+        {
+          'result' => response.elements['//captureResponse/captureResult'].text,
+          'pbs' => response.elements['//captureResponse/pbsResponse'].text,
+          'epay' => response.elements['//captureResponse/epayresponse'].text
+        }
+      end
+
+      def do_credit(params)
+        response = soap_post('credit', params)
+        {
+          'result' => response.elements['//creditResponse/creditResult'].text,
+          'pbs' => response.elements['//creditResponse/pbsresponse'].text,
+          'epay' => response.elements['//creditResponse/epayresponse'].text
+        }
+      end
+
+      def do_void(params)
+        response = soap_post('delete', params)
+        {
+          'result' => response.elements['//deleteResponse/deleteResult'].text,
+          'epay' => response.elements['//deleteResponse/epayresponse'].text
+        }
+      end
+
+      def make_headers(data, soap_call)
+        {
+          'Content-Type' => 'text/xml; charset=utf-8',
+          'Host' => API_HOST,
+          'Content-Length' => data.size.to_s,
+          'SOAPAction' => SOAP_URL + '/' + soap_call
+        }
+      end
+
+      def xml_builder(params, soap_call)
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct!
+          xml.tag! 'soap:Envelope', { 'xmlns:xsi' => 'http://schemas.xmlsoap.org/soap/envelope/',
+                                      'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+                                      'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/' } do
+            xml.tag! 'soap:Body' do
+              xml.tag! soap_call, { 'xmlns' => SOAP_URL } do
+                xml.tag! 'merchantnumber', @options[:login]
+                xml.tag! 'transactionid', params[:transaction]
+                xml.tag! 'amount', params[:amount].to_s if soap_call != 'delete'
+              end
+            end
+          end
+        xml.target!
+      end
+
+      def authorize_post_data(params = {})
+        params[:language] = '2'
+        params[:cms] = 'activemerchant'
+        params[:accepturl] = 'https://ssl.ditonlinebetalingssystem.dk/auth/default.aspx?accept=1'
+        params[:declineurl] = 'https://ssl.ditonlinebetalingssystem.dk/auth/default.aspx?decline=1'
+        params[:merchantnumber] = @options[:login]
+
+        params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      # Limited to 20 digits max
+      def format_order_number(number)
+        number.to_s.gsub(/[^\w_]/, '').rjust(4, "0")[0...20]
+      end
+    end
+  end
+end