activemerchant 1.42.6 → 1.90.0

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

@@ -6,10 +6,12 @@ module ActiveMerchant #:nodoc:
 
       self.default_currency = 'GBP'
       self.money_format = :cents
-      self.supported_countries = %w(HK US GB AU AD BE CH CY CZ DE DK ES FI FR GI GR HU IE IL IT LI LU MC MT NL NO NZ PL PT SE SG SI SM TR UM VA)
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :laser]
+      self.supported_countries = %w(HK GB AU AD AR BE BR CA CH CN CO CR CY CZ DE DK ES FI FR GI GR HU IE IN IT JP LI LU MC MT MY MX NL NO NZ PA PE PL PT SE SG SI SM TR UM VA)
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro]
+      self.currencies_without_fractions = %w(HUF IDR ISK JPY KRW)
+      self.currencies_with_three_decimal_places = %w(BHD KWD OMR RSD TND)
       self.homepage_url = 'http://www.worldpay.com/'
-      self.display_name = 'WorldPay'
+      self.display_name = 'Worldpay Global'
 
       CARD_CODES = {
         'visa'             => 'VISA-SSL',
@@ -18,8 +20,7 @@ module ActiveMerchant #:nodoc:
         'american_express' => 'AMEX-SSL',
         'jcb'              => 'JCB-SSL',
         'maestro'          => 'MAESTRO-SSL',
-        'laser'            => 'LASER-SSL',
-        'diners_club'      => 'DINERS-SSL'
+        'diners_club'      => 'DINERS-SSL',
       }
 
       def initialize(options = {})
@@ -29,8 +30,8 @@ module ActiveMerchant #:nodoc:
 
       def purchase(money, payment_method, options = {})
         MultiResponse.run do |r|
-          r.process{authorize(money, payment_method, options)}
-          r.process{capture(money, r.authorization, options.merge(:authorization_validated => true))}
+          r.process { authorize(money, payment_method, options) }
+          r.process { capture(money, r.authorization, options.merge(:authorization_validated => true)) }
         end
       end
 
@@ -41,56 +42,91 @@ module ActiveMerchant #:nodoc:
 
       def capture(money, authorization, options = {})
         MultiResponse.run do |r|
-          r.process{inquire_request(authorization, options, "AUTHORISED")} unless options[:authorization_validated]
+          r.process { inquire_request(authorization, options, 'AUTHORISED') } unless options[:authorization_validated]
           if r.params
             authorization_currency = r.params['amount_currency_code']
             options = options.merge(:currency => authorization_currency) if authorization_currency.present?
           end
-          r.process{capture_request(money, authorization, options)}
+          r.process { capture_request(money, authorization, options) }
         end
       end
 
       def void(authorization, options = {})
         MultiResponse.run do |r|
-          r.process{inquire_request(authorization, options, "AUTHORISED")}
-          r.process{cancel_request(authorization, options)}
+          r.process { inquire_request(authorization, options, 'AUTHORISED') } unless options[:authorization_validated]
+          r.process { cancel_request(authorization, options) }
         end
       end
 
       def refund(money, authorization, options = {})
-        MultiResponse.run do |r|
-          r.process{inquire_request(authorization, options, "CAPTURED", "SETTLED", "SETTLED_BY_MERCHANT")}
-          r.process{refund_request(money, authorization, options)}
+        response = MultiResponse.run do |r|
+          r.process { inquire_request(authorization, options, 'CAPTURED', 'SETTLED', 'SETTLED_BY_MERCHANT') }
+          r.process { refund_request(money, authorization, options) }
+        end
+
+        return response if response.success?
+        return response unless options[:force_full_refund_if_unsettled]
+
+        void(authorization, options) if response.params['last_event'] == 'AUTHORISED'
+      end
+
+      # Credits only function on a Merchant ID/login/profile flagged for Payouts
+      #   aka Credit Fund Transfers (CFT), whereas normal purchases, refunds,
+      #   and other transactions should be performed on a normal eCom-flagged
+      #   merchant ID.
+      def credit(money, payment_method, options = {})
+        credit_request(money, payment_method, options.merge(:credit => true))
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options.merge(:authorization_validated => true)) }
         end
       end
 
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((<cardNumber>)\d+(</cardNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<cvc>)[^<]+(</cvc>)), '\1[FILTERED]\2')
+      end
+
       private
 
       def authorize_request(money, payment_method, options)
