start_activemerchant 1.50.0

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

@@ -0,0 +1,206 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DibsGateway < Gateway
+      self.display_name = "DIBS"
+      self.homepage_url = "http://www.dibspayment.com/"
+
+      self.live_url = "https://api.dibspayment.com/merchant/v1/JSON/Transaction/"
+
+      self.supported_countries = ["US", "FI", "NO", "SE", "GB"]
+      self.default_currency = "USD"
+      self.money_format = :cents
+      self.ssl_version = :TLSv1
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :merchant_id, :secret_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run(false) do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(amount, r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_amount(post, amount)
+        add_invoice(post, amount, options)
+        if (payment_method.respond_to?(:number))
+          add_payment_method(post, payment_method, options)
+          commit(:authorize, post)
+        else
+          add_ticket_id(post, payment_method)
+          commit(:authorize_ticket, post)
+        end
+
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_amount(post, amount)
+        add_reference(post, authorization)
+
+        commit(:capture, post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+
+        commit(:void, post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_amount(post, amount)
+        add_reference(post, authorization)
+
+        commit(:refund, post)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def store(payment_method, options = {})
+        post = {}
+
+        add_invoice(post, 0, options)
+        add_payment_method(post, payment_method, options)
+
+        commit(:store, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r(("cardNumber\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvc\\?":\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
+      CURRENCY_CODES["USD"] = "840"
+      CURRENCY_CODES["DKK"] = "208"
+      CURRENCY_CODES["NOK"] = "578"
+      CURRENCY_CODES["SEK"] = "752"
+      CURRENCY_CODES["GBP"] = "826"
+      CURRENCY_CODES["EUR"] = "978"
+
+      def add_invoice(post, money, options)
+        post[:orderId] = options[:order_id] || generate_unique_id
+        post[:currency] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_ticket_id(post, payment_method)
+        post[:ticketId] = payment_method
+      end
+
+      def add_payment_method(post, payment_method, options)
+        post[:cardNumber] = payment_method.number
+        post[:cvc] = payment_method.verification_value if payment_method.verification_value
+        post[:expYear] = format(payment_method.year, :two_digits)
+        post[:expMonth] = payment_method.month
+
+        post[:startMonth] = payment_method.start_month if payment_method.start_month
+        post[:startYear] = payment_method.start_year if payment_method.start_year
+        post[:issueNumber] = payment_method.issue_number if payment_method.issue_number
+        post[:clientIp] = options[:ip] || "127.0.0.1"
+        post[:test] = true if test?
+      end
+
+
+      def add_reference(post, authorization)
+        post[:transactionId] = authorization
+      end
+
+      def add_amount(post, amount)
+        post[:amount] = amount
+      end
+
+      ACTIONS = {
+        authorize: "AuthorizeCard",
+        authorize_ticket: "AuthorizeTicket",
+        capture: "CaptureTransaction",
+        void: "CancelTransaction",
+        refund: "RefundTransaction",
+        store: "CreateTicket"
+      }
+
+      def commit(action, post)
+        post[:merchantId] = @options[:merchant_id]
+
+        data = build_request(post)
+        raw = parse(ssl_post(url(action), "request=#{data}", headers))
+        succeeded = success_from(raw)
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          authorization: authorization_from(post, raw),
+          test: test?
+        )
+      rescue JSON::ParserError
+        unparsable_response(raw)
+      end
+
+      def headers
+        {
+          "Content-Type" => "application/x-www-form-urlencoded"
+        }
+      end
+
+      def build_request(post)
+        add_hmac(post)
+        post.to_json
+      end
+
+      def add_hmac(post)
+        data = post.sort.collect { |key, value| "#{key}=#{value.to_s}" }.join("&")
+        digest = OpenSSL::Digest.new('sha256')
+        key = [@options[:secret_key]].pack('H*')
+        post[:MAC] = OpenSSL::HMAC.hexdigest(digest, key, data)
+      end
+
+      def url(action)
+        live_url + ACTIONS[action]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(raw_response)
+        raw_response["status"] == "ACCEPT"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response["status"] + ": " + response["declineReason"] || "Unable to read error message"
+        end
+      end
+
+      def authorization_from(request, response)
+        response['transactionId'] || response['ticketId'] || request[:transactionId]
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from Dibs. Please contact Dibs if you continue to receive this message."
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+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'
+
+      self.test_url = 'https://testefsnet.concordebiz.com/efsnet.dll'
+      self.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)
+        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)
+          ActiveMerchant.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, _ = 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)
+
+        {
+          :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? ? self.test_url : self.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
+
+      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,348 @@
+require 'active_merchant/billing/gateways/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 < Gateway
+      class_attribute :test_url, :live_url, :delimiter, :actions
+
+      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 = %w(US CA PR DE IE NO PL LU BE NL)
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.elavon.com/'
+
+      self.delimiter = "\n"
+      self.actions = {
+        :purchase => 'CCSALE',
+        :credit => 'CCCREDIT',
+        :refund => 'CCRETURN',
+        :authorize => 'CCAUTHONLY',
+        :capture => 'CCFORCE',
+        :void => 'CCDELETE',
+        :store => 'CCGETTOKEN',
+        :update => 'CCUPDATETOKEN',
+      }
+
+      # Initialize the Gateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- Merchant ID
+      # * <tt>:password</tt> -- PIN
+      # * <tt>:user</tt> -- Specify a subuser of the account (optional)
+      # * <tt>:test => +true+ or +false+</tt> -- Force test transactions
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      # Make a purchase
+      def purchase(money, payment_method, options = {})
+        form = {}
+        add_salestax(form, options)
+        add_invoice(form, options)
+        if payment_method.is_a?(String)
+          add_token(form, payment_method)
+        else
+          add_creditcard(form, payment_method)
+        end
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:purchase, money, form)
+      end
+
+      # 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_salestax(form, options)
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(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_salestax(form, options)
+        add_approval_code(form, authorization)
+        add_invoice(form, options)
+        add_creditcard(form, options[:credit_card])
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:capture, money, form)
+      end
+
+      # Refund a transaction.
+      #
+      # This transaction indicates to the gateway that
+      # money should flow from the merchant to the customer.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt> -- The amount to be credited to the customer as an Integer value in cents.
+      # * <tt>identification</tt> -- The ID of the original transaction against which the refund is being issued.
+      # * <tt>options</tt> -- A hash of parameters.
+      def refund(money, identification, options = {})
+        form = {}
+        add_txn_id(form, identification)
+        add_test_mode(form, options)
+        commit(:refund, money, form)
+      end
+
+      # Void a previous transaction
+      #
+      # ==== Parameters
+      #
+      # * <tt>authorization</tt> - The authorization returned from the previous request.
+      def void(identification, options = {})
+        form = {}
+        add_txn_id(form, identification)
+        add_test_mode(form, options)
+        commit(:void, nil, form)
+      end
+
+      # Make a credit to a card.  Use the refund method if you'd like to credit using
+      # previous transaction
+      #
+      # ==== Parameters
+      # * <tt>money</tt> - The amount to be credited as an Integer value in cents.
+      # * <tt>creditcard</tt> - The credit card to be credited.
+      # * <tt>options</tt>
+      def credit(money, creditcard, options = {})
+        if creditcard.is_a?(String)
+          raise ArgumentError, "Reference credits are not supported. Please supply the original credit card or use the #refund method."
+        end
+
+        form = {}
+        add_invoice(form, options)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:credit, money, form)
+      end
+
+      def verify(credit_card, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def store(creditcard, options = {})
+        form = {}
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        add_verification(form, options)
+        form[:add_token] = 'Y'
+        commit(:store, nil, form)
+      end
+
+      def update(token, creditcard, options = {})
+        form = {}
+        add_token(form, token)
+        add_creditcard(form, creditcard)
+        add_address(form, options)
+        add_customer_data(form, options)
+        add_test_mode(form, options)
+        commit(:update, nil, form)
+      end
+
+      private
+
+      def add_invoice(form,options)
+        form[:invoice_number] = (options[:order_id] || options[:invoice]).to_s.slice(0, 10)
+        form[:description] = options[:description].to_s.slice(0, 255)
+      end
+
+      def add_approval_code(form, authorization)
+        form[:approval_code] = authorization.split(';').first
+      end
+
+      def add_txn_id(form, authorization)
+        form[:txn_id] = authorization.split(';').last
+      end
+
+      def authorization_from(response)
+        [response['approval_code'], response['txn_id']].join(';')
+      end
+
+      def add_creditcard(form, creditcard)
+        form[:card_number] = creditcard.number
+        form[:exp_date] = expdate(creditcard)
+
+        if creditcard.verification_value?
+          add_verification_value(form, creditcard)
+        end
+
+        form[:first_name] = creditcard.first_name.to_s.slice(0, 20)
+        form[:last_name] = creditcard.last_name.to_s.slice(0, 30)
+      end
+
+      def add_token(form, token)
+        form[:token] = token
+      end
+
+      def add_verification_value(form, creditcard)
+        form[:cvv2cvc2] = creditcard.verification_value
+        form[:cvv2cvc2_indicator] = '1'
+      end
+
+      def add_customer_data(form, options)
+        form[:email] = options[:email].to_s.slice(0, 100) unless options[:email].blank?
+        form[:customer_code] = options[:customer].to_s.slice(0, 10) unless options[:customer].blank?
+      end
+
+      def add_salestax(form, options)
+        form[:salestax] = options[:tax] if options[:tax].present?
+      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.gsub(/[^a-zA-Z0-9]/, '').slice(0, 9)
+          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 add_verification(form, options)
+        form[:verify] = 'Y' if options[:verify]
+      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
+
+      def add_test_mode(form, options)
+        form[:test_mode] = 'TRUE' if options[:test_mode]
+      end
+
+      def message_from(response)
+        success?(response) ? response['result_message'] : response['errorMessage']
+      end
+
+      def success?(response)
+        !response.has_key?('errorMessage')
+      end
+
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money)
+        parameters[:transaction_type] = self.actions[action]
+
+        response = parse( ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)) )
+
+        Response.new(response['result'] == '0', message_from(response), response,
+          :test => @options[:test] || test?,
+          :authorization => authorization_from(response),
+          :avs_result => { :code => response['avs_response'] },
+          :cvv_result => response['cvv2_response']
+        )
+      end
+
+      def post_data(parameters)
+        result = preamble
+        result.merge!(parameters)
+        result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+      end
+
+      def preamble
+        result = {
+          'merchant_id'   => @options[:login],
+          'pin'           => @options[:password],
+          'show_form'     => 'false',
+          'result_format' => 'ASCII'
+        }
+
+        result['user_id'] = @options[:user] unless @options[:user].blank?
+        result
+      end
+
+      def parse(msg)
+        resp = {}
+        msg.split(self.delimiter).collect{|li|
+            key, value = li.split("=")
+            resp[key.to_s.strip.gsub(/^ssl_/, '')] = value.to_s.strip
+          }
+        resp
+      end
+
+    end
+  end
+end
+