activemerchant 1.43.3 → 1.44.0

data/lib/active_merchant/billing/cvv_result.rb

@@ -4,29 +4,29 @@ module ActiveMerchant
     # http://www.bbbonline.org/eExport/doc/MerchantGuide_cvv2.pdf
     # Check additional codes from cybersource website
     class CVVResult
-      
+
       MESSAGES = {
-        'D'  =>  'Suspicious transaction',
-        'I'  =>  'Failed data validation check',
-        'M'  =>  'Match',
-        'N'  =>  'No Match',
-        'P'  =>  'Not Processed',
-        'S'  =>  'Should have been present',
-        'U'  =>  'Issuer unable to process request',
-        'X'  =>  'Card does not support verification'
+        'D'  =>  'CVV check flagged transaction as suspicious',
+        'I'  =>  'CVV failed data validation check',
+        'M'  =>  'CVV matches',
+        'N'  =>  'CVV does not match',
+        'P'  =>  'CVV not processed',
+        'S'  =>  'CVV should have been present',
+        'U'  =>  'CVV request unable to be processed by issuer',
+        'X'  =>  'CVV check not supported for card'
       }
-      
+
       def self.messages
         MESSAGES
       end
-      
+
       attr_reader :code, :message
-      
+
       def initialize(code)
-        @code = code.upcase unless code.blank?
+        @code = (code.blank? ? nil : code.upcase)
         @message = MESSAGES[@code]
       end