-        commit('authorize', build_authorization_request(money, payment_method, options), "AUTHORISED")
+        commit('authorize', build_authorization_request(money, payment_method, options), 'AUTHORISED', options)
       end
 
       def capture_request(money, authorization, options)
-        commit('capture', build_capture_request(money, authorization, options), :ok)
+        commit('capture', build_capture_request(money, authorization, options), :ok, options)
       end
 
       def cancel_request(authorization, options)
-        commit('cancel', build_void_request(authorization, options), :ok)
+        commit('cancel', build_void_request(authorization, options), :ok, options)
       end
 
       def inquire_request(authorization, options, *success_criteria)
-        commit('inquiry', build_order_inquiry_request(authorization, options), *success_criteria)
+        commit('inquiry', build_order_inquiry_request(authorization, options), *success_criteria, options)
       end
 
       def refund_request(money, authorization, options)
-        commit('refund', build_refund_request(money, authorization, options), :ok)
+        commit('refund', build_refund_request(money, authorization, options), :ok, options)
+      end
+
+      def credit_request(money, payment_method, options)
+        commit('credit', build_authorization_request(money, payment_method, options), :ok, 'SENT_FOR_REFUND', options)
       end
 
       def build_request
         xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct! :xml, :encoding => 'ISO-8859-1'
-        xml.declare! :DOCTYPE, :paymentService, :PUBLIC, "-//WorldPay//DTD WorldPay PaymentService v1//EN", "http://dtd.wp3.rbsworldpay.com/paymentService_v1.dtd"
-        xml.tag! 'paymentService', 'version' => "1.4", 'merchantCode' => @options[:login] do
+        xml.instruct! :xml, :encoding => 'UTF-8'
+        xml.declare! :DOCTYPE, :paymentService, :PUBLIC, '-//WorldPay//DTD WorldPay PaymentService v1//EN', 'http://dtd.worldpay.com/paymentService_v1.dtd'
+        xml.tag! 'paymentService', 'version' => '1.4', 'merchantCode' => @options[:login] do
           yield xml
         end
         xml.target!
@@ -117,8 +153,8 @@ module ActiveMerchant #:nodoc:
       def build_authorization_request(money, payment_method, options)
         build_request do |xml|
           xml.tag! 'submit' do
-            xml.tag! 'order', {'orderCode' => options[:order_id], 'installationId' => @options[:inst_id]}.reject{|_,v| !v} do
-              xml.description(options[:description].blank? ? "Purchase" : options[:description])
+            xml.tag! 'order', order_tag_attributes(options) do
+              xml.description(options[:description].blank? ? 'Purchase' : options[:description])
               add_amount(xml, money, options)
               if options[:order_content]
                 xml.tag! 'orderContent' do
@@ -126,11 +162,22 @@ module ActiveMerchant #:nodoc:
                 end
               end
               add_payment_method(xml, money, payment_method, options)
+              add_email(xml, options)
+              if options[:hcg_additional_data]
+                add_hcg_additional_data(xml, options)
+              end
+              if options[:instalments]
+                add_instalments_data(xml, options)
+              end
             end
           end
         end
       end
 
+      def order_tag_attributes(options)
+        { 'orderCode' => options[:order_id], 'installationId' => options[:inst_id] || @options[:inst_id] }.reject { |_, v| !v }
+      end
+
       def build_capture_request(money, authorization, options)
         build_order_modify_request(authorization) do |xml|
           xml.tag! 'capture' do
@@ -150,23 +197,22 @@ module ActiveMerchant #:nodoc:
       def build_refund_request(money, authorization, options)
         build_order_modify_request(authorization) do |xml|
           xml.tag! 'refund' do
-            add_amount(xml, money, options.merge(:debit_credit_indicator => "credit"))
+            add_amount(xml, money, options.merge(:debit_credit_indicator => 'credit'))
           end
         end
       end
 
       def add_amount(xml, money, options)
         currency = options[:currency] || currency(money)
