bitfluent-activemerchant 1.5.1.1 → 1.15.1

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -5,11 +5,11 @@ module ActiveMerchant #:nodoc:
       CARD_COMPANIES = { 
         'visa'               => /^4\d{12}(\d{3})?$/,
         'master'             => /^(5[1-5]\d{4}|677189)\d{10}$/,
-        'discover'           => /^(6011|65\d{2})\d{12}$/,
+        'discover'           => /^(6011|65\d{2}|64[4-9]\d)\d{12}|(62\d{14})$/,
         'american_express'   => /^3[47]\d{13}$/,
         'diners_club'        => /^3(0[0-5]|[68]\d)\d{11}$/,
         'jcb'                => /^35(28|29|[3-8]\d)\d{12}$/,
-        'switch'             => /^6759\d{12}(\d{2,3})?$/,  
+        'switch'             => /^6759\d{12}(\d{2,3})?$/,
         'solo'               => /^6767\d{12}(\d{2,3})?$/,
         'dankort'            => /^5019\d{12}$/,
         'maestro'            => /^(5[06-8]|6\d)\d{10,17}$/,
@@ -122,4 +122,4 @@ module ActiveMerchant #:nodoc:
       end
     end
   end
-end
+end

data/lib/active_merchant/billing/gateway.rb

@@ -62,7 +62,9 @@ module ActiveMerchant #:nodoc:
       include Utils
       
       DEBIT_CARDS = [ :switch, :solo ]
-      
+      CURRENCIES_WITHOUT_FRACTIONS = [ 'JPY' ]
+      CREDIT_DEPRECATION_MESSAGE = "Support for using credit to refund existing transactions is deprecated and will be removed from a future release of ActiveMerchant. Please use the refund method instead."
+            
       cattr_reader :implementations
       @@implementations = []
       
@@ -74,22 +76,22 @@ module ActiveMerchant #:nodoc:
       # The format of the amounts used by the gateway
       # :dollars => '12.50'
       # :cents => '1250'
-      class_inheritable_accessor :money_format
+      class_attribute :money_format
       self.money_format = :dollars
       
       # The default currency for the transactions if no currency is provided
-      class_inheritable_accessor :default_currency
+      class_attribute :default_currency
       
       # The countries of merchants the gateway supports
-      class_inheritable_accessor :supported_countries
+      class_attribute :supported_countries
       self.supported_countries = []
       
       # The supported card types for the gateway
-      class_inheritable_accessor :supported_cardtypes
+      class_attribute :supported_cardtypes
       self.supported_cardtypes = []
       
-      class_inheritable_accessor :homepage_url
-      class_inheritable_accessor :display_name
+      class_attribute :homepage_url
+      class_attribute :display_name
       
       # The application making the calls to the gateway
       # Useful for things like the PayPal build notation (BN) id fields
@@ -133,13 +135,13 @@ module ActiveMerchant #:nodoc:
       def amount(money)
         return nil if money.nil?
         cents = if money.respond_to?(:cents)
-          warn "Support for Money objects is deprecated and will be removed from a future release of ActiveMerchant. Please use an Integer value in cents"
+          deprecated "Support for Money objects is deprecated and will be removed from a future release of ActiveMerchant. Please use an Integer value in cents"
           money.cents
         else
           money
         end
 
-        if money.is_a?(String) or cents.to_i < 0
+        if money.is_a?(String) 
           raise ArgumentError, 'money amount must be a positive Integer in cents.' 
         end
 
@@ -149,6 +151,11 @@ module ActiveMerchant #:nodoc:
           sprintf("%.2f", cents.to_f / 100)
         end
       end
+
+      def localized_amount(money, currency)
+        amount = amount(money)
+        CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s) ? amount.split('.').first : amount
+      end
       
       def currency(money)
         money.respond_to?(:currency) ? money.currency : self.default_currency

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

@@ -26,7 +26,7 @@ module ActiveMerchant #:nodoc:
     class AuthorizeNetGateway < Gateway
       API_VERSION = '3.1'
 