-      
+
       def to_hash
         {
           'code' => code,
@@ -35,4 +35,4 @@ module ActiveMerchant
       end
     end
   end
-end
+end

data/lib/active_merchant/billing/gateway.rb

@@ -10,19 +10,16 @@ module ActiveMerchant #:nodoc:
     #
     # The standard list of gateway functions that most concrete gateway subclasses implement is:
     #
-    # * <tt>purchase(money, creditcard, options = {})</tt>
-    # * <tt>authorize(money, creditcard, options = {})</tt>
+    # * <tt>purchase(money, credit_card, options = {})</tt>
+    # * <tt>authorize(money, credit_card, options = {})</tt>
     # * <tt>capture(money, authorization, options = {})</tt>
     # * <tt>void(identification, options = {})</tt>
-    # * <tt>credit(money, identification, options = {})</tt>
-    #
-    # Some gateways include features for recurring billing
-    #
-    # * <tt>recurring(money, creditcard, options = {})</tt>
+    # * <tt>refund(money, identification, options = {})</tt>
+    # * <tt>verify(credit_card, options = {})</tt>
     #
     # Some gateways also support features for storing credit cards:
     #
-    # * <tt>store(creditcard, options = {})</tt>
+    # * <tt>store(credit_card, options = {})</tt>
     # * <tt>unstore(identification, options = {})</tt>
     #
     # === Gateway Options
@@ -57,13 +54,12 @@ module ActiveMerchant #:nodoc:
     #
     class Gateway
       include PostsData
-      include RequiresParameters
       include CreditCardFormatting
-      include Utils
 
       DEBIT_CARDS = [ :switch, :solo ]
       CURRENCIES_WITHOUT_FRACTIONS = [ 'BIF', 'BYR', 'CLP', 'CVE', 'DJF', 'GNF', 'HUF', 'ISK', 'JPY', 'KMF', 'KRW', 'PYG', 'RWF', 'TWD', 'UGX', 'VND', 'VUV', 'XAF', 'XOF', 'XPF' ]
       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."
+      RECURRING_DEPRECATION_MESSAGE = "Recurring functionality in ActiveMerchant is deprecated and will be removed in a future version. Please contact the ActiveMerchant maintainers if you have an interest in taking ownership of a separate gem that continues support for it."
 
       cattr_reader :implementations
       @@implementations = []
@@ -73,6 +69,10 @@ module ActiveMerchant #:nodoc:
         @@implementations << subclass
       end
 
+      def generate_unique_id
+        SecureRandom.hex(16)
+      end
+
       # The format of the amounts used by the gateway
       # :dollars => '12.50'
       # :cents => '1250'
@@ -146,6 +146,28 @@ module ActiveMerchant #:nodoc:
         (@options.has_key?(:test) ? @options[:test] : Base.test?)
       end
 
+      protected # :nodoc: all
+
+      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 user_agent
+        @@ua ||= JSON.dump({
+          :bindings_version => ActiveMerchant::VERSION,
+          :lang => 'ruby',
+          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          :platform => RUBY_PLATFORM,
+          :publisher => 'active_merchant'
+        })
+      end
+
       private # :nodoc: all
 
       def name
@@ -155,7 +177,7 @@ module ActiveMerchant #:nodoc:
       def amount(money)
         return nil if money.nil?
         cents = if money.respond_to?(: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"
+          ActiveMerchant.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
@@ -196,6 +218,19 @@ module ActiveMerchant #:nodoc:
         return false if card_brand(credit_card).blank?
         DEBIT_CARDS.include?(card_brand(credit_card).to_sym)
       end
+
+      def requires!(hash, *params)
+        params.each do |param|
+          if param.is_a?(Array)
+            raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first)
+
+            valid_options = param[1..-1]
+            raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:words_connector => 'or')}") unless valid_options.include?(hash[param.first])
+          else
+            raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param)
+          end
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,205 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class AdyenGateway < Gateway
+      self.test_url = 'https://pal-test.adyen.com/pal/adapter/httppost'
+      self.live_url = 'https://pal-live.adyen.com/pal/adapter/httppost'
+
+      self.supported_countries = ['AR', 'AT', 'BE', 'BR', 'CA', 'CH', 'CL', 'CN', 'CO', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GB', 'HK', 'ID', 'IE', 'IL', 'IN', 'IT', 'JP', 'KR', 'LU', 'MX', 'MY', 'NL', 'NO', 'PA', 'PE', 'PH', 'PL', 'PT', 'RU', 'SE', 'SG', 'TH', 'TR', 'TW', 'US', 'VN', 'ZA']
+      self.default_currency = 'EUR'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :dankort, :maestro]
+
+      self.homepage_url = 'https://www.adyen.com/'
+      self.display_name = 'Adyen'
+
+      def initialize(options = {})
+        requires!(options, :company, :merchant, :password)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        MultiResponse.run do |r|
+          r.process { authorize(money, creditcard, options) }
+          r.process { capture(money, r.authorization, options) }
+        end
+      end
+
+      def authorize(money, creditcard, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        post[:paymentRequest] = payment_request(money, options)
+        post[:paymentRequest][:amount] = amount_hash(money, options[:currency])
+        post[:paymentRequest][:card] = credit_card_hash(creditcard)
+
+        if address = (options[:billing_address] || options[:address])
+          post[:paymentRequest][:billingAddress] = address_hash(address)
+        end
+
+        if options[:shipping_address]
+          post[:paymentRequest][:deliveryAddress] = address_hash(options[:shipping_address])
+        end
+
+        commit('Payment.authorise', post)
+      end
+
+      def capture(money, authorization, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        post[:modificationRequest] = modification_request(authorization, options)
+        post[:modificationRequest][:modificationAmount] = amount_hash(money, options[:currency])
+        
+        commit('Payment.capture', post)
+      end
+
+      def refund(money, authorization, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        post[:modificationRequest] = modification_request(authorization, options)
+        post[:modificationRequest][:modificationAmount] = amount_hash(money, options[:currency])
+        
+        commit('Payment.refund', post)
+      end
+
+      def void(identification, options = {})
+        requires!(options, :order_id)
+
+        post = {}
+        post[:modificationRequest] = modification_request(identification, options)
+
+        commit('Payment.cancel', post)
+      end
+
+      private
+
+      def commit(action, post)
+        request = post_data(flatten_hash(post.merge(:action => action)))
+        raw_response = ssl_post(url, request, headers)
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          test: test?,
+          authorization: response['pspReference']
+        )
+
+      rescue ResponseError => e
+        case e.response.code
+        when '401'
+          return Response.new(false, 'Invalid credentials', {}, :test => test?)
+        when '500'
+          if e.response.body.split(' ')[0] == 'validation'
+            return Response.new(false, e.response.body.split(' ', 3)[2], {}, :test => test?)
+          end
+        end
+        raise
+      end
+
+      def flatten_hash(hash, prefix = nil)
+        flat_hash = {}
+        hash.each_pair do |key, val|
+          conc_key = prefix.nil? ? key : "#{prefix}.#{key}"
+          if val.is_a?(Hash)
+            flat_hash.merge!(flatten_hash(val, conc_key))
+          else
+            flat_hash[conc_key] = val
+          end
+        end
+        flat_hash
+      end
+
+      def headers
+        {
+          'Authorization' => 'Basic ' + Base64.encode64("ws@Company.#{@options[:company]}:#{@options[:password]}").strip
+        }
+      end
+
+      def parse(response)
+        Hash[
+          response.split('&').map do |x|
+            key, val = x.split('=', 2)
+            [key.split('.').last, CGI.unescape(val)]
+          end
+        ]
+      end
+
+      def post_data(data)
+        data.map do |key, val|
+          "#{key}=#{CGI.escape(val.to_s)}"
+        end.reduce do |x, y|
+          "#{x}&#{y}"
+        end
+      end
+
+      def message_from(response)
+        return response['resultCode'] if response.has_key?('resultCode') # Payment request
+        return response['response'] if response['response'] # Modification request
+        "Failure" # Negative fallback in case of error
+      end
+
+      def success_from(response)
+        return true if response.has_key?('authCode')
+
+        successful_responses = %w([capture-received] [cancel-received] [refund-received])
+        successful_responses.include?(response['response'])
+      end
+
+      def url
+        test? ? self.test_url : self.live_url
+      end
+
+      def address_hash(address)
+        full_address = "#{address[:address1]} #{address[:address2]}"
+
+        {
+          :city              => address[:city],
+          :street            => full_address.split(/\s+/).keep_if { |x| x !~ /\d/ }.join(' '),
+          :houseNumberOrName => full_address.split(/\s+/).keep_if { |x| x =~ /\d/ }.join(' '),
+          :postalCode        => address[:zip],
+          :stateOrProvince   => address[:state],
+          :country           => address[:country]
+        }
+      end
+
+      def amount_hash(money, currency)
+        {
+          :currency => (currency || currency(money)),
+          :value    => amount(money)
+        }
+      end
+
+      def credit_card_hash(creditcard)
+        {
+          :cvc         => creditcard.verification_value,
+          :expiryMonth => format(creditcard.month, :two_digits),
+          :expiryYear  => format(creditcard.year, :four_digits),
+          :holderName  => creditcard.name,
+          :number      => creditcard.number
+        }
+      end
+
+      def modification_request(reference, options)
+        {
+          :merchantAccount    => @options[:merchant],
+          :originalReference  => reference
+        }.keep_if { |_, v| v }
+      end
+
+      def payment_request(money, options)
+        {
+          :merchantAccount  => @options[:merchant],
+          :reference        => options[:order_id],
+          :shopperEmail     => options[:email],
+          :shopperIP        => options[:ip],
+          :shopperReference => options[:customer]
+        }.keep_if { |_, v| v }
+      end
+    end
+  end
+end

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

@@ -166,17 +166,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def headers
-        @@ua ||= JSON.dump(
-          :bindings_version => ActiveMerchant::VERSION,
-          :lang => 'ruby',
-          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
-          :platform => RUBY_PLATFORM,
-          :publisher => 'active_merchant'
-        )
-
         {
           "Authorization" => "Basic " + Base64.strict_encode64(@options[:api_key].to_s + ":" + @options[:api_secret].to_s),
-          "User-Agent" => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "User-Agent" => user_agent,
         }
       end
     end

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

@@ -15,25 +15,12 @@ module ActiveMerchant #:nodoc:
     # 4. Type in the answer to the secret question configured on setup
     # 5. Click Submit
     #
-    # ==== Automated Recurring Billing (ARB)
-    #
-    # Automated Recurring Billing (ARB) is an optional service for submitting and managing recurring, or subscription-based, transactions.
-    #
-    # To use recurring, update_recurring, cancel_recurring and status_recurring ARB must be enabled for your account.
-    #
-    # Information about ARB is available on the {Authorize.Net website}[http://www.authorize.net/solutions/merchantsolutions/merchantservices/automatedrecurringbilling/].
-    # Information about the ARB API is available at the {Authorize.Net Integration Center}[http://developer.authorize.net/]
     class AuthorizeNetGateway < Gateway
       API_VERSION = '3.1'
 
-      class_attribute :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"
 
-      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_attribute :duplicate_window
 
       APPROVED, DECLINED, ERROR, FRAUD_REVIEW = 1, 2, 3, 4
@@ -44,7 +31,7 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'USD'
 
       self.supported_countries = %w(AD AT AU BE BG CA CH CY CZ DE DK ES FI FR GB GB GI GR HU IE IT LI LU MC MT NL NO PL PT RO SE SI SK SM TR US VA)
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :maestro]
       self.homepage_url = 'http://www.authorize.net/'
       self.display_name = 'Authorize.Net'
 
@@ -53,15 +40,6 @@ module ActiveMerchant #:nodoc:
       AVS_REASON_CODES = %w(27 45)
       TRANSACTION_ALREADY_ACTIONED = %w(310 311)
 
-      AUTHORIZE_NET_ARB_NAMESPACE = 'AnetApi/xml/v1/schema/AnetApiSchema.xsd'
-
-      RECURRING_ACTIONS = {
-        :create => 'ARBCreateSubscription',
-        :update => 'ARBUpdateSubscription',
-        :cancel => 'ARBCancelSubscription',
-        :status => 'ARBGetSubscriptionStatus'
-      }
-
       # Creates a new AuthorizeNetGateway
       #
       # The gateway requires that a valid login and password be passed
@@ -177,89 +155,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.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.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be charged to the customer at each interval as an Integer value in cents.
-      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
-      # * <tt>options</tt> -- A hash of parameters.
-      #
-      # ==== Options
-      #
-      # * <tt>:interval</tt> -- A hash containing information about the interval of time between payments. Must
-      #   contain the keys <tt>:length</tt> and <tt>:unit</tt>. <tt>:unit</tt> can be either <tt>:months</tt> or <tt>:days</tt>.
-      #   If <tt>:unit</tt> is <tt>:months</tt> then <tt>:length</tt> must be an integer between 1 and 12 inclusive.
-      #   If <tt>:unit</tt> is <tt>:days</tt> then <tt>:length</tt> must be an integer between 7 and 365 inclusive.
-      #   For example, to charge the customer once every three months the hash would be
-      #   +:interval => { :unit => :months, :length => 3 }+ (REQUIRED)
-      # * <tt>:duration</tt> -- A hash containing keys for the <tt>:start_date</tt> the subscription begins (also the date the
-      #   initial billing occurs) and the total number of billing <tt>:occurrences</tt> or payments for the subscription. (REQUIRED)
-      def recurring(money, creditcard, options={})
-        requires!(options, :interval, :duration, :billing_address)
-        requires!(options[:interval], :length, [:unit, :days, :months])
-        requires!(options[:duration], :start_date, :occurrences)
-        requires!(options[:billing_address], :first_name, :last_name)
-
-        options[:credit_card] = creditcard
-        options[:amount] = money
-
-        request = build_recurring_request(:create, options)
-        recurring_commit(:create, request)
-      end
-
-      # Update a recurring payment's details.
-      #
-      # This transaction updates an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled
-      # and the subscription must have already been created previously by calling +recurring()+. The ability to change certain
-      # details about a recurring payment is dependent on transaction history and cannot be determined until after calling
-      # +update_recurring()+. See the ARB XML Guide for such conditions.
-      #
-      # ==== Parameters
-      #
-      # * <tt>options</tt> -- A hash of parameters.
-      #
-      # ==== Options
-      #
-      # * <tt>:subscription_id</tt> -- A string containing the <tt>:subscription_id</tt> of the recurring payment already in place
-      #   for a given credit card. (REQUIRED)
-      def update_recurring(options={})
-        requires!(options, :subscription_id)
-        request = build_recurring_request(:update, options)
-        recurring_commit(:update, request)
-      end
-
-      # Cancel a recurring payment.
-      #
-      # This transaction cancels an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled
-      # and the subscription must have already been created previously by calling recurring()
-      #
-      # ==== Parameters
-      #
-      # * <tt>subscription_id</tt> -- A string containing the +subscription_id+ of the recurring payment already in place
-      #   for a given credit card. (REQUIRED)
-      def cancel_recurring(subscription_id)
-        request = build_recurring_request(:cancel, :subscription_id => subscription_id)
-        recurring_commit(:cancel, request)
-      end
-
-      # Get Subscription Status of a recurring payment.
-      #
-      # This transaction gets the status of an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled.
-      #
-      # ==== Parameters
-      #
-      # * <tt>subscription_id</tt> -- A string containing the +subscription_id+ of the recurring payment already in place
-      #   for a given credit card. (REQUIRED)
-      def status_recurring(subscription_id)
-        request = build_recurring_request(:status, :subscription_id => subscription_id)
-        recurring_commit(:status, request)
+      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
 
       private
@@ -419,17 +323,6 @@ module ActiveMerchant #:nodoc:
         end
       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 message_from(results)
         if results[:response_code] == DECLINED
           return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
@@ -441,286 +334,9 @@ module ActiveMerchant #:nodoc:
         (results[:response_reason_text] ? results[:response_reason_text].chomp('.') : '')
       end
 
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
       def split(response)
         response[1..-2].split(/\$,\$/)
       end
-
-      # ARB
-
-      # Builds recurring billing request
-      def build_recurring_request(action, options = {})
-        unless RECURRING_ACTIONS.include?(action)
-          raise StandardError, "Invalid Automated Recurring Billing Action: #{action}"
-        end
-
-        xml = Builder::XmlMarkup.new(:indent => 2)
-        xml.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
-        xml.tag!("#{RECURRING_ACTIONS[action]}Request", :xmlns => AUTHORIZE_NET_ARB_NAMESPACE) do
-          add_arb_merchant_authentication(xml)
-          # Merchant-assigned reference ID for the request
-          xml.tag!('refId', options[:ref_id]) if options[:ref_id]
-          send("build_arb_#{action}_subscription_request", xml, options)
-        end
-      end
-
-      # Contains the merchant’s payment gateway account authentication information
-      def add_arb_merchant_authentication(xml)
-        xml.tag!('merchantAuthentication') do
-          xml.tag!('name', @options[:login])
-          xml.tag!('transactionKey', @options[:password])
-        end
-      end
-
-      # Builds body for ARBCreateSubscriptionRequest
-      def build_arb_create_subscription_request(xml, options)
-        # Subscription
-        add_arb_subscription(xml, options)
-
-        xml.target!
-      end
-
-      # Builds body for ARBUpdateSubscriptionRequest
-      def build_arb_update_subscription_request(xml, options)
-        xml.tag!('subscriptionId', options[:subscription_id])
-        # Adds Subscription
-        add_arb_subscription(xml, options)
-
-        xml.target!
-      end
-
-      # Builds body for ARBCancelSubscriptionRequest
-      def build_arb_cancel_subscription_request(xml, options)
-        xml.tag!('subscriptionId', options[:subscription_id])
-
-        xml.target!
-      end
-
-      # Builds body for ARBGetSubscriptionStatusRequest
-      def build_arb_status_subscription_request(xml, options)
-        xml.tag!('subscriptionId', options[:subscription_id])
-
-        xml.target!
-      end
-
-      # Adds subscription information
-      def add_arb_subscription(xml, options)
-        xml.tag!('subscription') do
-          # Merchant-assigned name for the subscription (optional)
-          xml.tag!('name', options[:subscription_name]) if options[:subscription_name]
-          # Contains information about the payment schedule
-          add_arb_payment_schedule(xml, options)
-          # The amount to be billed to the customer
-          # for each payment in the subscription
-          xml.tag!('amount', amount(options[:amount])) if options[:amount]
-          if trial = options[:trial]
-            # The amount to be charged for each payment during a trial period (conditional)
-            xml.tag!('trialAmount', amount(trial[:amount])) if trial[:amount]
-          end
-          # Contains either the customer’s credit card
-          # or bank account payment information
-          add_arb_payment(xml, options)
-          # Contains order information (optional)
-          add_arb_order(xml, options)
-          # Contains information about the customer
-          add_arb_customer(xml, options)
-          # Contains the customer's billing address information
-          add_arb_address(xml, 'billTo', options[:billing_address])
-          # Contains the customer's shipping address information (optional)
-          add_arb_address(xml, 'shipTo', options[:shipping_address])
-        end
-      end
-
-      # Adds information about the interval of time between payments
-      def add_arb_interval(xml, options)
-        interval = options[:interval]
-        return unless interval
-        xml.tag!('interval') do
-          # The measurement of time, in association with the Interval Unit,
-          # that is used to define the frequency of the billing occurrences
-          xml.tag!('length', interval[:length])
-          # The unit of time, in association with the Interval Length,
-          # between each billing occurrence
-          xml.tag!('unit', interval[:unit].to_s)
-        end
-      end
-
-      # Adds information about the subscription duration
-      def add_arb_duration(xml, options)
-        duration = options[:duration]
-        return unless duration
-        # The date the subscription begins
-        # (also the date the initial billing occurs)
-        xml.tag!('startDate', duration[:start_date]) if duration[:start_date]
-        # Number of billing occurrences or payments for the subscription
-        xml.tag!('totalOccurrences', duration[:occurrences]) if duration[:occurrences]
-      end
-
-      def add_arb_payment_schedule(xml, options)
-        return unless options[:interval] || options[:duration]
-        xml.tag!('paymentSchedule') do
-          # Contains information about the interval of time between payments
-          add_arb_interval(xml, options)
-          add_arb_duration(xml, options)
-          if trial = options[:trial]
-            # Number of billing occurrences or payments in the trial period (optional)
-            xml.tag!('trialOccurrences', trial[:occurrences]) if trial[:occurrences]
-          end
-        end
-      end
-
-      # Adds customer's credit card or bank account payment information
-      def add_arb_payment(xml, options)
-        return unless options[:credit_card] || options[:bank_account]
-        xml.tag!('payment') do
-          # Contains the customer’s credit card information
-          add_arb_credit_card(xml, options)
-          # Contains the customer’s bank account information
-          add_arb_bank_account(xml, options)
-        end
-      end
-
-      # Adds customer’s credit card information
-      # Note: This element should only be included
-      # when the payment method is credit card.
-      def add_arb_credit_card(xml, options)
-        credit_card = options[:credit_card]
-        return unless credit_card
-        xml.tag!('creditCard') do
-          # The credit card number used for payment of the subscription
-          xml.tag!('cardNumber', credit_card.number)
-          # The expiration date of the credit card used for the subscription
-          xml.tag!('expirationDate', arb_expdate(credit_card))
-        end
-      end
-
-      # Adds customer’s bank account information
-      # Note: This element should only be included
-      # when the payment method is bank account.
-      def add_arb_bank_account(xml, options)
-        bank_account = options[:bank_account]
-        return unless bank_account
-        xml.tag!('bankAccount') do
-          # The type of bank account used for payment of the subscription
-          xml.tag!('accountType', bank_account[:account_type])
-          # The routing number of the customer’s bank
-          xml.tag!('routingNumber', bank_account[:routing_number])
-          # The bank account number used for payment of the subscription
-          xml.tag!('accountNumber', bank_account[:account_number])
-          # The full name of the individual associated
-          # with the bank account number
-          xml.tag!('nameOfAccount', bank_account[:name_of_account])
-          # The full name of the individual associated
-          # with the bank account number (optional)
-          xml.tag!('bankName', bank_account[:bank_name]) if bank_account[:bank_name]
-          # The type of electronic check transaction used for the subscription
-          xml.tag!('echeckType', bank_account[:echeck_type])
-        end
-      end
-
-      # Adds order information (optional)
-      def add_arb_order(xml, options)
-        order = options[:order]
-        return unless order
-        xml.tag!('order') do
-          # Merchant-assigned invoice number for the subscription (optional)
-          xml.tag!('invoiceNumber', order[:invoice_number])
-          # Description of the subscription (optional)
-          xml.tag!('description', order[:description])
-        end
-      end
-
-      # Adds information about the customer
-      def add_arb_customer(xml, options)
-        customer = options[:customer]
-        return unless customer
-        xml.tag!('customer') do
-          xml.tag!('type', customer[:type]) if customer[:type]
-          xml.tag!('id', customer[:id]) if customer[:id]
-          xml.tag!('email', customer[:email]) if customer[:email]
-          xml.tag!('phoneNumber', customer[:phone_number]) if customer[:phone_number]
-          xml.tag!('faxNumber', customer[:fax_number]) if customer[:fax_number]
-          add_arb_drivers_license(xml, options)
-          xml.tag!('taxId', customer[:tax_id]) if customer[:tax_id]
-        end
-      end
-
-      # Adds the customer's driver's license information (conditional)
-      def add_arb_drivers_license(xml, options)
-        return unless customer = options[:customer]
-        return unless drivers_license = customer[:drivers_license]
-        xml.tag!('driversLicense') do
-          # The customer's driver's license number
-          xml.tag!('number', drivers_license[:number])
-          # The customer's driver's license state
-          xml.tag!('state', drivers_license[:state])
-          # The customer's driver's license date of birth
-          xml.tag!('dateOfBirth', drivers_license[:date_of_birth])
-        end
-      end
-
-      # Adds address information
-      def add_arb_address(xml, container_name, address)
-        return if address.blank?
-        xml.tag!(container_name) do
-          xml.tag!('firstName', address[:first_name])
-          xml.tag!('lastName', address[:last_name])
-          xml.tag!('company', address[:company])
-          xml.tag!('address', address[:address1])
-          xml.tag!('city', address[:city])
-          xml.tag!('state', address[:state])
-          xml.tag!('zip', address[:zip])
-          xml.tag!('country', address[:country])
-        end
-      end
-
-      def arb_expdate(credit_card)
-        sprintf('%04d-%02d', credit_card.year, credit_card.month)
-      end
-
-      def recurring_commit(action, request)
-        url = test? ? arb_test_url : arb_live_url
-        xml = ssl_post(url, request, "Content-Type" => "text/xml")
-
-        response = recurring_parse(action, xml)
-
-        message = response[:message] || response[:text]
-        test_mode = test? || message =~ /Test Mode/
-        success = response[:result_code] == 'Ok'
-
-        Response.new(success, message, response,
-          :test => test_mode,
-          :authorization => response[:subscription_id]
-        )
-      end
-
-     def recurring_parse(action, xml)
-        response = {}
-        xml = REXML::Document.new(xml)
-        root = REXML::XPath.first(xml, "//#{RECURRING_ACTIONS[action]}Response") ||
-               REXML::XPath.first(xml, "//ErrorResponse")
-        if root
-          root.elements.to_a.each do |node|
-            recurring_parse_element(response, node)
-          end
-        end
-
-        response
-      end
-
-      def recurring_parse_element(response, node)
-        if node.has_elements?
-          node.elements.each{|e| recurring_parse_element(response, e) }
-        else
-          response[node.name.underscore.to_sym] = node.text
-        end
-      end
     end
   end
 end