-        amount   = localized_amount(money, currency)
 
         amount_hash = {
-          :value => amount,
+          :value => localized_amount(money, currency),
           'currencyCode' => currency,
-          'exponent' => 2
+          'exponent' => currency_exponent(currency)
         }
 
         if options[:debit_credit_indicator]
-          amount_hash.merge!('debitCreditIndicator' => options[:debit_credit_indicator])
+          amount_hash['debitCreditIndicator'] = options[:debit_credit_indicator]
         end
 
         xml.tag! 'amount', amount_hash
@@ -174,52 +220,113 @@ module ActiveMerchant #:nodoc:
 
       def add_payment_method(xml, amount, payment_method, options)
         if payment_method.is_a?(String)
-          xml.tag! 'payAsOrder', 'orderCode' => payment_method do
-            add_amount(xml, amount, options)
+          if options[:merchant_code]
+            xml.tag! 'payAsOrder', 'orderCode' => payment_method, 'merchantCode' => options[:merchant_code] do
+              add_amount(xml, amount, options)
+            end
+          else
+            xml.tag! 'payAsOrder', 'orderCode' => payment_method do
+              add_amount(xml, amount, options)
+            end
           end
         else
-          xml.tag! 'paymentDetails' do
+          xml.tag! 'paymentDetails', credit_fund_transfer_attribute(options) do
             xml.tag! CARD_CODES[card_brand(payment_method)] do
               xml.tag! 'cardNumber', payment_method.number
               xml.tag! 'expiryDate' do
                 xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
               end
 
-              xml.tag! 'cardHolderName', payment_method.name
+              xml.tag! 'cardHolderName', options[:execute_threed] ? '3D' : payment_method.name
               xml.tag! 'cvc', payment_method.verification_value
 
-              add_address(xml, 'cardAddress', (options[:billing_address] || options[:address]))
+              add_address(xml, (options[:billing_address] || options[:address]))
             end
+            if options[:ip] && options[:session_id]
+              xml.tag! 'session', 'shopperIPAddress' => options[:ip], 'id' => options[:session_id]
+            else
+              xml.tag! 'session', 'shopperIPAddress' => options[:ip] if options[:ip]
+              xml.tag! 'session', 'id' => options[:session_id] if options[:session_id]
+            end
+            add_stored_credential_options(xml, options) if options[:stored_credential_usage]
+          end
+        end
+      end
+
+      def add_stored_credential_options(xml, options={})
+        if options[:stored_credential_initiated_reason]
+          xml.tag! 'storedCredentials', 'usage' => options[:stored_credential_usage], 'merchantInitiatedReason' => options[:stored_credential_initiated_reason] do
+            xml.tag! 'schemeTransactionIdentifier', options[:stored_credential_transaction_id] if options[:stored_credential_transaction_id]
+          end
+        else
+          xml.tag! 'storedCredentials', 'usage' => options[:stored_credential_usage]
+        end
+      end
+
+      def add_email(xml, options)
+        return unless options[:execute_threed] || options[:email]
+        xml.tag! 'shopper' do
+          xml.tag! 'shopperEmailAddress', options[:email] if  options[:email]
+          xml.tag! 'browser' do
+            xml.tag! 'acceptHeader', options[:accept_header]
+            xml.tag! 'userAgentHeader', options[:user_agent]
           end
         end
       end
 
-      def add_address(xml, element, address)
-        return if address.nil?
+      def add_address(xml, address)
+        return unless address
 
-        xml.tag! element do
+        address = address_with_defaults(address)
+
+        xml.tag! 'cardAddress' do
           xml.tag! 'address' do
             if m = /^\s*([^\s]+)\s+(.+)$/.match(address[:name])
               xml.tag! 'firstName', m[1]
               xml.tag! 'lastName', m[2]
             end
