activemerchant 1.35.1 → 1.36.0

data/CHANGELOG

@@ -1,5 +1,16 @@
 = ActiveMerchant CHANGELOG
 
+== Version 1.36.0 (August 2, 2013)
+
+* Fat Zebra: More consistent handling of tokens [adrianmacneil]
+* Add Platron integration [alexwl]
+* Litle: Support wiredump_device [pierre]
+* Litle: support paypage registrations [pierre]
+* SecureNet: Cleanup and refactoring [duff]
+* Mercury: Proper refund and void support [opendining]
+* PaymentExpress: Return token in authorization [ntalbott]
+* Stripe: Support for partial application fee refunds [melari, odorcicd]
+
 == Version 1.35.1 (July 22, 2013)
 
 * Stripe: Allow application_fees to be refunded via the refund_application_fee flag [melari]

data/CONTRIBUTORS

@@ -408,3 +408,7 @@ Barclays ePDQ Extra Plus (June 2013)
 MerchantWare V4 (July 2013)
 
 * Aleksei Gusev (hron)
+
+Platron integration (July 2013)
+
+* Alexey Kiryushin (alexwl)

data/README.md

@@ -197,6 +197,7 @@ The [ActiveMerchant Wiki](http://github.com/Shopify/active_merchant/wikis) conta
 * [Paxum](https://www.paxum.com/)
 * [PayPal Website Payments Standard](https://www.paypal.com/cgi-bin/webscr?cmd#_wp-standard-overview-outside)
 * [Paysbuy](https://www.paysbuy.com/) - TH
+* [Platron](https://www.platron.ru/) - RU
 * [RBK Money](https://rbkmoney.ru/) - RU
 * [Robokassa](http://robokassa.ru/) - RU
 * [SagePay Form](http://www.sagepay.com/products_services/sage_pay_go/integration/form)

data/lib/active_merchant/billing/gateway.rb

@@ -161,7 +161,11 @@ module ActiveMerchant #:nodoc:
 
       def localized_amount(money, currency)
         amount = amount(money)
-        CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s) ? amount.split('.').first : amount
+        non_fractional_currency?(currency) ? amount.split('.').first : amount
+      end
+
+      def non_fractional_currency?(currency)
+        CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
       end
 
       def currency(money)

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

@@ -858,7 +858,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def format_extra_options(options)
-        options.map{ |k, v| "#{k}=#{v}" }.join(',') unless options.nil?
+        options.map{ |k, v| "#{k}=#{v}" }.join('&') unless options.nil?
       end
 
       def parse_direct_response(params)

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

@@ -13,15 +13,14 @@ module ActiveMerchant #:nodoc:
 
       self.homepage_url = 'https://www.fatzebra.com.au/'
       self.display_name = 'Fat Zebra'
-    
+
       # Setup a new instance of the gateway.
       #
       # The options hash should include :username and :token
       # You can find your username and token at https://dashboard.fatzebra.com.au
       # Under the Your Account section
       def initialize(options = {})
-        requires!(options, :username)
-        requires!(options, :token)
+        requires!(options, :username, :token)
         @username = options[:username]
         @token    = options[:token]
         super
@@ -29,11 +28,11 @@ module ActiveMerchant #:nodoc:
 
       # To create a purchase on a credit card use:
       #
-      #   purchase(money, creditcard , { ... })
+      #   purchase(money, creditcard)
       #
       # To charge a tokenized card
       #
-      #   purchase(money, {:token => "abzy87u", :cvv => "123"}, { ... }})
+      #   purchase(money, "abzy87u", :cvv => "123")
       def purchase(money, creditcard, options = {})
         post = {}
 
@@ -61,6 +60,8 @@ module ActiveMerchant #:nodoc:
       end
 
       # Tokenize a credit card
+      #
+      # The token is returned in the Response#authorization
       def store(creditcard)
         post = {}
         add_creditcard(post, creditcard)
@@ -69,6 +70,7 @@ module ActiveMerchant #:nodoc:
       end
 
       private
+
       # Add the money details to the request
       def add_amount(post, money, options)
         post[:amount] = money
@@ -81,42 +83,61 @@ module ActiveMerchant #:nodoc:
           post[:card_expiry] = "#{creditcard.month}/#{creditcard.year}"
           post[:cvv] = creditcard.verification_value if creditcard.verification_value?
           post[:card_holder] = creditcard.name if creditcard.name
+        elsif creditcard.is_a?(String)
+          post[:card_token] = creditcard
+          post[:cvv] = options[:cvv]
+        elsif creditcard.is_a?(Hash)
+          deprecated "Passing the credit card as a Hash is deprecated. Use a String and put the (optional) CVV in the options hash instead."
+          post[:card_token] = creditcard[:token]
+          post[:cvv] = creditcard[:cvv]
         else
-            post[:card_token] = creditcard[:token]
-            post[:cvv] = creditcard[:cvv]
+          raise ArgumentError.new("Unknown credit card format #{creditcard.inspect}")
         end
       end
 
       # Post the data to the gateway
       def commit(method, uri, parameters=nil)
-        raw_response = response = nil
-        success = false
-        begin
-          raw_response = ssl_request(method, get_url(uri), parameters.to_json, headers)
-          response = parse(raw_response)
-          success = response["successful"] && (response["response"]["successful"] || response["response"]["token"])
+        response = begin
+          parse(ssl_request(method, get_url(uri), parameters.to_json, headers))
         rescue ResponseError => e
-          if e.response.code == "401"
-            return Response.new(false, "Invalid Login")
-          end
-
-          raw_response = e.response.body
-          response = parse(raw_response)
-        rescue JSON::ParserError
-          response = json_error(raw_response)
+          return Response.new(false, "Invalid Login") if(e.response.code == "401")
+          parse(e.response.body)
         end
 
-        message = response["response"]["message"]
-        unless response["successful"]
-          # There is an error, so we will show that instead
-          message = response["errors"].empty? ? "Unknown Error" : response["errors"].join(", ")
+        success = success_from(response)
+        Response.new(
+          success,
+          message_from(response),
+          response,
+          :test => response["test"],
+          :authorization => authorization_from(response, success)
+        )
+      end
+
+      def success_from(response)
+        (
+          response["successful"] &&
+          response["response"] &&
+          (response["response"]["successful"] || response["response"]["token"])
+        )
+      end
+
+      def authorization_from(response, success)
+        if success
+          (response["response"]["id"] || response["response"]["token"])
+        else
+          nil
         end
+      end
 
-        Response.new(success,
-          message,
-          response,
-          :test => response.has_key?("test") ? response["test"] : false,
-          :authorization => response["response"]["id"] || response["response"]["token"])
+      def message_from(response)
+        if !response["errors"].empty?
+          response["errors"].join(", ")
+        elsif response["response"]["message"]
+          response["response"]["message"]
+        else
+          "Unknown Error"
+        end
       end
 
       # Parse the returned JSON, if parse errors are raised then return a detailed error.
@@ -146,7 +167,7 @@ module ActiveMerchant #:nodoc:
           "Authorization" => "Basic " + Base64.strict_encode64(@username.to_s + ":" + @token.to_s).strip,
           "User-Agent" => "Fat Zebra v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
         }
-      end 
+      end
     end
   end
 end

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

@@ -57,7 +57,15 @@ module ActiveMerchant #:nodoc:
         begin
           require 'LitleOnline'
         rescue LoadError
-          raise "Could not load the LitleOnline gem (>= 08.13.2).  Use `gem install LitleOnline` to install it."
+          raise "Could not load the LitleOnline gem (> 08.15.0).  Use `gem install LitleOnline` to install it."
+        end
+
+        if wiredump_device
+          LitleOnline::Configuration.logger = ((Logger === wiredump_device) ? wiredump_device : Logger.new(wiredump_device))
+          LitleOnline::Configuration.logger.level = Logger::DEBUG
+        else
+          LitleOnline::Configuration.logger = Logger.new(STDOUT)
+          LitleOnline::Configuration.logger.level = Logger::WARN
         end
 
         @litle = LitleOnline::LitleOnlineRequest.new
@@ -109,8 +117,8 @@ module ActiveMerchant #:nodoc:
         build_response(:credit, @litle.credit(to_pass))
       end
 
-      def store(creditcard, options = {})
-        to_pass = create_token_hash(creditcard, options)
+      def store(creditcard_or_paypage_registration_id, options = {})
+        to_pass = create_token_hash(creditcard_or_paypage_registration_id, options)
         build_response(:registerToken, @litle.register_token_request(to_pass), %w(000 801 802))
       end
 
@@ -286,9 +294,15 @@ module ActiveMerchant #:nodoc:
         hash
       end
 
-      def create_token_hash(creditcard, options)
+      def create_token_hash(creditcard_or_paypage_registration_id, options)
         hash                  = create_hash(0, options)
-        hash['accountNumber'] = creditcard.number
+
+        if creditcard_or_paypage_registration_id.is_a?(String)
+          hash['paypageRegistrationId'] = creditcard_or_paypage_registration_id
+        else
+          hash['accountNumber'] = creditcard_or_paypage_registration_id.number
+        end
+
         hash
       end
 

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

@@ -59,12 +59,22 @@ module ActiveMerchant #:nodoc:
       def refund(money, authorization, options = {})
         requires!(options, :credit_card) unless @use_tokenization
 
-        request = build_authorized_request('VoidSale', money, authorization, options[:credit_card], options)
-        commit(options[:void], request)
+        request = build_authorized_request('Return', money, authorization, options[:credit_card], options)
+        commit('Return', request)
       end
 
       def void(authorization, options={})
-        refund(nil, authorization, options.merge(:void => true))
+        requires!(options, :credit_card) unless @use_tokenization
+
+        if options[:try_reversal]
+          request = build_authorized_request('VoidSale', nil, authorization, options[:credit_card], options.merge(:reversal => true))
+          response = commit('VoidSale', request)
+
+          return response if response.success?
+        end
+
+        request = build_authorized_request('VoidSale', nil, authorization, options[:credit_card], options)
+        commit('VoidSale', request)
       end
 
       private
@@ -94,7 +104,7 @@ module ActiveMerchant #:nodoc:
         xml = Builder::XmlMarkup.new
 
         invoice_no, ref_no, auth_code, acq_ref_data, process_data, record_no, amount = split_authorization(authorization)
-        ref_no = invoice_no if options[:void]
+        ref_no = invoice_no if options[:reversal]
 
         xml.tag! "TStream" do
           xml.tag! "Transaction" do
@@ -111,8 +121,8 @@ module ActiveMerchant #:nodoc:
             add_address(xml, options)
             xml.tag! 'TranInfo' do
               xml.tag! "AuthCode", auth_code
-              xml.tag! "AcqRefData", acq_ref_data
-              xml.tag! "ProcessData", process_data
+              xml.tag! "AcqRefData", acq_ref_data if options[:reversal]
+              xml.tag! "ProcessData", process_data if options[:reversal]
             end
           end
         end
@@ -121,7 +131,7 @@ module ActiveMerchant #:nodoc:
 
       def add_invoice(xml, invoice_no, ref_no, options)
         if /^\d+$/ !~ invoice_no.to_s
-          raise ArgumentError.new("#{invoice_no} is not numeric as required by Mercury")
+          raise ArgumentError.new("order_id '#{invoice_no}' is not numeric as required by Mercury")
         end
 
         xml.tag! 'InvoiceNo', invoice_no

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

@@ -285,9 +285,9 @@ module ActiveMerchant #:nodoc:
         response = parse( ssl_post(self.live_url, request.to_s) )
 
         # Return a response
-        PaymentExpressResponse.new(response[:success] == APPROVED, response[:card_holder_help_text], response,
+        PaymentExpressResponse.new(response[:success] == APPROVED, message_from(response), response,
           :test => response[:test_mode] == '1',
-          :authorization => response[:dps_txn_ref]
+          :authorization => authorization_from(action, response)
         )
       end
 
@@ -312,6 +312,19 @@ module ActiveMerchant #:nodoc:
         response
       end
 
+      def message_from(response)
+        (response[:card_holder_help_text] || response[:response_text])
+      end
+
+      def authorization_from(action, response)
+        case action
+        when :validate
+          (response[:billing_id] || response[:dps_billing_id])
+        else
+          response[:dps_txn_ref]
+        end
+      end
+
       def format_date(month, year)
         "#{format(month, :two_digits)}#{format(year, :two_digits)}"
       end

data/lib/active_merchant/billing/gateways/paypal/paypal_common_api.rb

@@ -542,7 +542,7 @@ module ActiveMerchant #:nodoc:
             xml.tag! 'n2:Number', item[:number]
             xml.tag! 'n2:Quantity', item[:quantity]
             if item[:amount]
-              xml.tag! 'n2:Amount', localized_amount(item[:amount], currency_code), 'currencyID' => currency_code
+              xml.tag! 'n2:Amount', item_amount(item[:amount], currency_code), 'currencyID' => currency_code
             end
             xml.tag! 'n2:Description', item[:description]
             xml.tag! 'n2:ItemURL', item[:url]
@@ -657,6 +657,14 @@ module ActiveMerchant #:nodoc:
       def date_to_iso(date)
         (date.is_a?(Date) ? date.to_time : date).utc.iso8601
       end
+
+      def item_amount(amount, currency_code)
+        if amount.to_i < 0 && non_fractional_currency?(currency_code)
+          amount(amount).to_f.floor
+        else
+          localized_amount(amount, currency_code)
+        end
+      end
     end
   end
 end

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

@@ -5,53 +5,28 @@ module ActiveMerchant #:nodoc:
       API_VERSION = "4.0"
 
       TRANSACTIONS = {
-        :auth_only                      => "0000",  #
-        :partial_auth_only              => "0001",
-        :auth_capture                   => "0100",  #
-        :partial_auth_capture           => "0101",
+        :auth_only                      => "0000",
+        :auth_capture                   => "0100",
         :prior_auth_capture             => "0200",
-        :capture_only                   => "0300",  #
-        :void                           => "0400",  #
-        :partial_void                   => "0401",
-        :credit                         => "0500",  #
-        :credit_authonly                => "0501",
-        :credit_priorauthcapture        => "0502",
-        :force_credit                   => "0600",
-        :force_credit_authonly          => "0601",
-        :force_credit_priorauthcapture  => "0602",
-        :verification                   => "0700",
-        :auth_increment                 => "0800",
-        :issue                          => "0900",
-        :activate                       => "0901",
-        :redeem                         => "0902",
-        :redeem_partial                 => "0903",
-        :deactivate                     => "0904",
-        :reactivate                     => "0905",
-        :inquiry_balance                => "0906"
+        :void                           => "0400",
+        :credit                         => "0500"
       }
 
-      XML_ATTRIBUTES = { 'xmlns' => "http://gateway.securenet.com/API/Contracts",
-                         'xmlns:i' => "http://www.w3.org/2001/XMLSchema-instance"
+      XML_ATTRIBUTES = {
+                        'xmlns' => "http://gateway.securenet.com/API/Contracts",
+                        'xmlns:i' => "http://www.w3.org/2001/XMLSchema-instance"
                        }
       NIL_ATTRIBUTE = { 'i:nil' => "true" }
 
-#      SUCCESS = "true"
-#      SENSITIVE_FIELDS = [ :verification_str2, :expiry_date, :card_number ]
-
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
       self.homepage_url = 'http://www.securenet.com/'
       self.display_name = 'SecureNet'
-#      self.wiredump_device = STDOUT
 
-#      self.test_url = 'https://certify.securenet.com/api/Gateway.svc'
       self.test_url = 'https://certify.securenet.com/API/gateway.svc/webHttp/ProcessTransaction'
       self.live_url = 'https://gateway.securenet.com/api/Gateway.svc'
 
-      APPROVED, DECLINED, ERROR = 1, 2, 3
-
-      RESPONSE_CODE, RESPONSE_REASON_CODE, RESPONSE_REASON_TEXT = 0, 2, 3
-      AVS_RESULT_CODE, CARD_CODE_RESPONSE_CODE, TRANSACTION_ID  = 5, 6, 8
+      APPROVED, DECLINED = 1, 2
 
       CARD_CODE_ERRORS = %w( N S )
       AVS_ERRORS = %w( A E N R W Z )
@@ -62,150 +37,87 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorize(money, creditcard, options = {})
-        commit(build_sale_or_authorization_request(creditcard, options, :auth_only), money)
+        commit(build_sale_or_authorization(creditcard, options, :auth_only, money))
       end
 
       def purchase(money, creditcard, options = {})
-        commit(build_sale_or_authorization_request(creditcard, options, :auth_capture), money)
+        commit(build_sale_or_authorization(creditcard, options, :auth_capture, money))
+      end
+
+      def capture(money, authorization, options = {})
+        commit(build_capture_refund_void(authorization, options, :prior_auth_capture, money))
       end
 
-      def capture(money, creditcard, authorization, options = {})
-        commit(build_capture_request(authorization, creditcard, options, :prior_auth_capture), money)
+      def void(authorization, options = {})
+        commit(build_capture_refund_void(authorization, options, :void))
       end
 
-      def void(money, creditcard, authorization, options = {})
-        commit(build_void_request(authorization, creditcard, options, :void), money)
+      def refund(money, authorization, options = {})
+        commit(build_capture_refund_void(authorization, options, :credit, money))
       end
 
-      def credit(money, creditcard, authorization, options = {})
-        commit(build_credit_request(authorization, creditcard, options, :credit), money)
+      def credit(money, authorization, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, authorization, options)
       end
 
+
       private
-      def commit(request, money)
-        xml = build_request(request, money)
+      def commit(request)
+        xml = build_request(request)
         data = ssl_post(self.test_url, xml, "Content-Type" => "text/xml")
         response = parse(data)
 
         test_mode = test?
         Response.new(success?(response), message_from(response), response,
           :test => test_mode,
-          :authorization => response[:transactionid],
+          :authorization => build_authorization(response),
           :avs_result => { :code => response[:avs_result_code] },
           :cvv_result => response[:card_code_response_code]
         )
       end
 
-      def build_request(request, money)
+      def build_request(request)
         xml = Builder::XmlMarkup.new
 
         xml.instruct!
         xml.tag!("TRANSACTION", XML_ATTRIBUTES) do
-          xml.tag! 'AMOUNT', amount(money)
           xml << request
         end
 
         xml.target!
       end
 
-      def build_sale_or_authorization_request(creditcard, options, action)
+      def build_sale_or_authorization(creditcard, options, action, money)
         xml = Builder::XmlMarkup.new
 
+        xml.tag! 'AMOUNT', amount(money)
         add_credit_card(xml, creditcard)
-        xml.tag! 'CODE', TRANSACTIONS[action]
-        add_customer_data(xml, options)
+        add_required_params(xml, action, options)
         add_address(xml, creditcard, options)
-        xml.tag! 'DCI', 0 # No duplicate checking will be done, except for ORDERID
-        xml.tag! 'INSTALLMENT_SEQUENCENUM', 1
         add_invoice(xml, options)
-        add_merchant_key(xml, options)
-        xml.tag! 'METHOD', 'CC'
-        xml.tag! 'ORDERID', options[:order_id]#'30'.to_i.to_s#'22'# @options[:order_id]
-        xml.tag! 'OVERRIDE_FROM', 0 # Docs say not required, but doesn't work without it
-        xml.tag! 'RETAIL_LANENUM', '0' # Docs say string, but it's an integer!?
-        xml.tag! 'TEST', 'TRUE'
-        xml.tag! 'TOTAL_INSTALLMENTCOUNT', 0
-        xml.tag! 'TRANSACTION_SERVICE', 0
-
-        xml.target!
-      end
-
-      def build_capture_or_credit_request(identification, options)
-        xml = Builder::XmlMarkup.new
-
-        add_identification(xml, identification)
-        add_customer_data(xml, options)
+        add_more_required_params(xml, options)
 
         xml.target!
       end
 
-      def build_capture_request(authorization, creditcard, options, action)
+      def build_capture_refund_void(authorization, options, action, money = nil)
         xml = Builder::XmlMarkup.new
 
-        add_credit_card(xml, creditcard)
-        xml.tag! 'CODE', TRANSACTIONS[action]
-        add_customer_data(xml, options)
-        xml.tag! 'DCI', 0 # No duplicate checking will be done, except for ORDERID
-        xml.tag! 'INSTALLMENT_SEQUENCENUM', 1
-        add_merchant_key(xml, options)
-        xml.tag! 'METHOD', 'CC'
-        xml.tag! 'ORDERID', options[:order_id]#'30'.to_i.to_s#'22'# @options[:order_id]
-        xml.tag! 'OVERRIDE_FROM', 0 # Docs say not required, but doesn't work without it
-        xml.tag! 'REF_TRANSID', authorization
-        xml.tag! 'RETAIL_LANENUM', '0' # Docs say string, but it's an integer!?
-        xml.tag! 'TEST', 'TRUE'
-        xml.tag! 'TOTAL_INSTALLMENTCOUNT', 0
-        xml.tag! 'TRANSACTION_SERVICE', 0
-
-        xml.target!
-      end
-
-      def build_credit_request(authorization, creditcard, options, action)
-#        requires!(options, :card_number)
-        xml = Builder::XmlMarkup.new
-
-        add_credit_card(xml, creditcard)
-        xml.tag! 'CODE', TRANSACTIONS[action]
-        add_customer_data(xml, options)
-        xml.tag! 'DCI', 0 # No duplicate checking will be done, except for ORDERID
-        xml.tag! 'INSTALLMENT_SEQUENCENUM', 1
-        add_merchant_key(xml, options)
-        xml.tag! 'METHOD', 'CC'
-        xml.tag! 'ORDERID', options[:order_id]#'30'.to_i.to_s#'22'# @options[:order_id]
-        xml.tag! 'OVERRIDE_FROM', 0 # Docs say not required, but doesn't work without it
-        xml.tag! 'REF_TRANSID', authorization
-        xml.tag! 'RETAIL_LANENUM', '0' # Docs say string, but it's an integer!?
-        xml.tag! 'TEST', 'TRUE'
-        xml.tag! 'TOTAL_INSTALLMENTCOUNT', 0
-        xml.tag! 'TRANSACTION_SERVICE', 0
-
-        xml.target!
-      end
+        transaction_id, amount_in_ref, last_four = split_authorization(authorization)
 
-      def build_void_request(authorization, creditcard, options, action)
-        xml = Builder::XmlMarkup.new
+        xml.tag! 'AMOUNT', amount(money) || amount_in_ref
+        xml.tag!("CARD") do
+          xml.tag! 'CARDNUMBER', last_four
+        end
 
-        add_credit_card(xml, creditcard)
-        xml.tag! 'CODE', TRANSACTIONS[action]
-        add_customer_data(xml, options)
-        xml.tag! 'DCI', 0 # No duplicate checking will be done, except for ORDERID
-        xml.tag! 'INSTALLMENT_SEQUENCENUM', 1
-        add_merchant_key(xml, options)
-        xml.tag! 'METHOD', 'CC'
-        xml.tag! 'ORDERID', options[:order_id]#'30'.to_i.to_s#'22'# @options[:order_id]
-        xml.tag! 'OVERRIDE_FROM', 0 # Docs say not required, but doesn't work without it
-        xml.tag! 'REF_TRANSID', authorization
-        xml.tag! 'RETAIL_LANENUM', '0' # Docs say string, but it's an integer!?
-        xml.tag! 'TEST', 'TRUE'
-        xml.tag! 'TOTAL_INSTALLMENTCOUNT', 0
-        xml.tag! 'TRANSACTION_SERVICE', 0
+        add_required_params(xml, action, options)
+        xml.tag! 'REF_TRANSID', transaction_id
+        add_more_required_params(xml, options)
 
         xml.target!
       end
 
-      #########################################################################
-      # FUNCTIONS RELATED TO BUILDING THE XML
-      #########################################################################
       def add_credit_card(xml, creditcard)
         xml.tag!("CARD") do
           xml.tag! 'CARDCODE', creditcard.verification_value if creditcard.verification_value?
@@ -241,7 +153,6 @@ module ActiveMerchant #:nodoc:
             xml.tag! 'COUNTRY', address[:country].to_s
             if options.has_key? :email
               xml.tag! 'EMAIL', options[:email]
-#              xml.tag! 'EMAIL', 'myemail@yahoo.com'
               xml.tag! 'EMAILRECEIPT', 'FALSE'
             end
             xml.tag! 'FIRSTNAME', creditcard.first_name
@@ -283,9 +194,24 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      #########################################################################
-      # FUNCTIONS RELATED TO THE RESPONSE
-      #########################################################################
+      def add_required_params(xml, action, options)
+        xml.tag! 'CODE', TRANSACTIONS[action]
+        add_customer_data(xml, options)
+        xml.tag! 'DCI', 0 # No duplicate checking will be done, except for ORDERID
+        xml.tag! 'INSTALLMENT_SEQUENCENUM', 1
+        add_merchant_key(xml, options)
+        xml.tag! 'METHOD', 'CC'
+        xml.tag! 'ORDERID', options[:order_id]
+        xml.tag! 'OVERRIDE_FROM', 0 # Docs say not required, but doesn't work without it
+      end
+
+      def add_more_required_params(xml, options)
+        xml.tag! 'RETAIL_LANENUM', '0'
+        xml.tag! 'TEST', 'TRUE'
+        xml.tag! 'TOTAL_INSTALLMENTCOUNT', 0
+        xml.tag! 'TRANSACTION_SERVICE', 0
+      end
+
       def success?(response)
         response[:response_code].to_i == APPROVED
       end
@@ -302,9 +228,7 @@ module ActiveMerchant #:nodoc:
       def parse(xml)
         response = {}
         xml = REXML::Document.new(xml)
-        root = REXML::XPath.first(xml, "//GATEWAYRESPONSE")# ||
-#        root = REXML::XPath.first(xml, "//ProcessTransactionResponse")# ||
-#               REXML::XPath.first(xml, "//ErrorResponse")
+        root = REXML::XPath.first(xml, "//GATEWAYRESPONSE")
         if root
           root.elements.to_a.each do |node|
             recurring_parse_element(response, node)
@@ -322,6 +246,14 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def split_authorization(authorization)
+        transaction_id, amount, last_four = authorization.split("|")
+        [transaction_id, amount, last_four]
+      end
+
+      def build_authorization(response)
+        [response[:transactionid], response[:transactionamount], response[:last4_digits]].join("|")
+      end
 
     end
   end