activemerchant 1.38.0 → 1.79.2

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

@@ -1,17 +1,8 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
-    # See the remote and mocked unit test files for example usage.  Pay special
-    # attention to the contents of the options hash.
-    #
     # Initial setup instructions can be found in
     # http://cybersource.com/support_center/implementation/downloads/soap_api/SOAP_toolkits.pdf
     #
-    # Debugging
-    # If you experience an issue with this gateway be sure to examine the
-    # transaction information from a general transaction search inside the
-    # CyberSource Business Center for the full error messages including field
-    # names.
-    #
     # Important Notes
     # * For checks you can purchase and store.
     # * AVS and CVV only work against the production server.  You will always
@@ -24,31 +15,38 @@ module ActiveMerchant #:nodoc:
     #   CyberSource what kind of item you are selling.  It is used when
     #   calculating tax/VAT.
     # * All transactions use dollar values.
-    # * To process pinless debit cards throught the pinless debit card
+    # * To process pinless debit cards through the pinless debit card
     #   network, your Cybersource merchant account must accept pinless
     #   debit card payments.
+    # * The order of the XML elements does matter, make sure to follow the order in
+    #   the documentation exactly.
     class CyberSourceGateway < Gateway
-      self.test_url = 'https://ics2wstest.ic3.com/commerce/1.x/transactionProcessor'
-      self.live_url = 'https://ics2ws.ic3.com/commerce/1.x/transactionProcessor'
+      self.test_url = 'https://ics2wstesta.ic3.com/commerce/1.x/transactionProcessor'
+      self.live_url = 'https://ics2wsa.ic3.com/commerce/1.x/transactionProcessor'
+
+      XSD_VERSION = "1.121"
 
-      XSD_VERSION = "1.69"
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :switch, :dankort, :maestro]
+      self.supported_countries = %w(US BR CA CN DK FI FR DE JP MX NO SE GB SG LB)
 
-      # visa, master, american_express, discover
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
-      self.supported_countries = ['US']
       self.default_currency = 'USD'
+      self.currencies_without_fractions = %w(JPY)
+
       self.homepage_url = 'http://www.cybersource.com'
       self.display_name = 'CyberSource'
 
-      # map credit card to the CyberSource expected representation
       @@credit_card_codes = {
         :visa  => '001',
         :master => '002',
         :american_express => '003',
-        :discover => '004'
+        :discover => '004',
+        :diners_club => '005',
+        :jcb => '007',
+        :switch => '024',
+        :dankort => '034',
+        :maestro => '042'
       }
 