-      class_inheritable_accessor :test_url, :live_url, :arb_test_url, :arb_live_url
+      class_attribute :test_url, :live_url, :arb_test_url, :arb_live_url
 
       self.test_url = "https://test.authorize.net/gateway/transact.dll"
       self.live_url = "https://secure.authorize.net/gateway/transact.dll"
@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
       self.arb_test_url = 'https://apitest.authorize.net/xml/v1/request.api'
       self.arb_live_url = 'https://api.authorize.net/xml/v1/request.api'
       
-      class_inheritable_accessor :duplicate_window
+      class_attribute :duplicate_window
 
       APPROVED, DECLINED, ERROR, FRAUD_REVIEW = 1, 2, 3, 4
 
@@ -48,6 +48,7 @@ module ActiveMerchant #:nodoc:
 
       CARD_CODE_ERRORS = %w( N S )
       AVS_ERRORS = %w( A E N R W Z )
+      AVS_REASON_CODES = %w(27 45)
 
       AUTHORIZE_NET_ARB_NAMESPACE = 'AnetApi/xml/v1/schema/AnetApiSchema.xsd'
 
@@ -130,34 +131,41 @@ module ActiveMerchant #:nodoc:
       # * <tt>authorization</tt> - The authorization returned from the previous authorize request.
       def void(authorization, options = {})
         post = {:trans_id => authorization}
+        add_duplicate_window(post)
         commit('VOID', nil, post)
       end
 
-      # Credit an account.
+      # Refund a transaction.
       #
-      # This transaction is also referred to as a Refund and indicates to the gateway that
+      # 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 credit is being issued.
+      # * <tt>identification</tt> -- The ID of the original transaction against which the refund is being issued.
       # * <tt>options</tt> -- A hash of parameters.
       #
       # ==== Options
       #
-      # * <tt>:card_number</tt> -- The credit card number the credit is being issued to. (REQUIRED)
-      def credit(money, identification, options = {})
+      # * <tt>:card_number</tt> -- The credit card number the refund is being issued to. (REQUIRED)
+      def refund(money, identification, options = {})
         requires!(options, :card_number)
 
         post = { :trans_id => identification,
                  :card_num => options[:card_number]
                }
         add_invoice(post, options)
+        add_duplicate_window(post)
 
         commit('CREDIT', money, post)
       end
 
