activemerchant 1.90.0 → 1.99.0

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

@@ -4,18 +4,21 @@ module ActiveMerchant #:nodoc:
 
       # we recommend setting up merchant-specific endpoints.
       # https://docs.adyen.com/developers/api-manual#apiendpoints
-      self.test_url = 'https://pal-test.adyen.com/pal/servlet/Payment/v18'
-      self.live_url = 'https://pal-live.adyen.com/pal/servlet/Payment/v18'
+      self.test_url = 'https://pal-test.adyen.com/pal/servlet/Payment/'
+      self.live_url = 'https://pal-live.adyen.com/pal/servlet/Payment/'
 
       self.supported_countries = ['AT', 'AU', 'BE', 'BG', 'BR', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GB', 'GI', 'GR', 'HK', 'HU', 'IE', 'IS', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'MX', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SG', 'SK', 'SI', 'US']
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb, :dankort, :maestro,  :discover]
+      self.currencies_without_fractions = %w(CVE DJF GNF IDR JPY KMF KRW PYG RWF UGX VND VUV XAF XOF XPF)
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb, :dankort, :maestro,  :discover, :elo, :naranja, :cabal]
 
       self.money_format = :cents
 
       self.homepage_url = 'https://www.adyen.com/'
       self.display_name = 'Adyen'
 
+      API_VERSION = 'v40'
+
       STANDARD_ERROR_CODE_MAPPING = {
         '101' => STANDARD_ERROR_CODE[:incorrect_number],
         '103' => STANDARD_ERROR_CODE[:invalid_cvc],
@@ -33,12 +36,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, payment, options={})
-        if options[:execute_threed]
+        if options[:execute_threed] || options[:threed_dynamic]
           authorize(money, payment, options)
         else
           MultiResponse.run do |r|
             r.process { authorize(money, payment, options) }
-            r.process { capture(money, r.authorization, options) }
+            r.process { capture(money, r.authorization, capture_options(options)) }
           end
         end
       end
@@ -49,31 +52,40 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, money, options)
         add_payment(post, payment)
         add_extra_data(post, payment, options)
-        add_shopper_interaction(post, payment, options)
+        add_stored_credentials(post, payment, options)
         add_address(post, options)
         add_installments(post, options) if options[:installments]
-        add_3ds(post, options) if options[:execute_threed]
-        commit('authorise', post)
+        add_3ds(post, options)
+        add_3ds_authenticated_data(post, options)
+        commit('authorise', post, options)
       end
 
       def capture(money, authorization, options={})
         post = init_post(options)
         add_invoice_for_modification(post, money, options)
         add_reference(post, authorization, options)
-        commit('capture', post)
+        commit('capture', post, options)
       end
 
       def refund(money, authorization, options={})
         post = init_post(options)
         add_invoice_for_modification(post, money, options)
         add_original_reference(post, authorization, options)
-        commit('refund', post)
+        commit('refund', post, options)
       end
 
       def void(authorization, options={})
         post = init_post(options)
         add_reference(post, authorization, options)
-        commit('cancel', post)
+        commit('cancel', post, options)
+      end
+
+      def adjust(money, authorization, options={})
+        post = init_post(options)
+        add_invoice_for_modification(post, money, options)
+        add_reference(post, authorization, options)
+        add_extra_data(post, nil, options)
+        commit('adjustAuthorisation', post, options)
       end
 
       def store(credit_card, options={})
@@ -82,14 +94,23 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, 0, options)
         add_payment(post, credit_card)
         add_extra_data(post, credit_card, options)
+        add_stored_credentials(post, credit_card, options)
         add_recurring_contract(post, options)
         add_address(post, options)
-        commit('authorise', post)
+
+        initial_response = commit('authorise', post, options)
+
+        if initial_response.success? && card_not_stored?(initial_response)
+          unsupported_failure_response(initial_response)
+        else
+          initial_response
+        end
       end
 
       def verify(credit_card, options={})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(0, credit_card, options) }