-      # map response codes to something humans can read
       @@response_codes = {
         :r100 => "Successful transaction",
         :r101 => "Request is missing one or more required fields" ,
@@ -102,7 +100,7 @@ module ActiveMerchant #:nodoc:
       # :vat_reg_number => your VAT registration number
       #
       # :nexus => "WI CA QC" sets the states/provinces where you have a physical
-      #           presense for tax purposes
+      #           presence for tax purposes
       #
       # :ignore_avs => true   don't want to use AVS so continue processing even
       #                       if AVS would have failed
@@ -114,74 +112,67 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      # Request an authorization for an amount from CyberSource
-      #
-      # You must supply an :order_id in the options hash
       def authorize(money, creditcard_or_reference, options = {})
-        requires!(options,  :order_id)
         setup_address_hash(options)
-        commit(build_auth_request(money, creditcard_or_reference, options), options )
+        commit(build_auth_request(money, creditcard_or_reference, options), :authorize, money, options )
       end
 
-      def auth_reversal(money, identification, options = {})
-        commit(build_auth_reversal_request(money, identification, options), options)
-      end
-
-      # Capture an authorization that has previously been requested
       def capture(money, authorization, options = {})
         setup_address_hash(options)
-        commit(build_capture_request(money, authorization, options), options)
+        commit(build_capture_request(money, authorization, options), :capture, money, options)
       end
 
-      # Purchase is an auth followed by a capture
-      # You must supply an order_id in the options hash
       # options[:pinless_debit_card] => true # attempts to process as pinless debit card
       def purchase(money, payment_method_or_reference, options = {})
-        requires!(options, :order_id)
         setup_address_hash(options)
-        commit(build_purchase_request(money, payment_method_or_reference, options), options)
+        commit(build_purchase_request(money, payment_method_or_reference, options), :purchase, money, options)
       end
 
       def void(identification, options = {})
-        commit(build_void_request(identification, options), options)
+        commit(build_void_request(identification, options), :void, nil, options)
       end
 
       def refund(money, identification, options = {})
-        commit(build_refund_request(money, identification, options), options)
+        commit(build_refund_request(money, identification, options), :refund, money, options)
+      end
+
+      def verify(payment, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, payment, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
       end
 
       # Adds credit to a subscription (stand alone credit).
       def credit(money, reference, options = {})
-        requires!(options, :order_id)
-        commit(build_credit_request(money, reference, options), options)
+        commit(build_credit_request(money, reference, options), :credit, money, options)
       end
 
       # Stores a customer subscription/profile with type "on-demand".
       # To charge the card while creating a profile, pass
       # options[:setup_fee] => money
       def store(payment_method, options = {})
-        requires!(options, :order_id)
         setup_address_hash(options)
-        commit(build_create_subscription_request(payment_method, options), options)
+        commit(build_create_subscription_request(payment_method, options), :store, nil, options)
       end
 
       # Updates a customer subscription/profile
       def update(reference, creditcard, options = {})
         requires!(options, :order_id)
         setup_address_hash(options)
-        commit(build_update_subscription_request(reference, creditcard, options), options)
+        commit(build_update_subscription_request(reference, creditcard, options), :update, nil, options)
       end
 
       # Removes a customer subscription/profile
       def unstore(reference, options = {})
         requires!(options, :order_id)
-        commit(build_delete_subscription_request(reference, options), options)
+        commit(build_delete_subscription_request(reference, options), :unstore, nil, options)
       end
 
       # Retrieves a customer subscription/profile
       def retrieve(reference, options = {})
         requires!(options, :order_id)
-        commit(build_retrieve_subscription_request(reference, options), options)
+        commit(build_retrieve_subscription_request(reference, options), :retrieve, nil, options)
       end
 
       # CyberSource requires that you provide line item information for tax
@@ -213,29 +204,63 @@ module ActiveMerchant #:nodoc:
       def calculate_tax(creditcard, options)
         requires!(options,  :line_items)
         setup_address_hash(options)
-        commit(build_tax_calculation_request(creditcard, options), options)
+        commit(build_tax_calculation_request(creditcard, options), :calculate_tax, nil, options)
       end
 
       # Determines if a card can be used for Pinless Debit Card transactions
       def validate_pinless_debit_card(creditcard, options = {})
         requires!(options, :order_id)
-        commit(build_validate_pinless_debit_request(creditcard,options), options)
+        commit(build_validate_pinless_debit_request(creditcard,options), :validate_pinless_debit_card, nil, options)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<wsse:Password [^>]*>)[^<]*(</wsse:Password>))i, '\1[FILTERED]\2').
+          gsub(%r((<accountNumber>)[^<]*(</accountNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<cvNumber>)[^<]*(</cvNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<cavv>)[^<]*(</cavv>))i, '\1[FILTERED]\2').
+          gsub(%r((<xid>)[^<]*(</xid>))i, '\1[FILTERED]\2').
+          gsub(%r((<authenticationData>)[^<]*(</authenticationData>))i, '\1[FILTERED]\2')
+      end
+
+      def supports_network_tokenization?
+        true
+      end
+
+      def verify_credentials
+        response = void("0")
+        response.params["reasonCode"] == "102"
       end
 
       private
 
       # Create all address hash key value pairs so that we still function if we
-      # were only provided with one or two of them
+      # were only provided with one or two of them or even none
       def setup_address_hash(options)
-        options[:billing_address] = options[:billing_address] || options[:address] || {}
+        default_address = {
+          :address1 => 'Unspecified',
+          :city => 'Unspecified',
+          :state => 'NC',
+          :zip => '00000',
+          :country => 'US'
+        }
+        options[:billing_address] = options[:billing_address] || options[:address] || default_address
         options[:shipping_address] = options[:shipping_address] || {}
       end
 
       def build_auth_request(money, creditcard_or_reference, options)
         xml = Builder::XmlMarkup.new :indent => 2
         add_payment_method_or_subscription(xml, money, creditcard_or_reference, options)