+      def credit(money, identification, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+
       # Create a recurring payment.
       #
       # This transaction creates a new Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled.
@@ -370,10 +378,12 @@ module ActiveMerchant #:nodoc:
       def message_from(results)  
         if results[:response_code] == DECLINED
           return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
-          return AVSResult.messages[ results[:avs_result_code] ] if AVS_ERRORS.include?(results[:avs_result_code])
+          if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
+            return AVSResult.messages[ results[:avs_result_code] ] 
+          end
         end
 
-        return results[:response_reason_text].nil? ? '' : results[:response_reason_text][0..-2]
+        (results[:response_reason_text] ? results[:response_reason_text].chomp('.') : '')
       end
 
       def expdate(creditcard)

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

@@ -27,7 +27,7 @@ module ActiveMerchant #:nodoc:
     # 5. Click Submit
     class AuthorizeNetCimGateway < Gateway
     
-      class_inheritable_accessor :test_url, :live_url
+      class_attribute :test_url, :live_url
 
       self.test_url = 'https://apitest.authorize.net/xml/v1/request.api'
       self.live_url = 'https://api.authorize.net/xml/v1/request.api'
@@ -54,13 +54,17 @@ module ActiveMerchant #:nodoc:
       CIM_TRANSACTION_TYPES = {
         :auth_capture => 'profileTransAuthCapture',
         :auth_only => 'profileTransAuthOnly',
-        :capture_only => 'profileTransCaptureOnly'
+        :capture_only => 'profileTransCaptureOnly',
+        :prior_auth_capture => 'profileTransPriorAuthCapture',
+        :refund => 'profileTransRefund',
+        :void => 'profileTransVoid'
       }
 
       CIM_VALIDATION_MODES = {
         :none => 'none',
         :test => 'testMode',
-        :live => 'liveMode'
+        :live => 'liveMode',
+        :old => 'oldLiveMode'
       }
       
       BANK_ACCOUNT_TYPES = {
@@ -309,14 +313,105 @@ module ActiveMerchant #:nodoc:
       #
       # ==== Transaction
       #
-      # * <tt>:type</tt> -- The type of transaction. Can be either <tt>:auth_only</tt>, <tt>:capture_only</tt>, or <tt>:auth_capture</tt>. (REQUIRED)
-      # * <tt>:amount</tt> -- The amount for the tranaction. Formatted with a decimal. For example "4.95" (REQUIRED)
-      # * <tt>:customer_profile_id</tt> -- The Customer Profile ID of the customer to use in this transaction. (REQUIRED)
-      # * <tt>:customer_payment_profile_id</tt> -- The Customer Payment Profile ID of the Customer Payment Profile to use in this transaction. (REQUIRED)
+      # * <tt>:type</tt> -- The type of transaction. Can be either <tt>:auth_only</tt>, <tt>:capture_only</tt>, <tt>:auth_capture</tt>, <tt>:prior_auth_capture</tt>, <tt>:refund</tt> or <tt>:void</tt>. (REQUIRED)
+      # * <tt>:amount</tt> -- The amount for the tranaction. Formatted with a decimal. For example "4.95" (CONDITIONAL)
+      #     - :type == :void (NOT USED)
+      #     - :type == (:refund, :auth_only, :capture_only, :auth_capture, :prior_auth_capture) (REQUIRED)
+      #
+      # * <tt>:customer_profile_id</tt> -- The Customer Profile ID of the customer to use in this transaction. (CONDITIONAL)
+      #     - :type == (:void, :prior_auth_capture) (OPTIONAL)
+      #     - :type == :refund (CONDITIONAL - required if masked information is not being submitted [see below])
+      #     - :type == (:auth_only, :capture_only, :auth_capture) (REQUIRED)
+      #
+      # * <tt>:customer_payment_profile_id</tt> -- The Customer Payment Profile ID of the Customer Payment Profile to use in this transaction. (CONDITIONAL)
+      #     - :type == (:void, :prior_auth_capture) (OPTIONAL)
+      #     - :type == :refund (CONDITIONAL - required if masked information is not being submitted [see below])
+      #     - :type == (:auth_only, :capture_only, :auth_capture) (REQUIRED)
+      #
+      # * <tt>:trans_id</tt> -- The payment gateway assigned transaction ID of the original transaction (CONDITIONAL):
+      #     - :type = (:void, :refund, :prior_auth_capture) (REQUIRED)
+      #     - :type = (:auth_only, :capture_only, :auth_capture) (NOT USED)
+      #
+      # * <tt>customer_shipping_address_id</tt> -- Payment gateway assigned ID associated with the customer shipping address (CONDITIONAL)
+      #     - :type = (:void, :refund) (OPTIONAL)
+      #     - :type = (:auth_only, :capture_only, :auth_capture) (NOT USED)
+      #     - :type = (:prior_auth_capture) (OPTIONAL)
+      #
+      # ==== For :type == :refund only
+      # * <tt>:credit_card_number_masked</tt> -- (CONDITIONAL - requied for credit card refunds is :customer_profile_id AND :customer_payment_profile_id are missing)
+      # * <tt>:bank_routing_number_masked && :bank_account_number_masked</tt> -- (CONDITIONAL - requied for electronic check refunds is :customer_profile_id AND :customer_payment_profile_id are missing) (NOT ABLE TO TEST - I keep getting "ACH transactions are not accepted by this merchant." when trying to make a payment and, until that's possible I can't refund (wiseleyb@gmail.com))
       def create_customer_profile_transaction(options)
         requires!(options, :transaction)
-        requires!(options[:transaction], :type, :amount, :customer_profile_id, :customer_payment_profile_id)
+        requires!(options[:transaction], :type)
+        case options[:transaction][:type]
+          when :void
+            requires!(options[:transaction], :trans_id)
+          when :refund
+            requires!(options[:transaction], :trans_id) &&
+              (
+                (options[:transaction][:customer_profile_id] && options[:transaction][:customer_payment_profile_id]) ||
+                options[:transaction][:credit_card_number_masked] ||
+                (options[:transaction][:bank_routing_number_masked] && options[:transaction][:bank_account_number_masked])
+              )
+          when :prior_auth_capture
+            requires!(options[:transaction], :amount, :trans_id)
+          else
+            requires!(options[:transaction], :amount, :customer_profile_id, :customer_payment_profile_id)
+        end
+        request = build_request(:create_customer_profile_transaction, options)
+        commit(:create_customer_profile_transaction, request)
+      end
 
+      # Creates a new payment transaction for refund from an existing customer profile
+      #
+      # This is what is used to refund a transaction you have stored in a Customer Profile.
+      #
+      # Returns a Response object that contains the result of the transaction in <tt>params['direct_response']</tt>
+      #
+      # ==== Options
+      #
+      # * <tt>:transaction</tt> -- A hash containing information on the transaction that is being requested. (REQUIRED)
+      #
+      # ==== Transaction
+      #
+      # * <tt>:amount</tt> -- The total amount to be refunded (REQUIRED)
+      #
+      # * <tt>:customer_profile_id</tt> -- The Customer Profile ID of the customer to use in this transaction. (CONDITIONAL :customer_payment_profile_id must be included if used)
+      # * <tt>:customer_payment_profile_id</tt> -- The Customer Payment Profile ID of the Customer Payment Profile to use in this transaction. (CONDITIONAL :customer_profile_id must be included if used)
+      #
+      # * <tt>:credit_card_number_masked</tt> -- Four Xs follwed by the last four digits of the credit card (CONDITIONAL - used if customer_profile_id and customer_payment_profile_id aren't given)
+      #
+      # * <tt>:bank_routing_number_masked</tt> -- The last four gidits of the routing number to be refunded (CONDITIONAL - must be used with :bank_account_number_masked)
+      # * <tt>:bank_account_number_masked</tt> -- The last four digis of the bank account number to be refunded, Ex. XXXX1234 (CONDITIONAL - must be used with :bank_routing_number_masked)
+      def create_customer_profile_transaction_for_refund(options)
+        requires!(options, :transaction)
+        options[:transaction][:type] = :refund
+        requires!(options[:transaction], :trans_id)
+        requires!(options[:transaction], :amount)
+        request = build_request(:create_customer_profile_transaction, options)
+        commit(:create_customer_profile_transaction, request)
+      end
+
+      # Creates a new payment transaction for void from an existing customer profile
+      #
+      # This is what is used to void a transaction you have stored in a Customer Profile.
+      #
+      # Returns a Response object that contains the result of the transaction in <tt>params['direct_response']</tt>
+      #
+      # ==== Options
+      #
+      # * <tt>:transaction</tt> -- A hash containing information on the transaction that is being requested. (REQUIRED)
+      #
+      # ==== Transaction
+      #
+      # * <tt>:trans_id</tt> -- The payment gateway assigned transaction id of the original transaction. (REQUIRED)
+      # * <tt>:customer_profile_id</tt> -- The Customer Profile ID of the customer to use in this transaction.
+      # * <tt>:customer_payment_profile_id</tt> -- The Customer Payment Profile ID of the Customer Payment Profile to use in this transaction.
+      # * <tt>:customer_shipping_address_id</tt> -- Payment gateway assigned ID associated with the customer shipping address.
+      def create_customer_profile_transaction_for_void(options)
+        requires!(options, :transaction)
+        options[:transaction][:type] = :void
+        requires!(options[:transaction], :trans_id)
         request = build_request(:create_customer_profile_transaction, options)
         commit(:create_customer_profile_transaction, request)
       end
@@ -443,6 +538,8 @@ module ActiveMerchant #:nodoc:
           add_payment_profile(xml, options[:payment_profile]) 
         end
 
+        xml.tag!('validationMode', CIM_VALIDATION_MODES[options[:validation_mode]]) if options[:validation_mode]
+		
         xml.target!
       end
 
@@ -502,10 +599,31 @@ module ActiveMerchant #:nodoc:
         xml.tag!('transaction') do
           xml.tag!(CIM_TRANSACTION_TYPES[transaction[:type]]) do
             # The amount to be billed to the customer
-            xml.tag!('amount', transaction[:amount])
-            xml.tag!('customerProfileId', transaction[:customer_profile_id])
-            xml.tag!('customerPaymentProfileId', transaction[:customer_payment_profile_id])
-            xml.tag!('approvalCode', transaction[:approval_code]) if transaction[:type] == :capture_only
+            case transaction[:type]
+              when :void
+                tag_unless_blank(xml,'customerProfileId', transaction[:customer_profile_id])
+                tag_unless_blank(xml,'customerPaymentProfileId', transaction[:customer_payment_profile_id])
+                tag_unless_blank(xml,'customerShippingAddressId', transaction[:customer_shipping_address_id])
+                xml.tag!('transId', transaction[:trans_id])
+              when :refund
+                #TODO - add support for all the other options fields
+                xml.tag!('amount', transaction[:amount])
+                tag_unless_blank(xml, 'customerProfileId', transaction[:customer_profile_id])
+                tag_unless_blank(xml, 'customerPaymentProfileId', transaction[:customer_payment_profile_id])
+                tag_unless_blank(xml, 'customerShippingAddressId', transaction[:customer_shipping_address_id])
+                tag_unless_blank(xml, 'creditCardNumberMasked', transaction[:credit_card_number_masked])
+                tag_unless_blank(xml, 'bankRoutingNumberMasked', transaction[:bank_routing_number_masked])
+                tag_unless_blank(xml, 'bankAccountNumberMasked', transaction[:bank_account_number_masked])
+                xml.tag!('transId', transaction[:trans_id])
+              when :prior_auth_capture
+                xml.tag!('amount', transaction[:amount])
+                xml.tag!('transId', transaction[:trans_id])
+              else
+                xml.tag!('amount', transaction[:amount])
+                xml.tag!('customerProfileId', transaction[:customer_profile_id])
+                xml.tag!('customerPaymentProfileId', transaction[:customer_payment_profile_id])
+                xml.tag!('approvalCode', transaction[:approval_code]) if transaction[:type] == :capture_only
+            end
             add_order(xml, transaction[:order]) if transaction[:order]
           end
         end
@@ -648,6 +766,10 @@ module ActiveMerchant #:nodoc:
         response
       end
       
+      def tag_unless_blank(xml, tag_name, data)
+        xml.tag!(tag_name, data) unless data.blank? || data.nil?
+      end
+
       def parse_direct_response(response)
         direct_response = {'raw' => response.params['direct_response']}
         direct_response_fields = response.params['direct_response'].split(',')

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

@@ -0,0 +1,309 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BarclaysEpdqGateway < Gateway
+      TEST_URL = 'https://secure2.mde.epdq.co.uk:11500'
+      LIVE_URL = 'https://secure2.epdq.co.uk:11500'
+
+      self.supported_countries = ['UK']
+      self.default_currency = 'GBP'
+      self.supported_cardtypes = [:visa, :master, :maestro, :switch ]
+      self.money_format = :cents
+      self.homepage_url = 'http://www.barclaycard.co.uk/business/accepting-payments/epdq-mpi/'
+      self.display_name = 'Barclays ePDQ'
+      
+      def initialize(options = {})
+        requires!(options, :login, :password, :client_id)
+        @options = options
+        super
+      end  
+      
+      def authorize(money, creditcard, options = {})
+        document = Document.new(self, @options) do
+          add_order_form(options[:order_id]) do
+            add_consumer(options) do
+              add_creditcard(creditcard)
+            end
+            add_transaction(:PreAuth, money)
+          end
+        end
+
+        commit(document)
+      end
+      
+      def purchase(money, creditcard, options = {})
+        # disable fraud checks if this is a repeat order:
+        if options[:payment_number] && (options[:payment_number] > 1)
+          no_fraud = true
+        else
+          no_fraud = options[:no_fraud]
+        end
+        document = Document.new(self, @options, :no_fraud => no_fraud) do
+          add_order_form(options[:order_id], options[:group_id]) do
+            add_consumer(options) do
+              add_creditcard(creditcard)
+            end
+            add_transaction(:Auth, money, options)
+          end
+        end
+        commit(document)
+      end                       
+    
+      # authorization is your unique order ID, not the authorization 
+      # code returned by ePDQ
+      def capture(money, authorization, options = {})
+        document = Document.new(self, @options) do
+          add_order_form(authorization) do
+            add_transaction(:PostAuth, money)
+          end
+        end
+
+        commit(document)
+      end
+
+      # authorization is your unique order ID, not the authorization 
+      # code returned by ePDQ
+      def credit(money, creditcard_or_authorization, options = {})
+        if creditcard_or_authorization.is_a?(String)
+          deprecated CREDIT_DEPRECATION_MESSAGE
+          refund(money, creditcard_or_authorization, options)
+        else
+          credit_new_order(money, creditcard_or_authorization, options)
+        end
+      end
+
+      def refund(money, authorization, options = {})
+        credit_existing_order(money, authorization, options)
+      end
+
+      def void(authorization, options = {})
+        document = Document.new(self, @options) do
+          add_order_form(authorization) do
+            add_transaction(:Void)
+          end
+        end
+
+        commit(document)
+      end
+
+      private                       
+      def credit_new_order(money, creditcard, options)
+        document = Document.new(self, @options) do
+          add_order_form do
+            add_consumer(options) do
+              add_creditcard(creditcard)
+            end
+            add_transaction(:Credit, money)
+          end
+        end
+
+        commit(document)
+      end
+
+      def credit_existing_order(money, authorization, options)
+        order_id, _ = authorization.split(":")
+        document = Document.new(self, @options) do
+          add_order_form(order_id) do
+            add_transaction(:Credit, money)
+          end
+        end
+        
+        commit(document)
+      end
+      
+      def parse(body)
+        parser = Parser.new(body)
+        response = parser.parse
+        Response.new(response[:success], response[:message], response,
+          :test => test?,
+          :authorization => response[:authorization],
+          :avs_result => response[:avsresponse],
+          :cvv_result => response[:cvv_result],
+          :order_id => response[:order_id],
+          :raw_response => response[:raw_response]
+        )
+      end     
+      
+      def commit(document)
+        url = (test? ? TEST_URL : LIVE_URL)
+        data = ssl_post(url, document.to_xml)
+        parse(data)
+      end
+
+      class Parser
+        def initialize(response)
+          @response = response
+        end
+
+        def parse
+          doc = REXML::Document.new(@response)
+          auth_type = find(doc, "//Transaction/Type").to_s
+
+          message = find(doc, "//Message/Text")
+          if message.blank?
+            message = find(doc, "//Transaction/CardProcResp/CcReturnMsg")
+          end
+
+          case auth_type
+          when 'Credit', 'Void'
+            success = find(doc, "//CcReturnMsg") == "Approved."
+          else
+            success = find(doc, "//Transaction/AuthCode").present?
+          end
+
+          {       
+            :success => success,
+            :message => message,
+            :authorization =>
+              [find(doc, "//OrderFormDoc/Id"), find(doc, "//Transaction/Id")].join(":"),
+            :avs_result => find(doc, "//Transaction/AvsRespCode"),
+            :cvv_result => find(doc, "//Transaction/Cvv2Resp"),
+            :order_id => find(doc, "//OrderFormDoc/Transaction/Id"),
+            :raw_response => @response
+          }
+        end
+
+        def find(doc, xpath)
+          REXML::XPath.first(doc, xpath).try(:text)
+        end
+      end
+
+      class Document
+        attr_reader :type, :xml
+
+        PAYMENT_INTERVALS = { 
+          :days => 'D',
+          :months => 'M'
+        }
+
+        EPDQ_CARD_TYPES = {
+          :visa => 1,
+          :master => 2,
+          :switch => 9,
+          :maestro => 10,
+        }
+      
+        def initialize(gateway, options = {}, document_options = {}, &block)
+          @gateway = gateway
+          @options = options
+          @document_options = document_options
+          @xml = Builder::XmlMarkup.new(:indent => 2)
+          build(&block)
+        end
+
+        def to_xml
+          @xml.target!
+        end
+
+        def build(&block)
+          xml.instruct!(:xml, :version => '1.0')
+          xml.EngineDocList do
+            xml.DocVersion "1.0"
+            xml.EngineDoc do
+              xml.ContentType "OrderFormDoc"
+              xml.User do
+                xml.Name(@options[:login])
+                xml.Password(@options[:password])
+                xml.ClientId({ :DataType => "S32" }, @options[:client_id])
+              end
+              xml.Instructions do
+                if @document_options[:no_fraud]
+                  xml.Pipeline "PaymentNoFraud" 
+                else
+                  xml.Pipeline "Payment"
+                end
+              end
+              instance_eval(&block)
+            end
+          end
+        end
+
+        def add_order_form(order_id=nil, group_id=nil, &block)
+          xml.OrderFormDoc do
+            xml.Mode 'P'
+            xml.Id(order_id) if order_id
+            xml.GroupId(group_id) if group_id
+            instance_eval(&block)
+          end
+        end
+
+        def add_consumer(options=nil, &block)
+          xml.Consumer do
+            if options
+              xml.Email(options[:email]) if options[:email]
+              billing_address = options[:billing_address] || options[:address]
+              if billing_address
+                xml.BillTo do
+                  xml.Location do
+                    xml.Address do
+                      xml.Street1 billing_address[:address1]
+                      xml.Street2 billing_address[:address2]
+                      xml.City billing_address[:city]
+                      xml.StateProv billing_address[:state]
+                      xml.PostalCode billing_address[:zip]
+                      xml.Country billing_address[:country_code]
+                    end
+                  end
+                end
+              end
+            end
+            instance_eval(&block)
+          end
+        end
+
+        def add_creditcard(creditcard)
+          xml.PaymentMech do
+            xml.CreditCard do
+              xml.Type({ :DataType => 'S32' }, EPDQ_CARD_TYPES[creditcard.brand.to_sym])
+              xml.Number creditcard.number
+              xml.Expires({ :DataType => 'ExpirationDate', :Locale => 826 }, format_expiry_date(creditcard))
+              if creditcard.verification_value.present?
+                xml.Cvv2Indicator 1
+                xml.Cvv2Val creditcard.verification_value
+              else
+                xml.Cvv2Indicator 5
+              end
+              xml.IssueNum(creditcard.issue_number) if creditcard.issue_number.present?
+            end
+          end
+        end
+
+        def add_transaction(auth_type, amount = nil, options = {})
+          @auth_type = auth_type
+          xml.Transaction do
+            xml.Type @auth_type.to_s
+            if options[:payment_number] && options[:payment_number] > 1
+              xml.CardholderPresentCode({ :DataType => 'S32' }, 8)
+            else
+              xml.CardholderPresentCode({ :DataType => 'S32' }, 7)
+            end
+            if options[:payment_number]
+              xml.PaymentNumber({ :DataType => 'S32' }, options[:payment_number])
+            end
+            if options[:total_payments]
+              xml.TotalNumberPayments({ :DataType => 'S32' }, options[:total_payments])
+            end
+            if amount
+              xml.CurrentTotals do
+                xml.Totals do
+                  xml.Total({ :DataType => 'Money', :Currency => 826 }, amount)
+                end
+              end
+            end
+          end
+        end
+
+        # date must be formatted MM/YY
+        def format_expiry_date(creditcard)
+          month_str = "%02d" % creditcard.month
+          if match = creditcard.year.to_s.match(/^\d{2}(\d{2})$/) 
+            year_str = "%02d" % match[1].to_i
+          else 
+            year_str = "%02d" % creditcard.year
+          end
+          "#{month_str}/#{year_str}"
+        end
+      end
+    end
+  end
+end
+