+          options[:idempotency_key] = nil
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
@@ -110,24 +131,32 @@ module ActiveMerchant #:nodoc:
 
       AVS_MAPPING = {
         '0'  => 'R',  # Unknown
-        '1'  => 'A',	# Address matches, postal code doesn't
-        '2'  => 'N',	# Neither postal code nor address match
-        '3'  => 'R',	# AVS unavailable
-        '4'  => 'E',	# AVS not supported for this card type
-        '5'  => 'U',	# No AVS data provided
-        '6'  => 'Z',	# Postal code matches, address doesn't match
-        '7'  => 'D',	# Both postal code and address match
-        '8'  => 'U',	# Address not checked, postal code unknown
-        '9'  => 'B',	# Address matches, postal code unknown
-        '10' => 'N',	# Address doesn't match, postal code unknown
-        '11' => 'U',	# Postal code not checked, address unknown
-        '12' => 'B',	# Address matches, postal code not checked
-        '13' => 'U',	# Address doesn't match, postal code not checked
-        '14' => 'P',	# Postal code matches, address unknown
-        '15' => 'P',	# Postal code matches, address not checked
-        '16' => 'N',	# Postal code doesn't match, address unknown
+        '1'  => 'A',  # Address matches, postal code doesn't
+        '2'  => 'N',  # Neither postal code nor address match
+        '3'  => 'R',  # AVS unavailable
+        '4'  => 'E',  # AVS not supported for this card type
+        '5'  => 'U',  # No AVS data provided
+        '6'  => 'Z',  # Postal code matches, address doesn't match
+        '7'  => 'D',  # Both postal code and address match
+        '8'  => 'U',  # Address not checked, postal code unknown
+        '9'  => 'B',  # Address matches, postal code unknown
+        '10' => 'N',  # Address doesn't match, postal code unknown
+        '11' => 'U',  # Postal code not checked, address unknown
+        '12' => 'B',  # Address matches, postal code not checked
+        '13' => 'U',  # Address doesn't match, postal code not checked
+        '14' => 'P',  # Postal code matches, address unknown
+        '15' => 'P',  # Postal code matches, address not checked
+        '16' => 'N',  # Postal code doesn't match, address unknown
         '17' => 'U',  # Postal code doesn't match, address not checked
-        '18' => 'I'	  # Neither postal code nor address were checked
+        '18' => 'I',  # Neither postal code nor address were checked
+        '19' => 'L',  # Name and postal code matches.
+        '20' => 'V',  # Name, address and postal code matches.
+        '21' => 'O',  # Name and address matches.
+        '22' => 'K',  # Name matches.
+        '23' => 'F',  # Postal code matches, name doesn't match.
+        '24' => 'H',  # Both postal code and address matches, name doesn't match.
+        '25' => 'T',  # Address matches, name doesn't match.
+        '26' => 'N'   # Neither postal code, address nor name matches.
       }
 
       CVC_MAPPING = {
@@ -147,9 +176,11 @@ module ActiveMerchant #:nodoc:
       }
 
       def add_extra_data(post, payment, options)
+        post[:telephoneNumber] = options[:billing_address][:phone] if options.dig(:billing_address, :phone)
         post[:shopperEmail] = options[:shopper_email] if options[:shopper_email]
         post[:shopperIP] = options[:shopper_ip] if options[:shopper_ip]
         post[:shopperReference] = options[:shopper_reference] if options[:shopper_reference]
+        post[:shopperStatement] = options[:shopper_statement] if options[:shopper_statement]
         post[:fraudOffset] = options[:fraud_offset] if options[:fraud_offset]
         post[:selectedBrand] = options[:selected_brand] if options[:selected_brand]
         post[:selectedBrand] ||= NETWORK_TOKENIZATION_CARD_SOURCE[payment.source.to_s] if payment.is_a?(NetworkTokenizationCreditCard)
@@ -159,18 +190,29 @@ module ActiveMerchant #:nodoc:
         post[:additionalData][:overwriteBrand] = normalize(options[:overwrite_brand]) if options[:overwrite_brand]
         post[:additionalData][:customRoutingFlag] = options[:custom_routing_flag] if options[:custom_routing_flag]
         post[:additionalData]['paymentdatasource.type'] = NETWORK_TOKENIZATION_CARD_SOURCE[payment.source.to_s] if payment.is_a?(NetworkTokenizationCreditCard)