-        add_auth_service(xml)
-        add_business_rules_data(xml)
+        add_decision_manager_fields(xml, options)
+        add_mdd_fields(xml, options)
+        add_auth_service(xml, creditcard_or_reference, options)
+        add_threeds_services(xml, options)
+        add_payment_network_token(xml) if network_tokenization?(creditcard_or_reference)
+        add_business_rules_data(xml, creditcard_or_reference, options)
         xml.target!
       end
 
@@ -246,7 +271,7 @@ module ActiveMerchant #:nodoc:
         add_line_item_data(xml, options)
         add_purchase_data(xml, 0, false, options)
         add_tax_service(xml)
-        add_business_rules_data(xml)
+        add_business_rules_data(xml, creditcard, options)
         xml.target!
       end
 
@@ -257,37 +282,37 @@ module ActiveMerchant #:nodoc:
         xml = Builder::XmlMarkup.new :indent => 2
         add_purchase_data(xml, money, true, options)
         add_capture_service(xml, request_id, request_token)
-        add_business_rules_data(xml)
+        add_business_rules_data(xml, authorization, options)
         xml.target!
       end
 
       def build_purchase_request(money, payment_method_or_reference, options)
         xml = Builder::XmlMarkup.new :indent => 2
         add_payment_method_or_subscription(xml, money, payment_method_or_reference, options)
+        add_decision_manager_fields(xml, options)
+        add_mdd_fields(xml, options)
         if !payment_method_or_reference.is_a?(String) && card_brand(payment_method_or_reference) == 'check'
           add_check_service(xml)
         else
-          add_purchase_service(xml, options)
-          add_business_rules_data(xml) unless options[:pinless_debit_card]
+          add_purchase_service(xml, payment_method_or_reference, options)
+          add_threeds_services(xml, options)
+          add_payment_network_token(xml) if network_tokenization?(payment_method_or_reference)
+          add_business_rules_data(xml, payment_method_or_reference, options) unless options[:pinless_debit_card]
         end
         xml.target!
       end
 
       def build_void_request(identification, options)
-        order_id, request_id, request_token = identification.split(";")
+        order_id, request_id, request_token, action, money, currency  = identification.split(";")
         options[:order_id] = order_id
 
         xml = Builder::XmlMarkup.new :indent => 2
-        add_void_service(xml, request_id, request_token)
-        xml.target!
-      end
-
-      def build_auth_reversal_request(money, identification, options)
-        order_id, request_id, request_token = identification.split(";")
-        options[:order_id] = order_id
-        xml = Builder::XmlMarkup.new :indent => 2
-        add_purchase_data(xml, money, true, options)
-        add_auth_reversal_service(xml, request_id, request_token)
+        if action == "capture"
+          add_void_service(xml, request_id, request_token)
+        else
+          add_purchase_data(xml, money, true, options.merge(:currency => currency || default_currency))
+          add_auth_reversal_service(xml, request_id, request_token)
+        end
         xml.target!
       end
 
@@ -313,7 +338,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_create_subscription_request(payment_method, options)
-        options[:subscription] = (options[:subscription] || {}).merge(:frequency => "on-demand", :amount => 0, :automatic_renew => false)
+        default_subscription_params = {:frequency => "on-demand", :amount => 0, :automatic_renew => false}
+        options[:subscription] = default_subscription_params.update(
+          options[:subscription] || {}
+        )
 
         xml = Builder::XmlMarkup.new :indent => 2
         add_address(xml, payment_method, options[:billing_address], options)
@@ -321,15 +349,21 @@ module ActiveMerchant #:nodoc:
         if card_brand(payment_method) == 'check'
           add_check(xml, payment_method)
           add_check_payment_method(xml)
-          add_check_service(xml, options) if options[:setup_fee]
         else
           add_creditcard(xml, payment_method)
           add_creditcard_payment_method(xml)
-          add_purchase_service(xml, options) if options[:setup_fee]
         end
         add_subscription(xml, options)
+        if options[:setup_fee]
+          if card_brand(payment_method) == 'check'
+            add_check_service(xml, options)
+          else
+            add_purchase_service(xml, payment_method, options)
+            add_payment_network_token(xml) if network_tokenization?(payment_method)
+          end
+        end
         add_subscription_create_service(xml, options)