-            if m = /^\s*(\d+)\s+(.+)$/.match(address[:address1])
-              xml.tag! 'street', m[2]
-              house_number = m[1]
-            else
-              xml.tag! 'street', address[:address1]
-            end
-            xml.tag! 'houseName', address[:address2] if address[:address2]
-            xml.tag! 'houseNumber', house_number if house_number.present?
-            xml.tag! 'postalCode', (address[:zip].present? ? address[:zip] : "0000")
-            xml.tag! 'city', address[:city] if address[:city]
-            xml.tag! 'state', (address[:state].present? ? address[:state] : 'N/A')
+            xml.tag! 'address1', address[:address1]
+            xml.tag! 'address2', address[:address2] if address[:address2]
+            xml.tag! 'postalCode', address[:zip]
+            xml.tag! 'city', address[:city]
+            xml.tag! 'state', address[:state]
             xml.tag! 'countryCode', address[:country]
             xml.tag! 'telephoneNumber', address[:phone] if address[:phone]
           end
         end
       end
 
+      def add_hcg_additional_data(xml, options)
+        xml.tag! 'hcgAdditionalData' do
+          options[:hcg_additional_data].each do |k, v|
+            xml.tag! 'param', {name: k.to_s}, v
+          end
+        end
+      end
+
+      def add_instalments_data(xml, options)
+        xml.tag! 'thirdPartyData' do
+          xml.tag! 'instalments', options[:instalments]
+          xml.tag! 'cpf', options[:cpf] if options[:cpf]
+        end
+      end
+
+      def address_with_defaults(address)
+        address ||= {}
+        address.delete_if { |_, v| v.blank? }
+        address.reverse_merge!(default_address)
+      end
+
+      def default_address
+        {
+          address1: 'N/A',
+          zip: '0000',
+          city: 'N/A',
+          state: 'N/A',
+          country: 'US'
+        }
+      end
+
       def parse(action, xml)
         parse_element({:action => action}, REXML::Document.new(xml))
       end
@@ -230,16 +337,31 @@ module ActiveMerchant #:nodoc:
         end
         if node.has_elements?
           raw[node.name.underscore.to_sym] = true unless node.name.blank?
-          node.elements.each{|e| parse_element(raw, e) }
+          node.elements.each { |e| parse_element(raw, e) }
         else
           raw[node.name.underscore.to_sym] = node.text unless node.text.nil?
         end
         raw
       end
 
-      def commit(action, request, *success_criteria)
-        xmr = ssl_post(url, request, 'Content-Type' => 'text/xml', 'Authorization' => encoded_credentials)
-        raw = parse(action, xmr)
+      def headers(options)
+        headers = {
+          'Content-Type' => 'text/xml',
+          'Authorization' => encoded_credentials
+        }
+        if options[:cookie]
+          headers['Cookie'] = options[:cookie] if options[:cookie]
+        end
+        headers
+      end
+
+      def commit(action, request, *success_criteria, options)
+        xml = ssl_post(url, request, headers(options))
+        raw = parse(action, xml)
+        if options[:execute_threed]
+          raw[:cookie] = @cookie
+          raw[:session_id] = options[:session_id]
+        end
         success, message = success_and_message_from(raw, success_criteria)
 
         Response.new(
@@ -247,11 +369,11 @@ module ActiveMerchant #:nodoc:
           message,
           raw,
           :authorization => authorization_from(raw),
+          :error_code => error_code_from(success, raw),
           :test => test?)
-
       rescue ActiveMerchant::ResponseError => e
-        if e.response.code.to_s == "401"
-          return Response.new(false, "Invalid credentials", {}, :test => test?)
+        if e.response.code.to_s == '401'
+          return Response.new(false, 'Invalid credentials', {}, :test => test?)
         else
           raise e
         end
@@ -261,6 +383,18 @@ module ActiveMerchant #:nodoc:
         test? ? self.test_url : self.live_url
       end
 
+      # Override the regular handle response so we can access the headers
+      # Set-Cookie value is needed for 3DS transactions
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300
+          @cookie = response['Set-Cookie']
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
       # success_criteria can be:
       #   - a string or an array of strings (if one of many responses)
       #   - An array of strings if one of many responses could be considered a
@@ -268,7 +402,7 @@ module ActiveMerchant #:nodoc:
       def success_and_message_from(raw, success_criteria)
         success = (success_criteria.include?(raw[:last_event]) || raw[:ok].present?)
         if success
-          message = "SUCCESS"
+          message = 'SUCCESS'
         else
           message = (raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria))
         end