+        post[:additionalData][:authorisationType] = options[:authorisation_type] if options[:authorisation_type]
+        post[:additionalData][:adjustAuthorisationData] = options[:adjust_authorisation_data] if options[:adjust_authorisation_data]
+        post[:additionalData][:industryUsage] = options[:industry_usage] if options[:industry_usage]
+        post[:additionalData][:updateShopperStatement] = options[:update_shopper_statement] if options[:update_shopper_statement]
+        post[:additionalData][:RequestedTestAcquirerResponseCode] = options[:requested_test_acquirer_response_code] if options[:requested_test_acquirer_response_code] && test?
+        post[:deviceFingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
         add_risk_data(post, options)
       end
 
       def add_risk_data(post, options)
-        risk_data = {}
-        risk_data.merge!(options[:risk_data]) if options[:risk_data]
+        if (risk_data = options[:risk_data])
+          risk_data = Hash[risk_data.map { |k, v| ["riskdata.#{k}", v] }]
+          post[:additionalData].merge!(risk_data)
+        end
+      end
 
-        post[:additionalData][:riskData] = risk_data unless risk_data.empty?
+      def add_stored_credentials(post, payment, options)
+        add_shopper_interaction(post, payment, options)
+        add_recurring_processing_model(post, options)
       end
 
       def add_shopper_interaction(post, payment, options={})
-        if (payment.respond_to?(:verification_value) && payment.verification_value) || payment.is_a?(NetworkTokenizationCreditCard)
+        if options.dig(:stored_credential, :initial_transaction) || (payment.respond_to?(:verification_value) && payment.verification_value) || payment.is_a?(NetworkTokenizationCreditCard)
           shopper_interaction = 'Ecommerce'
         else
           shopper_interaction = 'ContAuth'
@@ -179,32 +221,48 @@ module ActiveMerchant #:nodoc:
         post[:shopperInteraction] = options[:shopper_interaction] || shopper_interaction
       end
 
+      def add_recurring_processing_model(post, options)
+        return unless options.dig(:stored_credential, :reason_type) || options[:recurring_processing_model]
+        if options.dig(:stored_credential, :reason_type) && options[:stored_credential][:reason_type] == 'unscheduled'
+          recurring_processing_model = 'CardOnFile'
+        else
+          recurring_processing_model = 'Subscription'
+        end
+
+        post[:recurringProcessingModel] = options[:recurring_processing_model] || recurring_processing_model
+      end
+
       def add_address(post, options)
         return unless post[:card]&.kind_of?(Hash)
         if (address = options[:billing_address] || options[:address]) && address[:country]
-          post[:card][:billingAddress] = {}
-          post[:card][:billingAddress][:street] = address[:address1] || 'N/A'
-          post[:card][:billingAddress][:houseNumberOrName] = address[:address2] || 'N/A'
-          post[:card][:billingAddress][:postalCode] = address[:zip] if address[:zip]
-          post[:card][:billingAddress][:city] = address[:city] || 'N/A'
-          post[:card][:billingAddress][:stateOrProvince] = address[:state] if address[:state]
-          post[:card][:billingAddress][:country] = address[:country] if address[:country]
+          post[:billingAddress] = {}
+          post[:billingAddress][:street] = address[:address1] || 'NA'
+          post[:billingAddress][:houseNumberOrName] = address[:address2] || 'NA'
+          post[:billingAddress][:postalCode] = address[:zip] if address[:zip]
+          post[:billingAddress][:city] = address[:city] || 'NA'
+          post[:billingAddress][:stateOrProvince] = get_state(address)
+          post[:billingAddress][:country] = address[:country] if address[:country]
         end
       end
 
+      def get_state(address)
+        address[:state] && !address[:state].blank? ? address[:state] : 'NA'
+      end
+
       def add_invoice(post, money, options)
+        currency = options[:currency] || currency(money)
         amount = {
-          value: amount(money),
-          currency: options[:currency] || currency(money)
+          value: localized_amount(money, currency),
+          currency: currency
         }
         post[:amount] = amount
-        post[:recurringProcessingModel] = options[:recurring_processing_model] if options[:recurring_processing_model]
       end
 
       def add_invoice_for_modification(post, money, options)
+        currency = options[:currency] || currency(money)
         amount = {
-          value: amount(money),
-          currency: options[:currency] || currency(money)
+          value: localized_amount(money, currency),
+          currency: currency
         }
         post[:modificationAmount] = amount
       end
@@ -235,6 +293,11 @@ module ActiveMerchant #:nodoc:
         post[:card] = card
       end
 
+      def capture_options(options)
+        return options.merge(idempotency_key: "#{options[:idempotency_key]}-cap") if options[:idempotency_key]
+        options
+      end
+
       def add_reference(post, authorization, options = {})
         _, psp_reference, _ = authorization.split('#')
         post[:originalReference] = single_reference(authorization) || psp_reference
@@ -272,8 +335,62 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_3ds(post, options)
-        post[:additionalData] = { executeThreeD: 'true' }
-        post[:browserInfo] = { userAgent: options[:user_agent], acceptHeader: options[:accept_header] }
+        if three_ds_2_options = options[:three_ds_2]
+          device_channel = three_ds_2_options[:channel]
+          if device_channel == 'app'
+            post[:threeDS2RequestData] = { deviceChannel: device_channel }
+          else
+            add_browser_info(three_ds_2_options[:browser_info], post)
+            post[:threeDS2RequestData] = { deviceChannel: device_channel, notificationURL: three_ds_2_options[:notification_url] }
+          end
+
+          if options.has_key?(:execute_threed)
+            post[:additionalData][:executeThreeD] = options[:execute_threed]
+            post[:additionalData][:scaExemption] = options[:sca_exemption] if options[:sca_exemption]
+          end
+        else
+          return unless options[:execute_threed] || options[:threed_dynamic]
+          post[:browserInfo] = { userAgent: options[:user_agent], acceptHeader: options[:accept_header] }
+          post[:additionalData] = { executeThreeD: 'true' } if options[:execute_threed]
+        end
+      end
+
+      def add_3ds_authenticated_data(post, options)
+        if options[:three_d_secure] && options[:three_d_secure][:eci] && options[:three_d_secure][:xid]
+          add_3ds1_authenticated_data(post, options)
+        elsif options[:three_d_secure]
+          add_3ds2_authenticated_data(post, options)
+        end
+      end
+
+      def add_3ds1_authenticated_data(post, options)
+        three_d_secure_options = options[:three_d_secure]
+        post[:mpiData] = {
+          cavv: three_d_secure_options[:cavv],
+          cavvAlgorithm: three_d_secure_options[:cavv_algorithm],
+          eci: three_d_secure_options[:eci],
+          xid: three_d_secure_options[:xid],
+          directoryResponse: three_d_secure_options[:directory_response_status],
+          authenticationResponse: three_d_secure_options[:authentication_response_status]
+        }
+      end
+
+      def add_3ds2_authenticated_data(post, options)
+        three_d_secure_options = options[:three_d_secure]
+        # If the transaction was authenticated in a frictionless flow, send the transStatus from the ARes.
+        if(three_d_secure_options[:authentication_response_status].nil?)
+          authentication_response = three_d_secure_options[:directory_response_status]
+        else
+          authentication_response = three_d_secure_options[:authentication_response_status]
+        end
+        post[:mpiData] = {
+          threeDSVersion: three_d_secure_options[:version],
+          eci: three_d_secure_options[:eci],
+          cavv: three_d_secure_options[:cavv],
+          dsTransID: three_d_secure_options[:ds_transaction_id],
+          directoryResponse: three_d_secure_options[:directory_response_status],
+          authenticationResponse: authentication_response
+        }
       end
 
       def parse(body)
@@ -281,9 +398,9 @@ module ActiveMerchant #:nodoc:
         JSON.parse(body)
       end
 
-      def commit(action, parameters)
+      def commit(action, parameters, options)
         begin
-          raw_response = ssl_post("#{url}/#{action}", post_data(action, parameters), request_headers)
+          raw_response = ssl_post("#{url}/#{action}", post_data(action, parameters), request_headers(options))
           response = parse(raw_response)
         rescue ResponseError => e
           raw_response = e.response.body
@@ -312,11 +429,11 @@ module ActiveMerchant #:nodoc:
 
       def url
         if test?
-          test_url
+          "#{test_url}#{API_VERSION}"
         elsif @options[:subdomain]
-          "https://#{@options[:subdomain]}-pal-live.adyenpayments.com/pal/servlet/Payment/v18"
+          "https://#{@options[:subdomain]}-pal-live.adyenpayments.com/pal/servlet/Payment/#{API_VERSION}"
         else
-          live_url
+          "#{live_url}#{API_VERSION}"
         end
       end
 
@@ -324,11 +441,13 @@ module ActiveMerchant #:nodoc:
         Base64.strict_encode64("#{@username}:#{@password}")
       end
 
-      def request_headers
-        {
+      def request_headers(options)
+        headers = {
           'Content-Type' => 'application/json',
           'Authorization' => "Basic #{basic_auth}"
         }
+        headers['Idempotency-Key'] = options[:idempotency_key] if options[:idempotency_key]
+        headers
       end
 
       def success_from(action, response)
@@ -337,6 +456,8 @@ module ActiveMerchant #:nodoc:
           ['Authorised', 'Received', 'RedirectShopper'].include?(response['resultCode'])
         when 'capture', 'refund', 'cancel'
           response['response'] == "[#{action}-received]"
+        when 'adjustAuthorisation'
+          response['response'] == 'Authorised' || response['response'] == '[adjustAuthorisation-received]'
         else
           false
         end
@@ -375,6 +496,37 @@ module ActiveMerchant #:nodoc:
       def error_code_from(response)
         STANDARD_ERROR_CODE_MAPPING[response['errorCode']]
       end
+
+      def add_browser_info(browser_info, post)
+        return unless browser_info
+        post[:browserInfo] = {
+          acceptHeader: browser_info[:accept_header],
+          colorDepth: browser_info[:depth],
+          javaEnabled: browser_info[:java],
+          language: browser_info[:language],
+          screenHeight: browser_info[:height],
+          screenWidth: browser_info[:width],
+          timeZoneOffset: browser_info[:timezone],
+          userAgent: browser_info[:user_agent]
+        }
+      end
+
+      def unsupported_failure_response(initial_response)
+        Response.new(
+          false,
+          'Recurring transactions are not supported for this card type.',
+          initial_response.params,
+          authorization: initial_response.authorization,
+          test: initial_response.test,
+          error_code: initial_response.error_code,
+          avs_result: initial_response.avs_result,
+          cvv_result: initial_response.cvv_result[:code]
+        )
+      end
+
+      def card_not_stored?(response)
+        response.authorization ? response.authorization.split('#')[2].nil? : true
+      end
     end
   end
 end

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

@@ -0,0 +1,226 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class BamboraApacGateway < Gateway
+      self.live_url = 'https://www.bambora.co.nz/interface/api'
+      self.test_url = 'https://demo.bambora.co.nz/interface/api'
+
+      self.supported_countries = ['AU', 'NZ']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
+
+      self.homepage_url = 'http://www.bambora.com/'
+      self.display_name = 'Bambora Asia-Pacific'
+
+      self.money_format = :cents
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '05' => STANDARD_ERROR_CODE[:card_declined],
+        '06' => STANDARD_ERROR_CODE[:processing_error],
+        '14' => STANDARD_ERROR_CODE[:invalid_number],
+        '54' => STANDARD_ERROR_CODE[:expired_card],
+      }
+
+      def initialize(options={})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        commit('SubmitSinglePayment') do |xml|
+          xml.Transaction do
+            xml.CustRef options[:order_id]
+            add_amount(xml, money)
+            xml.TrnType '1'
+            add_payment(xml, payment)
+            add_credentials(xml, options)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def authorize(money, payment, options={})
+        commit('SubmitSinglePayment') do |xml|
+          xml.Transaction do
+            xml.CustRef options[:order_id]
+            add_amount(xml, money)
+            xml.TrnType '2'
+            add_payment(xml, payment)
+            add_credentials(xml, options)
+            xml.TrnSource options[:ip]
+          end
+        end
+      end
+
+      def capture(money, authorization, options={})
+        commit('SubmitSingleCapture') do |xml|
+          xml.Capture do
+            xml.Receipt authorization
+            add_amount(xml, money)
+            add_credentials(xml, options)
+          end
+        end
+      end
+
+      def refund(money, authorization, options={})
+        commit('SubmitSingleRefund') do |xml|
+          xml.Refund do
+            xml.Receipt authorization
+            add_amount(xml, money)
+            add_credentials(xml, options)
+          end
+        end
+      end
+
+      def void(money, authorization, options={})
+        commit('SubmitSingleVoid') do |xml|
+          xml.Void do
+            xml.Receipt authorization
+            add_amount(xml, money)
+            add_credentials(xml, options)
+          end
+        end
+      end
+
+      def store(payment, options={})
+        commit('TokeniseCreditCard') do |xml|
+          xml.TokeniseCreditCard do
+            xml.CardNumber payment.number
+            xml.ExpM format(payment.month, :two_digits)
+            xml.ExpY format(payment.year, :four_digits)
+            xml.TokeniseAlgorithmID options[:tokenise_algorithm_id] || 2
+            xml.UserName @options[:username]
+            xml.Password @options[:password]
+          end
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<CardNumber>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<CVN>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<Password>)[^<]+(<))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_credentials(xml, options)
+        xml.AccountNumber options[:account_number] if options[:account_number]
+        xml.Security do
+          xml.UserName @options[:username]
+          xml.Password @options[:password]
+        end
+      end
+
+      def add_amount(xml, money)
+        xml.Amount amount(money)
+      end
+
+      def add_payment(xml, payment)
+        if payment.is_a?(String)
+          add_token(xml, payment)
+        else
+          add_credit_card(xml, payment)
+        end
+      end
+
+      def add_token(xml, payment)
+        xml.CreditCard do
+          xml.TokeniseAlgorithmID options[:tokenise_algorithm_id] || 2
+          xml.CardNumber payment
+        end
+      end
+
+      def add_credit_card(xml, payment)
+        xml.CreditCard :Registered => 'False' do
+          xml.CardNumber payment.number
+          xml.ExpM format(payment.month, :two_digits)
+          xml.ExpY format(payment.year, :four_digits)
+          xml.CVN payment.verification_value
+          xml.CardHolderName payment.name
+        end
+      end
+
+      def parse(body)
+        element = Nokogiri::XML(body).root.first_element_child.first_element_child
+
+        response = {}
+        doc = Nokogiri::XML(element)
+        doc.root.elements.each do |e|
+          response[e.name.underscore.to_sym] = e.inner_text
+        end
+        response
+      end
+
+      def commit(action, &block)
+        headers = {
+          'Content-Type' => 'text/xml; charset=utf-8',
+          'SOAPAction' => "http://www.ippayments.com.au/interface/api/#{endpoint(action)}/#{action}"
+        }
+        response = parse(ssl_post("#{commit_url}/#{endpoint(action)}.asmx", new_submit_xml(action, &block), headers))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          error_code: error_code_from(response),
+          test: test?
+        )
+      end
+
+      def new_submit_xml(action)
+        xml = Builder::XmlMarkup.new(indent: 2)
+        xml.instruct!
+        xml.soap :Envelope, 'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema', 'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/' do
+          xml.soap :Body do
+            xml.__send__(action, 'xmlns' => "http://www.ippayments.com.au/interface/api/#{endpoint(action)}") do
+              if action == 'TokeniseCreditCard'
+                xml.tokeniseCreditCardXML do
+                  inner_xml = Builder::XmlMarkup.new(indent: 2)
+                  yield(inner_xml)
+                  xml.cdata!(inner_xml.target!)
+                end
+              else
+                xml.trnXML do
+                  inner_xml = Builder::XmlMarkup.new(indent: 2)
+                  yield(inner_xml)
+                  xml.cdata!(inner_xml.target!)
+                end
+              end
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def endpoint(action)
+        action == 'TokeniseCreditCard' ? 'sipp' : 'dts'
+      end
+
+      def commit_url
+        test? ? test_url : live_url
+      end
+
+      def success_from(response)
+        response[:response_code] == '0' || response[:return_value] == '0'
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response[:declined_code]]
+      end
+
+      def message_from(response)
+        success_from(response) ? 'Succeeded' : response[:declined_message]
+      end
+
+      def authorization_from(response)
+        response[:receipt] || response[:token]
+      end
+    end
+  end
+end