-        add_business_rules_data(xml)
+        add_business_rules_data(xml, payment_method, options)
         xml.target!
       end
 
@@ -341,7 +375,7 @@ module ActiveMerchant #:nodoc:
         add_creditcard_payment_method(xml) if creditcard
         add_subscription(xml, options, reference)
         add_subscription_update_service(xml, options)
-        add_business_rules_data(xml)
+        add_business_rules_data(xml, creditcard, options)
         xml.target!
       end
 
@@ -366,17 +400,28 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
-      def add_business_rules_data(xml)
-        xml.tag! 'businessRules' do
-          xml.tag!('ignoreAVSResult', 'true') if @options[:ignore_avs]
-          xml.tag!('ignoreCVResult', 'true') if @options[:ignore_cvv]
+      def add_business_rules_data(xml, payment_method, options)
+        prioritized_options = [options, @options]
+
+        unless network_tokenization?(payment_method)
+          xml.tag! 'businessRules' do
+            xml.tag!('ignoreAVSResult', 'true') if extract_option(prioritized_options, :ignore_avs)
+            xml.tag!('ignoreCVResult', 'true') if extract_option(prioritized_options, :ignore_cvv)
+          end
+        end
+      end
+
+      def extract_option prioritized_options, option_name
+        options_matching_key = prioritized_options.detect do |options|
+          options.has_key? option_name
         end
+        options_matching_key[option_name] if options_matching_key
       end
 
       def add_line_item_data(xml, options)
         options[:line_items].each_with_index do |value, index|
           xml.tag! 'item', {'id' => index} do
-            xml.tag! 'unitPrice', amount(value[:declared_value])
+            xml.tag! 'unitPrice', localized_amount(value[:declared_value].to_i, options[:currency] || default_currency)
             xml.tag! 'quantity', value[:quantity]
             xml.tag! 'productCode', value[:code] || 'shipping_only'
             xml.tag! 'productName', value[:description]
@@ -387,7 +432,7 @@ module ActiveMerchant #:nodoc:
 
       def add_merchant_data(xml, options)
         xml.tag! 'merchantID', @options[:login]
-        xml.tag! 'merchantReferenceCode', options[:order_id]
+        xml.tag! 'merchantReferenceCode', options[:order_id] || generate_unique_id
         xml.tag! 'clientLibrary' ,'Ruby Active Merchant'
         xml.tag! 'clientLibraryVersion',  VERSION
         xml.tag! 'clientEnvironment' , RUBY_PLATFORM
@@ -396,13 +441,11 @@ module ActiveMerchant #:nodoc:
       def add_purchase_data(xml, money = 0, include_grand_total = false, options={})
         xml.tag! 'purchaseTotals' do
           xml.tag! 'currency', options[:currency] || currency(money)
-          xml.tag!('grandTotalAmount', amount(money))  if include_grand_total
+          xml.tag!('grandTotalAmount', localized_amount(money.to_i, options[:currency] || default_currency))  if include_grand_total
         end
       end
 
       def add_address(xml, payment_method, address, options, shipTo = false)
-        requires!(options, :email)
-
         xml.tag! shipTo ? 'shipTo' : 'billTo' do
           xml.tag! 'firstName',             payment_method.first_name             if payment_method
           xml.tag! 'lastName',              payment_method.last_name              if payment_method
@@ -411,11 +454,12 @@ module ActiveMerchant #:nodoc:
           xml.tag! 'city',                  address[:city]
           xml.tag! 'state',                 address[:state]
           xml.tag! 'postalCode',            address[:zip]
-          xml.tag! 'country',               address[:country]
+          xml.tag! 'country',               lookup_country_code(address[:country]) unless address[:country].blank?
           xml.tag! 'company',               address[:company]                 unless address[:company].blank?
           xml.tag! 'companyTaxID',          address[:companyTaxID]            unless address[:company_tax_id].blank?