@@ -276,27 +410,37 @@ module ActiveMerchant #:nodoc:
         [ success, message ]
       end
 
+      def error_code_from(success, raw)
+        unless success == 'SUCCESS'
+          raw[:iso8583_return_code_code] || raw[:error_code] || nil
+        end
+      end
+
       def required_status_message(raw, success_criteria)
         if(!success_criteria.include?(raw[:last_event]))
-          "A transaction status of #{success_criteria.collect{|c| "'#{c}'"}.join(" or ")} is required."
+          "A transaction status of #{success_criteria.collect { |c| "'#{c}'" }.join(" or ")} is required."
         end
       end
 
       def authorization_from(raw)
-        pair = raw.detect{|k,v| k.to_s =~ /_order_code$/}
+        pair = raw.detect { |k, v| k.to_s =~ /_order_code$/ }
         (pair ? pair.last : nil)
       end
 
+      def credit_fund_transfer_attribute(options)
+        return unless options[:credit]
+        {'action' => 'REFUND'}
+      end
+
       def encoded_credentials
         credentials = "#{@options[:login]}:#{@options[:password]}"
         "Basic #{[credentials].pack('m').strip}"
       end
 
-      def localized_amount(money, currency)
-        amount = amount(money)
-        return amount unless CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
-
-        amount.to_i / 100 * 100
+      def currency_exponent(currency)
+        return 0 if non_fractional_currency?(currency)
+        return 3 if three_decimal_currency?(currency)
+        return 2
       end
     end
   end

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