-          xml.tag! 'phoneNumber',           address[:phone_number]            unless address[:phone_number].blank?
-          xml.tag! 'email',                 options[:email]
+          xml.tag! 'phoneNumber',           address[:phone]                   unless address[:phone].blank?
+          xml.tag! 'email',                 options[:email] || 'null@cybersource.com'
+          xml.tag! 'ipAddress',             options[:ip]                      unless options[:ip].blank? || shipTo
           xml.tag! 'driversLicenseNumber',  options[:drivers_license_number]  unless options[:drivers_license_number].blank?
           xml.tag! 'driversLicenseState',   options[:drivers_license_state]   unless options[:drivers_license_state].blank?
         end
@@ -431,6 +475,26 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_decision_manager_fields(xml, options)
+        return unless options[:decision_manager_enabled]
+
+        xml.tag! 'decisionManager' do
+          xml.tag! 'enabled', options[:decision_manager_enabled] if options[:decision_manager_enabled]
+          xml.tag! 'profile', options[:decision_manager_profile] if options[:decision_manager_profile]
+        end
+      end
+
+      def add_mdd_fields(xml, options)
+        return unless options.keys.any? { |key| key.to_s.start_with?("mdd_field") }
+
+        xml.tag! 'merchantDefinedData' do
+          (1..100).each do |each|
+            key = "mdd_field_#{each}".to_sym
+            xml.tag!("field#{each}", options[key]) if options[key]
+          end
+        end
+      end
+
       def add_check(xml, check)
         xml.tag! 'check' do
           xml.tag! 'accountNumber', check.account_number
@@ -446,8 +510,50 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_auth_service(xml)
-        xml.tag! 'ccAuthService', {'run' => 'true'}
+      def add_auth_service(xml, payment_method, options)
+        if network_tokenization?(payment_method)
+          add_auth_network_tokenization(xml, payment_method, options)
+        else
+          xml.tag! 'ccAuthService', {'run' => 'true'}
+        end
+      end
+
+      def network_tokenization?(payment_method)
+        payment_method.is_a?(NetworkTokenizationCreditCard)
+      end
+
+      def add_auth_network_tokenization(xml, payment_method, options)
+        return unless network_tokenization?(payment_method)
+
+        case card_brand(payment_method).to_sym
+        when :visa
+          xml.tag! 'ccAuthService', {'run' => 'true'} do
+            xml.tag!("cavv", payment_method.payment_cryptogram)
+            xml.tag!("commerceIndicator", "vbv")
+            xml.tag!("xid", payment_method.payment_cryptogram)
+          end
+        when :mastercard
+          xml.tag! 'ucaf' do
+            xml.tag!("authenticationData", payment_method.payment_cryptogram)
+            xml.tag!("collectionIndicator", "2")
+          end
+          xml.tag! 'ccAuthService', {'run' => 'true'} do
+            xml.tag!("commerceIndicator", "spa")
+          end
+        when :american_express
+          cryptogram = Base64.decode64(payment_method.payment_cryptogram)
+          xml.tag! 'ccAuthService', {'run' => 'true'} do
+            xml.tag!("cavv", Base64.encode64(cryptogram[0...20]))
+            xml.tag!("commerceIndicator", "aesk")
+            xml.tag!("xid", Base64.encode64(cryptogram[20...40]))
+          end
+        end
+      end
+
+      def add_payment_network_token(xml)
+        xml.tag! 'paymentNetworkToken' do
+          xml.tag!('transactionType', '1')
+        end
       end
 
       def add_capture_service(xml, request_id, request_token)
@@ -457,11 +563,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_purchase_service(xml, options)
+      def add_purchase_service(xml, payment_method, options)
         if options[:pinless_debit_card]
           xml.tag! 'pinlessDebitService', {'run' => 'true'}
         else
-          xml.tag! 'ccAuthService', {'run' => 'true'}
+          add_auth_service(xml, payment_method, options)
           xml.tag! 'ccCaptureService', {'run' => 'true'}
         end
       end
@@ -512,12 +618,12 @@ module ActiveMerchant #:nodoc:
 
         xml.tag! 'recurringSubscriptionInfo' do
           if reference
-            _, subscription_id, _ = reference.split(";")
+            subscription_id = reference.split(";")[6]
             xml.tag! 'subscriptionID',  subscription_id
           end
 
           xml.tag! 'status',            options[:subscription][:status]                         if options[:subscription][:status]
-          xml.tag! 'amount',            options[:subscription][:amount]                         if options[:subscription][:amount]
+          xml.tag! 'amount',            localized_amount(options[:subscription][:amount].to_i, options[:currency] || default_currency) if options[:subscription][:amount]
           xml.tag! 'numberOfPayments',  options[:subscription][:occurrences]                    if options[:subscription][:occurrences]
           xml.tag! 'automaticRenew',    options[:subscription][:automatic_renew]                if options[:subscription][:automatic_renew]
           xml.tag! 'frequency',         options[:subscription][:frequency]                      if options[:subscription][:frequency]
@@ -551,6 +657,7 @@ module ActiveMerchant #:nodoc:
           add_check(xml, payment_method_or_reference)
         else
           add_address(xml, payment_method_or_reference, options[:billing_address], options)
+          add_address(xml, payment_method_or_reference, options[:shipping_address], options, true)
           add_purchase_data(xml, money, true, options)
           add_creditcard(xml, payment_method_or_reference)
         end
@@ -560,6 +667,20 @@ module ActiveMerchant #:nodoc:
         xml.tag!'pinlessDebitValidateService', {'run' => 'true'}
       end
 
+      def add_threeds_services(xml, options)
+        xml.tag! 'payerAuthEnrollService', {'run' => 'true'} if options[:payer_auth_enroll_service]
+        if options[:payer_auth_validate_service]
+          xml.tag! 'payerAuthValidateService', {'run' => 'true'} do
+            xml.tag! 'signedPARes', options[:pares]
+          end
+        end
+      end
+
+      def lookup_country_code(country_field)
+        country_code = Country.find(country_field) rescue nil
+        country_code.code(:alpha2) if country_code
+      end
+
       # Where we actually build the full SOAP request using builder
       def build_request(body, options)
         xml = Builder::XmlMarkup.new :indent => 2
@@ -585,12 +706,19 @@ module ActiveMerchant #:nodoc:
 
       # Contact CyberSource, make the SOAP request, and parse the reply into a
       # Response object
-      def commit(request, options)
-        response = parse(ssl_post(test? ? self.test_url : self.live_url, build_request(request, options)))
+      def commit(request, action, amount, options)
+        begin
+          response = parse(ssl_post(test? ? self.test_url : self.live_url, build_request(request, options)))
+        rescue ResponseError => e
+          response = parse(e.response.body)
+        rescue REXML::ParseException => e
+          response = { message: e.to_s }
+        end
 
         success = response[:decision] == "ACCEPT"
-        message = @@response_codes[('r' + response[:reasonCode]).to_sym] rescue response[:message]
-        authorization = success ? [ options[:order_id], response[:requestID], response[:requestToken] ].compact.join(";") : nil
+        message = response[:message]
+
+        authorization = success ? authorization_from(response, action, amount, options) : nil
 
         Response.new(success, message, response,
           :test => test?,
@@ -607,9 +735,10 @@ module ActiveMerchant #:nodoc:
         xml = REXML::Document.new(xml)
         if root = REXML::XPath.first(xml, "//c:replyMessage")
           root.elements.to_a.each do |node|
-            case node.name
+            case node.expanded_name
             when 'c:reasonCode'
-              reply[:message] = reply(node.text)
+              reply[:reasonCode] = node.text
+              reply[:message] = reason_message(node.text)
             else
               parse_element(reply, node)
             end
@@ -626,14 +755,24 @@ module ActiveMerchant #:nodoc:
           node.elements.each{|e| parse_element(reply, e) }
         else
           if node.parent.name =~ /item/
-            parent = node.parent.name + (node.parent.attributes["id"] ? "_" + node.parent.attributes["id"] : '')
-            reply[(parent + '_' + node.name).to_sym] = node.text
-          else
-            reply[node.name.to_sym] = node.text
+            parent = node.parent.name
+            parent += '_' + node.parent.attributes["id"] if node.parent.attributes["id"]
+            parent += '_'
           end
+          reply["#{parent}#{node.name}".to_sym] ||= node.text
         end
         return reply
       end
+
+      def reason_message(reason_code)
+        return if reason_code.blank?
+        @@response_codes[:"r#{reason_code}"]
+      end
+
+      def authorization_from(response, action, amount, options)
+        [options[:order_id], response[:requestID], response[:requestToken], action, amount,
+         options[:currency], response[:subscriptionID]].join(";")
+      end
     end
   end
 end