@@ -0,0 +1,215 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WorldpayOnlinePaymentsGateway < Gateway
+      self.live_url =  'https://api.worldpay.com/v1/'
+
+      self.default_currency = 'GBP'
+
+      self.money_format = :cents
+
+      self.supported_countries = %w(HK US GB BE CH CZ DE DK ES FI FR GR HU IE IT LU MT NL NO PL PT SE SG TR)
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro]
+
+      self.homepage_url = 'http://online.worldpay.com'
+      self.display_name = 'Worldpay Online Payments'
+
+      def initialize(options={})
+        requires!(options, :client_key, :service_key)
+        @client_key = options[:client_key]
+        @service_key = options[:service_key]
+        super
+      end
+
+      def authorize(money, credit_card, options={})
+        response = create_token(true, credit_card.first_name+' '+credit_card.last_name, credit_card.month, credit_card.year, credit_card.number, credit_card.verification_value)
+        if response.success?
+          options[:authorizeOnly] = true
+          post = create_post_for_auth_or_purchase(response.authorization, money, options)
+          response = commit(:post, 'orders', post, {}, 'authorize')
+        end
+        response
+      end
+
+      def capture(money, authorization, options={})
+        if authorization
+          commit(:post, "orders/#{CGI.escape(authorization)}/capture", {'captureAmount'=>money}, options, 'capture')
+        else
+          Response.new(false,
+            'FAILED',
+            'FAILED',
+            :test => test?,
+            :authorization => false,
+            :avs_result => {},
+            :cvv_result => {},
+            :error_code => false
+          )
+        end
+      end
+
+      def purchase(money, credit_card, options={})
+        response = create_token(true, credit_card.first_name+' '+credit_card.last_name, credit_card.month, credit_card.year, credit_card.number, credit_card.verification_value)
+        if response.success?
+          post = create_post_for_auth_or_purchase(response.authorization, money, options)
+          response = commit(:post, 'orders', post, options, 'purchase')
+        end
+        response
+      end
+
+      def refund(money, orderCode, options={})
+        obj = money ? {'refundAmount' => money} : {}
+        commit(:post, "orders/#{CGI.escape(orderCode)}/refund", obj, options, 'refund')
+      end
+
+      def void(orderCode, options={})
+        response = commit(:delete, "orders/#{CGI.escape(orderCode)}", nil, options, 'void')
+        if !response.success? && (response.params && response.params['customCode'] != 'ORDER_NOT_FOUND')
+          response = refund(nil, orderCode)
+        end
+        response
+      end
+
+      def verify(credit_card, options={})
+        authorize(0, credit_card, options)
+      end
+
+      private
+
+      def create_token(reusable, name, exp_month, exp_year, number, cvc)
+        obj = {
+          'reusable'=> reusable,
+          'paymentMethod'=> {
+            'type'=> 'Card',
+            'name'=> name,
+            'expiryMonth'=> exp_month,
+            'expiryYear'=> exp_year,
+            'cardNumber'=> number,
+            'cvc'=> cvc
+          },
+          'clientKey'=> @client_key
+        }
+        token_response = commit(:post, 'tokens', obj, {'Authorization' => @service_key}, 'token')
+        token_response
+      end
+
+      def create_post_for_auth_or_purchase(token, money, options)
+        {
+          'token' => token,
+          'orderDescription' => options[:description] || 'Worldpay Order',
+          'amount' => money,
+          'currencyCode' => options[:currency] || default_currency,
+          'name' => options[:billing_address]&&options[:billing_address][:name] ? options[:billing_address][:name] : '',
+          'billingAddress' => {
+            'address1'=>options[:billing_address]&&options[:billing_address][:address1] ? options[:billing_address][:address1] : '',
+            'address2'=>options[:billing_address]&&options[:billing_address][:address2] ? options[:billing_address][:address2] : '',
+            'address3'=>'',
+            'postalCode'=>options[:billing_address]&&options[:billing_address][:zip] ? options[:billing_address][:zip] : '',
+            'city'=>options[:billing_address]&&options[:billing_address][:city] ? options[:billing_address][:city] : '',
+            'state'=>options[:billing_address]&&options[:billing_address][:state] ? options[:billing_address][:state] : '',
+            'countryCode'=>options[:billing_address]&&options[:billing_address][:country] ? options[:billing_address][:country] : ''
+           },
+          'customerOrderCode' => options[:order_id],
+          'orderType' => 'ECOM',
+          'authorizeOnly' => options[:authorizeOnly] ? true : false
+        }
+      end
+
+      def parse(body)
+        body ? JSON.parse(body) : {}
+      end
+
+      def headers(options = {})
+        headers = {
+          'Authorization' => @service_key,
+          'Content-Type' => 'application/json',
+          'User-Agent' => "Worldpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'X-Worldpay-Client-User-Agent' => user_agent,
+          'X-Worldpay-Client-User-Metadata' => {:ip => options[:ip]}.to_json
+        }
+        if options['Authorization']
+          headers['Authorization'] = options['Authorization']
+        end
+        headers
+      end
+
+      def commit(method, url, parameters=nil, options = {}, type = false)
+        raw_response = response = nil
+        success = false
+        begin
+          json = parameters ? parameters.to_json : nil
+
+          raw_response = ssl_request(method, self.live_url + url, json, headers(options))
+
+          if raw_response != ''
+            response = parse(raw_response)
+            if type == 'token'
+              success = response.key?('token')
+            else
+              if response.key?('httpStatusCode')
+                success = false
+              else
+                if type == 'authorize' && response['paymentStatus'] == 'AUTHORIZED'
+                  success = true
+                elsif type == 'purchase' && response['paymentStatus'] == 'SUCCESS'
+                  success = true
+                elsif type == 'capture' || type=='refund' || type=='void'
+                  success = true
+                end
+              end
+            end
+          else
+            success = true
+            response = {}
+          end
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = response_error(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        if response['orderCode']
+          authorization = response['orderCode']
+        elsif response['token']
+          authorization = response['token']
+        else
+          authorization = response['message']
+        end
+
+        Response.new(success,
+          success ? 'SUCCESS' : response['message'],
+          response,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => {},
+          :cvv_result => {},
+          :error_code => success ? nil : response['customCode']
+        )
+      end
+
+      def test?
+        @service_key[0] == 'T'
+      end
+
+      def response_error(raw_response)
+        parse(raw_response)
+      rescue JSON::ParserError
+        json_error(raw_response)
+      end
+
+      def json_error(raw_response)
+        msg = 'Invalid response received from the Worldpay Online Payments API.  Please contact techsupport.online@worldpay.com if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          'error' => {
+            'message' => msg
+          }
+        }
+      end
+
+      def handle_response(response)
+        response.body
+      end
+
+    end
+  end
+end