activemerchant 1.113.0 → 1.119.0

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

@@ -42,13 +42,13 @@ module ActiveMerchant #:nodoc:
         97 => STANDARD_ERROR_CODE[:processing_error]
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :api_key)
         super
         @options[:preauth_mode] ||= false
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         raise ArgumentError, 'Purchase is not supported on Decidir gateways configured with the preauth_mode option' if @options[:preauth_mode]
 
         post = {}
@@ -56,7 +56,7 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'payments', post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         raise ArgumentError, 'Authorize is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
 
         post = {}
@@ -64,7 +64,7 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'payments', post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         raise ArgumentError, 'Capture is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
 
         post = {}
@@ -72,18 +72,18 @@ module ActiveMerchant #:nodoc:
         commit(:put, "payments/#{authorization}", post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         add_amount(post, money, options)
         commit(:post, "payments/#{authorization}/refunds", post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         commit(:post, "payments/#{authorization}/refunds", post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         raise ArgumentError, 'Verify is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
 
         MultiResponse.run(:use_first_response) do |r|
@@ -170,6 +170,12 @@ module ActiveMerchant #:nodoc:
         card_data[:security_code] = credit_card.verification_value if credit_card.verification_value?
         card_data[:card_holder_name] = credit_card.name if credit_card.name
 
+        # the device_unique_id has to be sent in via the card data (as device_unique_identifier) no other fraud detection fields require this
+        if options[:fraud_detection].present?
+          card_data[:fraud_detection] = {} if (options[:fraud_detection][:device_unique_id]).present?
+          card_data[:fraud_detection][:device_unique_identifier] = (options[:fraud_detection][:device_unique_id]) if (options[:fraud_detection][:device_unique_id]).present?
+        end
+
         # additional data used for Visa transactions
         card_data[:card_holder_door_number] = options[:card_holder_door_number].to_i if options[:card_holder_door_number]
         card_data[:card_holder_birthday] = options[:card_holder_birthday] if options[:card_holder_birthday]
@@ -209,6 +215,15 @@ module ActiveMerchant #:nodoc:
           hsh[:send_to_cs] = options[:send_to_cs] if valid_fraud_detection_option?(options[:send_to_cs]) # true/false
           hsh[:channel] = options[:channel] if valid_fraud_detection_option?(options[:channel])
           hsh[:dispatch_method] = options[:dispatch_method] if valid_fraud_detection_option?(options[:dispatch_method])
+          hsh[:csmdds] = options[:csmdds] if valid_fraud_detection_option?(options[:csmdds])
+          hsh[:device_unique_id] = options[:device_unique_id] if valid_fraud_detection_option?(options[:device_unique_id])
+          hsh[:bill_to] = options[:bill_to] if valid_fraud_detection_option?(options[:bill_to])
+          hsh[:purchase_totals] = options[:purchase_totals] if valid_fraud_detection_option?(options[:purchase_totals])
+          hsh[:customer_in_site] = options[:customer_in_site] if valid_fraud_detection_option?(options[:customer_in_site])
+          hsh[:retail_transaction_data] = options[:retail_transaction_data] if valid_fraud_detection_option?(options[:retail_transaction_data])
+          hsh[:ship_to] = options[:ship_to] if valid_fraud_detection_option?(options[:ship_to])
+          hsh[:tax_voucher_required] = options[:tax_voucher_required] if valid_fraud_detection_option?(options[:tax_voucher_required])
+          hsh[:copy_paste_card_data] = options[:copy_paste_card_data] if valid_fraud_detection_option?(options[:copy_paste_card_data])
         end
       end
 
@@ -225,7 +240,7 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def commit(method, endpoint, parameters, options={})
+      def commit(method, endpoint, parameters, options = {})
         url = "#{(test? ? test_url : live_url)}/#{endpoint}"
 
         begin
@@ -286,15 +301,21 @@ module ActiveMerchant #:nodoc:
         error_code = nil
         if error = response.dig('status_details', 'error')
           code = error.dig('reason', 'id')
-          error_code = STANDARD_ERROR_CODE_MAPPING[code]
+          standard_error_code = STANDARD_ERROR_CODE_MAPPING[code]
+          error_code = "#{code}, #{standard_error_code}"
           error_code ||= error['type']
         elsif response['error_type']
           error_code = response['error_type'] if response['validation_errors']
-        elsif error = response.dig('error')
+        elsif response.dig('error', 'validation_errors')
+          error = response.dig('error')
           validation_errors = error.dig('validation_errors', 0)
           code = validation_errors['code'] if validation_errors && validation_errors['code']
           param = validation_errors['param'] if validation_errors && validation_errors['param']
           error_code = "#{error['error_type']} | #{code} | #{param}" if error['error_type']
+        elsif error = response.dig('error')
+          code = error.dig('reason', 'id')
+          standard_error_code = STANDARD_ERROR_CODE_MAPPING[code]
+          error_code = "#{code}, #{standard_error_code}"
         end
 
         error_code || STANDARD_ERROR_CODE[:processing_error]

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

@@ -11,19 +11,19 @@ module ActiveMerchant #:nodoc:
       self.money_format = :cents
       self.supported_cardtypes = %i[visa master american_express discover]
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :merchant_id, :secret_key)
         super
       end
 
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         MultiResponse.run(false) do |r|
           r.process { authorize(amount, payment_method, options) }
           r.process { capture(amount, r.authorization, options) }
         end
       end
 
-      def authorize(amount, payment_method, options={})
+      def authorize(amount, payment_method, options = {})
         post = {}
         add_amount(post, amount)
         add_invoice(post, amount, options)
@@ -36,7 +36,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         post = {}
         add_amount(post, amount)
         add_reference(post, authorization)
@@ -44,14 +44,14 @@ module ActiveMerchant #:nodoc:
         commit(:capture, post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_reference(post, authorization)
 
         commit(:void, post)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         post = {}
         add_amount(post, amount)
         add_reference(post, authorization)
@@ -59,7 +59,7 @@ module ActiveMerchant #:nodoc:
         commit(:refund, post)
       end
 
-      def verify(credit_card, options={})
+      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) }
@@ -87,7 +87,7 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      CURRENCY_CODES = Hash.new { |h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
+      CURRENCY_CODES = Hash.new { |_h, k| raise ArgumentError.new("Unsupported currency: #{k}") }
       CURRENCY_CODES['USD'] = '840'
       CURRENCY_CODES['DKK'] = '208'
       CURRENCY_CODES['NOK'] = '578'

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

@@ -14,19 +14,19 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://digitzs.com'
       self.display_name = 'Digitzs'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :app_key, :api_key)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         MultiResponse.run do |r|
           r.process { commit('auth/token', app_token_request(options)) }
           r.process { commit('payments', purchase_request(money, payment, options), options.merge({ app_token: app_token_from(r) })) }
         end
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         MultiResponse.run do |r|
           r.process { commit('auth/token', app_token_request(options)) }
           r.process { commit('payments', refund_request(money, authorization, options), options.merge({ app_token: app_token_from(r) })) }
@@ -151,7 +151,7 @@ module ActiveMerchant #:nodoc:
         post[:data][:type] = 'payments'
         post[:data][:attributes][:merchantId] = options[:merchant_id]
         post[:data][:attributes][:paymentType] = 'cardRefund'
-        post[:data][:attributes][:originalTransaction] = {id: authorization}
+        post[:data][:attributes][:originalTransaction] = { id: authorization }
         add_transaction(post, money, options)
 
         post
@@ -206,7 +206,7 @@ module ActiveMerchant #:nodoc:
         JSON.parse(body)
       end
 
-      def commit(action, parameters, options={})
+      def commit(action, parameters, options = {})
         url = (test? ? test_url : live_url)
         response = parse(ssl_post(url + "/#{action}", parameters.to_json, headers(options)))
 

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

@@ -46,12 +46,12 @@ module ActiveMerchant #:nodoc:
         'cl' => 5000
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :integration_key)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = { payment: {} }
         add_integration_key(post)
         add_operation(post)
@@ -65,7 +65,7 @@ module ActiveMerchant #:nodoc:
         commit(:purchase, post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = { payment: {} }
         add_integration_key(post)
         add_operation(post)
@@ -80,7 +80,7 @@ module ActiveMerchant #:nodoc:
         commit(:authorize, post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         add_integration_key(post)
         post[:hash] = authorization
@@ -89,7 +89,7 @@ module ActiveMerchant #:nodoc:
         commit(:capture, post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         add_integration_key(post)
         add_operation(post)
@@ -100,7 +100,7 @@ module ActiveMerchant #:nodoc:
         commit(:refund, post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_integration_key(post)
         add_authorization(post, authorization)
@@ -108,7 +108,7 @@ module ActiveMerchant #:nodoc:
         commit(:void, post)
       end
 
-      def store(credit_card, options={})
+      def store(credit_card, options = {})
         post = {}
         add_integration_key(post)
         add_payment_details(post, credit_card)
@@ -117,7 +117,7 @@ module ActiveMerchant #:nodoc:
         commit(:store, post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(VERIFY_AMOUNT_PER_COUNTRY[customer_country(options)], credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -222,7 +222,7 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, parameters)
         url = url_for((test? ? test_url : live_url), action, parameters)
-        response = parse(ssl_request(HTTP_METHOD[action], url, post_data(action, parameters), {'x-ebanx-client-user-agent': "ActiveMerchant/#{ActiveMerchant::VERSION}"}))
+        response = parse(ssl_request(HTTP_METHOD[action], url, post_data(action, parameters), { 'x-ebanx-client-user-agent': "ActiveMerchant/#{ActiveMerchant::VERSION}" }))
 
         success = success_from(action, response)
 

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

@@ -54,7 +54,7 @@ module ActiveMerchant #:nodoc:
       def void(identification, options = {})
         requires!(options, :order_id)
         original_transaction_id, = identification.split(';')
-        commit(:void_transaction, {reference_number: format_reference_number(options[:order_id]), transaction_id: original_transaction_id})
+        commit(:void_transaction, { reference_number: format_reference_number(options[:order_id]), transaction_id: original_transaction_id })
       end
 
       def voice_authorize(money, authorization_code, creditcard, options = {})
@@ -149,8 +149,7 @@ module ActiveMerchant #:nodoc:
           test: test?,
           authorization: authorization_from(response, parameters),
           avs_result: { code: response[:avs_response_code] },
-          cvv_result: response[:cvv_response_code]
-        )
+          cvv_result: response[:cvv_response_code])
       end
 
       def success?(response)

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

@@ -1,4 +1,5 @@
 require 'active_merchant/billing/gateways/viaklix'
+require 'nokogiri'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -7,13 +8,15 @@ module ActiveMerchant #:nodoc:
 
       class_attribute :test_url, :live_url, :delimiter, :actions
 
-      self.test_url = 'https://api.demo.convergepay.com/VirtualMerchantDemo/process.do'
-      self.live_url = 'https://api.convergepay.com/VirtualMerchant/process.do'
+      self.test_url = 'https://api.demo.convergepay.com/VirtualMerchantDemo/processxml.do'
+      self.live_url = 'https://api.convergepay.com/VirtualMerchant/processxml.do'
 
       self.display_name = 'Elavon MyVirtualMerchant'
       self.supported_countries = %w(US CA PR DE IE NO PL LU BE NL MX)
       self.supported_cardtypes = %i[visa master american_express discover]
       self.homepage_url = 'http://www.elavon.com/'
+      self.money_format = :dollars
+      self.default_currency = 'USD'
 
       self.delimiter = "\n"
       self.actions = {
@@ -35,115 +38,143 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, payment_method, options = {})
-        form = {}
-        add_salestax(form, options)
-        add_invoice(form, options)
-        if payment_method.is_a?(String)
-          add_token(form, payment_method)
-        else
-          add_creditcard(form, payment_method)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:purchase]
+          xml.ssl_amount            amount(money)
+
+          if payment_method.is_a?(String)
+            add_token(xml, payment_method)
+          else
+            add_creditcard(xml, payment_method)
+          end
+
+          add_invoice(xml, options)
+          add_salestax(xml, options)
+          add_currency(xml, money, options)
+          add_address(xml, options)
+          add_customer_email(xml, options)
+          add_test_mode(xml, options)
+          add_ip(xml, options)
+          add_auth_purchase_params(xml, options)
+          add_level_3_fields(xml, options) if options[:level_3_data]
         end
-        add_currency(form, money, options)
-        add_address(form, options)
-        add_customer_data(form, options)
-        add_test_mode(form, options)
-        add_ip(form, options)
-        add_auth_purchase_params(form, options)
-        add_level_3_fields(form, options) if options[:level_3_data]
-        commit(:purchase, money, form, options)
+        commit(request)
       end
 
       def authorize(money, creditcard, options = {})
-        form = {}
-        add_salestax(form, options)
-        add_invoice(form, options)
-        add_creditcard(form, creditcard)
-        add_currency(form, money, options)
-        add_address(form, options)
-        add_customer_data(form, options)
-        add_test_mode(form, options)
-        add_ip(form, options)
-        add_auth_purchase_params(form, options)
-        add_level_3_fields(form, options) if options[:level_3_data]
-        commit(:authorize, money, form, options)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:authorize]
+          xml.ssl_amount            amount(money)
+
+          add_salestax(xml, options)
+          add_invoice(xml, options)
+          add_creditcard(xml, creditcard)
+          add_currency(xml, money, options)
+          add_address(xml, options)
+          add_customer_email(xml, options)
+          add_test_mode(xml, options)
+          add_ip(xml, options)
+          add_auth_purchase_params(xml, options)
+          add_level_3_fields(xml, options) if options[:level_3_data]
+        end
+        commit(request)
       end
 
       def capture(money, authorization, options = {})
-        form = {}
-        if options[:credit_card]
-          action = :capture
-          add_salestax(form, options)
-          add_approval_code(form, authorization)
-          add_invoice(form, options)
-          add_creditcard(form, options[:credit_card])
-          add_currency(form, money, options)
-          add_address(form, options)
-          add_customer_data(form, options)
-          add_test_mode(form, options)
-        else
-          action = :capture_complete
-          add_txn_id(form, authorization)
-          add_partial_shipment_flag(form, options)
-          add_test_mode(form, options)
+        request = build_xml_request do |xml|
+          if options[:credit_card]
+            xml.ssl_transaction_type self.actions[:capture]
+            xml.ssl_amount amount(money)
+            add_salestax(xml, options)
+            add_approval_code(xml, authorization)
+            add_invoice(xml, options)
+            add_creditcard(xml, options[:credit_card])
+            add_currency(xml, money, options)
+            add_address(xml, options)
+            add_customer_email(xml, options)
+            add_test_mode(xml, options)
+          else
+            xml.ssl_transaction_type self.actions[:capture_complete]
+            xml.ssl_amount amount(money)
+            add_currency(xml, money, options)
+            add_txn_id(xml, authorization)
+            add_partial_shipment_flag(xml, options)
+            add_test_mode(xml, options)
+          end
         end
-        commit(action, money, form, options)
+        commit(request)
       end
 
       def refund(money, identification, options = {})
-        form = {}
-        add_txn_id(form, identification)
-        add_test_mode(form, options)
-        commit(:refund, money, form, options)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:refund]
+          xml.ssl_amount            amount(money)
+          add_txn_id(xml, identification)
+          add_test_mode(xml, options)
+        end
+        commit(request)
       end
 
       def void(identification, options = {})
-        form = {}
-        add_txn_id(form, identification)
-        add_test_mode(form, options)
-        commit(:void, nil, form, options)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:void]
+
+          add_txn_id(xml, identification)
+          add_test_mode(xml, options)
+        end
+        commit(request)
       end
 
       def credit(money, creditcard, options = {})
         raise ArgumentError, 'Reference credits are not supported. Please supply the original credit card or use the #refund method.' if creditcard.is_a?(String)
 
-        form = {}
-        add_invoice(form, options)
-        add_creditcard(form, creditcard)
-        add_currency(form, money, options)
-        add_address(form, options)
-        add_customer_data(form, options)
-        add_test_mode(form, options)
-        commit(:credit, money, form, options)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:credit]
+          xml.ssl_amount            amount(money)
+          add_invoice(xml, options)
+          add_creditcard(xml, creditcard)
+          add_currency(xml, money, options)
+          add_address(xml, options)
+          add_customer_email(xml, options)
+          add_test_mode(xml, options)
+        end
+        commit(request)
       end
 
       def verify(credit_card, options = {})
-        form = {}
-        add_creditcard(form, credit_card)
-        add_address(form, options)
-        add_test_mode(form, options)
-        add_ip(form, options)
-        commit(:verify, 0, form, options)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:verify]
+          add_creditcard(xml, credit_card)
+          add_address(xml, options)
+          add_test_mode(xml, options)
+          add_ip(xml, options)
+        end
+        commit(request)
       end
 
       def store(creditcard, options = {})
-        form = {}
-        add_creditcard(form, creditcard)
-        add_address(form, options)
-        add_customer_data(form, options)
-        add_test_mode(form, options)
-        add_verification(form, options)
-        form[:add_token] = 'Y'
-        commit(:store, nil, form, options)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:store]
+          xml.ssl_add_token 'Y'
+          add_creditcard(xml, creditcard)
+          add_address(xml, options)
+          add_customer_email(xml, options)
+          add_test_mode(xml, options)
+          add_verification(xml, options)
+        end
+        commit(request)
       end
 
       def update(token, creditcard, options = {})
-        form = {}
-        add_token(form, token)
-        add_creditcard(form, creditcard)
-        add_address(form, options)
-        add_customer_data(form, options)
-        add_test_mode(form, options)
-        commit(:update, nil, form, options)
+        request = build_xml_request do |xml|
+          xml.ssl_transaction_type  self.actions[:update]
+          add_token(xml, token)
+          add_creditcard(xml, creditcard)
+          add_address(xml, options)
+          add_customer_email(xml, options)
+          add_test_mode(xml, options)
+        end
+        commit(request)
       end
 
       def supports_scrubbing?
@@ -152,217 +183,247 @@ module ActiveMerchant #:nodoc:
 
       def scrub(transcript)
         transcript.
-          gsub(%r((&?ssl_pin=)[^&]*)i, '\1[FILTERED]').
-          gsub(%r((&?ssl_card_number=)[^&\\n\r\n]*)i, '\1[FILTERED]').
-          gsub(%r((&?ssl_cvv2cvc2=)[^&]*)i, '\1[FILTERED]')
+          gsub(%r((<ssl_pin>)(.*)(</ssl_pin>)), '\1[FILTERED]\3').
+          gsub(%r((<ssl_card_number>)(.*)(</ssl_card_number>)), '\1[FILTERED]\3').
+          gsub(%r((<ssl_cvv2cvc2>)(.*)(</ssl_cvv2cvc2>)), '\1[FILTERED]\3')
       end
 
       private
 
-      def add_invoice(form, options)
-        form[:invoice_number] = truncate((options[:order_id] || options[:invoice]), 10)
-        form[:description] = truncate(options[:description], 255)
+      def add_invoice(xml, options)
+        xml.ssl_invoice_number    truncate((options[:order_id] || options[:invoice]), 25)
+        xml.ssl_description       truncate(options[:description], 255)
       end
 
-      def add_approval_code(form, authorization)
-        form[:approval_code] = authorization.split(';').first
+      def add_approval_code(xml, authorization)
+        xml.ssl_approval_code authorization.split(';').first
       end
 
-      def add_txn_id(form, authorization)
-        form[:txn_id] = authorization.split(';').last
-      end
-
-      def authorization_from(response)
-        [response['approval_code'], response['txn_id']].join(';')
+      def add_txn_id(xml, authorization)
+        xml.ssl_txn_id authorization.split(';').last
       end
 
-      def add_creditcard(form, creditcard)
-        form[:card_number] = creditcard.number
-        form[:exp_date] = expdate(creditcard)
+      def add_creditcard(xml, creditcard)
+        xml.ssl_card_number   creditcard.number
+        xml.ssl_exp_date      expdate(creditcard)
 
-        add_verification_value(form, creditcard) if creditcard.verification_value?
+        add_verification_value(xml, creditcard) if creditcard.verification_value?
 
-        form[:first_name] = truncate(creditcard.first_name, 20)
-        form[:last_name] = truncate(creditcard.last_name, 30)
+        xml.ssl_first_name    truncate(creditcard.first_name, 20)
+        xml.ssl_last_name     truncate(creditcard.last_name, 30)
       end
 
-      def add_currency(form, money, options)
+      def add_currency(xml, money, options)
         currency = options[:currency] || currency(money)
-        form[:transaction_currency] = currency if currency && (@options[:multi_currency] || options[:multi_currency])
+        return unless currency && (@options[:multi_currency] || options[:multi_currency])
+
+        xml.ssl_transaction_currency currency
       end
 
-      def add_token(form, token)
-        form[:token] = token
+      def add_token(xml, token)
+        xml.ssl_token token
       end
 
-      def add_verification_value(form, creditcard)
-        form[:cvv2cvc2] = creditcard.verification_value
-        form[:cvv2cvc2_indicator] = '1'
+      def add_verification_value(xml, creditcard)
+        xml.ssl_cvv2cvc2            creditcard.verification_value
+        xml.ssl_cvv2cvc2_indicator  1
       end
 
-      def add_customer_data(form, options)
-        form[:email] = truncate(options[:email], 100) unless empty?(options[:email])
-        form[:customer_code] = truncate(options[:customer], 10) unless empty?(options[:customer])
-        form[:customer_number] = options[:customer_number] unless empty?(options[:customer_number])
-        options[:custom_fields]&.each do |key, value|
-          form[key.to_s] = value
-        end
+      def add_customer_email(xml, options)
+        xml.ssl_email truncate(options[:email], 100) unless empty?(options[:email])
       end
 
-      def add_salestax(form, options)
-        form[:salestax] = options[:tax] if options[:tax].present?
+      def add_salestax(xml, options)
+        return unless options[:tax].present?
+
+        xml.ssl_salestax options[:tax]
       end
 
-      def add_address(form, options)
+      def add_address(xml, options)
         billing_address = options[:billing_address] || options[:address]
 
         if billing_address
-          form[:avs_address]    = truncate(billing_address[:address1], 30)
-          form[:address2]       = truncate(billing_address[:address2], 30)
-          form[:avs_zip]        = truncate(billing_address[:zip].to_s.gsub(/[^a-zA-Z0-9]/, ''), 9)
-          form[:city]           = truncate(billing_address[:city], 30)
-          form[:state]          = truncate(billing_address[:state], 10)
-          form[:company]        = truncate(billing_address[:company], 50)
-          form[:phone]          = truncate(billing_address[:phone], 20)
-          form[:country]        = truncate(billing_address[:country], 50)
+          xml.ssl_avs_address     truncate(billing_address[:address1], 30)
+          xml.ssl_address2        truncate(billing_address[:address2], 30)
+          xml.ssl_avs_zip         truncate(billing_address[:zip].to_s.gsub(/[^a-zA-Z0-9]/, ''), 9)
+          xml.ssl_city            truncate(billing_address[:city], 30)
+          xml.ssl_state           truncate(billing_address[:state], 10)
+          xml.ssl_company         truncate(billing_address[:company], 50)
+          xml.ssl_phone           truncate(billing_address[:phone], 20)
+          xml.ssl_country         truncate(billing_address[:country], 50)
         end
 
         if shipping_address = options[:shipping_address]
-          first_name, last_name = split_names(shipping_address[:name])
-          form[:ship_to_first_name]     = truncate(first_name, 20)
-          form[:ship_to_last_name]      = truncate(last_name, 30)
-          form[:ship_to_address1]       = truncate(shipping_address[:address1], 30)
-          form[:ship_to_address2]       = truncate(shipping_address[:address2], 30)
-          form[:ship_to_city]           = truncate(shipping_address[:city], 30)
-          form[:ship_to_state]          = truncate(shipping_address[:state], 10)
-          form[:ship_to_company]        = truncate(shipping_address[:company], 50)
-          form[:ship_to_country]        = truncate(shipping_address[:country], 50)
-          form[:ship_to_zip]            = truncate(shipping_address[:zip], 10)
+          xml.ssl_ship_to_address1    truncate(shipping_address[:address1], 30)
+          xml.ssl_ship_to_address2    truncate(shipping_address[:address2], 30)
+          xml.ssl_ship_to_city        truncate(shipping_address[:city], 30)
+          xml.ssl_ship_to_company     truncate(shipping_address[:company], 50)
+          xml.ssl_ship_to_country     truncate(shipping_address[:country], 50)
+          xml.ssl_ship_to_first_name  truncate(shipping_address[:first_name], 20)
+          xml.ssl_ship_to_last_name   truncate(shipping_address[:last_name], 30)
+          xml.ssl_ship_to_phone       truncate(shipping_address[:phone], 10)
+          xml.ssl_ship_to_state       truncate(shipping_address[:state], 2)
+          xml.ssl_ship_to_zip         truncate(shipping_address[:zip], 10)
         end
       end
 
-      def add_verification(form, options)
-        form[:verify] = 'Y' if options[:verify]
+      def add_verification(xml, options)
+        xml.ssl_verify 'Y' if options[:verify]
+      end
+
+      def add_test_mode(xml, options)
+        xml.ssl_test_mode 'TRUE' if options[:test_mode]
       end
 
-      def add_test_mode(form, options)
-        form[:test_mode] = 'TRUE' if options[:test_mode]
+      def add_partial_shipment_flag(xml, options)
+        xml.ssl_partial_shipment_flag 'Y' if options[:partial_shipment_flag]
       end
 
-      def add_partial_shipment_flag(form, options)
-        form[:partial_shipment_flag] = 'Y' if options[:partial_shipment_flag]
+      def add_ip(xml, options)
+        xml.ssl_cardholder_ip options[:ip] if options.has_key?(:ip)
       end
 
-      def add_ip(form, options)
-        form[:cardholder_ip] = options[:ip] if options.has_key?(:ip)
+      def add_auth_purchase_params(xml, options)
+        xml.ssl_dynamic_dba                     options[:dba] if options.has_key?(:dba)
+        xml.ssl_merchant_initiated_unscheduled  merchant_initiated_unscheduled(options) if merchant_initiated_unscheduled(options)
+        xml.ssl_customer_code                   options[:customer] if options.has_key?(:customer)
+        xml.ssl_customer_number                 options[:customer_number] if options.has_key?(:customer_number)
+        xml.ssl_entry_mode                      entry_mode(options) if entry_mode(options)
+        add_custom_fields(xml, options) if options[:custom_fields]
+        add_stored_credential(xml, options) if options[:stored_credential]
       end
 
-      def add_auth_purchase_params(form, options)
-        form[:dynamic_dba] = options[:dba] if options.has_key?(:dba)
-        form[:merchant_initiated_unscheduled] = options[:merchant_initiated_unscheduled] if options.has_key?(:merchant_initiated_unscheduled)
+      def add_custom_fields(xml, options)
+        options[:custom_fields]&.each do |key, value|
+          xml.send(key.to_sym, value)
+        end
       end
 
-      def add_level_3_fields(form, options)
+      def add_level_3_fields(xml, options)
         level_3_data = options[:level_3_data]
-        form[:customer_code] = level_3_data[:customer_code] if level_3_data[:customer_code]
-        form[:salestax] = level_3_data[:salestax] if level_3_data[:salestax]
-        form[:salestax_indicator] = level_3_data[:salestax_indicator] if level_3_data[:salestax_indicator]
-        form[:level3_indicator] = level_3_data[:level3_indicator] if level_3_data[:level3_indicator]
-        form[:ship_to_zip] = level_3_data[:ship_to_zip] if level_3_data[:ship_to_zip]
-        form[:ship_to_country] = level_3_data[:ship_to_country] if level_3_data[:ship_to_country]
-        form[:shipping_amount] = level_3_data[:shipping_amount] if level_3_data[:shipping_amount]
-        form[:ship_from_postal_code] = level_3_data[:ship_from_postal_code] if level_3_data[:ship_from_postal_code]
-        form[:discount_amount] = level_3_data[:discount_amount] if level_3_data[:discount_amount]
-        form[:duty_amount] = level_3_data[:duty_amount] if level_3_data[:duty_amount]
-        form[:national_tax_indicator] = level_3_data[:national_tax_indicator] if level_3_data[:national_tax_indicator]
-        form[:national_tax_amount] = level_3_data[:national_tax_amount] if level_3_data[:national_tax_amount]
-        form[:order_date] = level_3_data[:order_date] if level_3_data[:order_date]
-        form[:other_tax] = level_3_data[:other_tax] if level_3_data[:other_tax]
-        form[:summary_commodity_code] = level_3_data[:summary_commodity_code] if level_3_data[:summary_commodity_code]
-        form[:merchant_vat_number] = level_3_data[:merchant_vat_number] if level_3_data[:merchant_vat_number]
-        form[:customer_vat_number] = level_3_data[:customer_vat_number] if level_3_data[:customer_vat_number]
-        form[:freight_tax_amount] = level_3_data[:freight_tax_amount] if level_3_data[:freight_tax_amount]
-        form[:vat_invoice_number] = level_3_data[:vat_invoice_number] if level_3_data[:vat_invoice_number]
-        form[:tracking_number] = level_3_data[:tracking_number] if level_3_data[:tracking_number]
-        form[:shipping_company] = level_3_data[:shipping_company] if level_3_data[:shipping_company]
-        form[:other_fees] = level_3_data[:other_fees] if level_3_data[:other_fees]
-        add_line_items(form, level_3_data) if level_3_data[:line_items]
-      end
-
-      def add_line_items(form, level_3_data)
-        items = []
-        level_3_data[:line_items].each do |line_item|
-          item = {}
-          line_item.each do |key, value|
-            prefixed_key = "ssl_line_Item_#{key}"
-            item[prefixed_key.to_sym] = value
+        xml.ssl_customer_code           level_3_data[:customer_code] if level_3_data[:customer_code]
+        xml.ssl_salestax                level_3_data[:salestax] if level_3_data[:salestax]
+        xml.ssl_salestax_indicator      level_3_data[:salestax_indicator] if level_3_data[:salestax_indicator]
+        xml.ssl_level3_indicator        level_3_data[:level3_indicator] if level_3_data[:level3_indicator]
+        xml.ssl_ship_to_zip             level_3_data[:ship_to_zip] if level_3_data[:ship_to_zip]
+        xml.ssl_ship_to_country         level_3_data[:ship_to_country] if level_3_data[:ship_to_country]
+        xml.ssl_shipping_amount         level_3_data[:shipping_amount] if level_3_data[:shipping_amount]
+        xml.ssl_ship_from_postal_code   level_3_data[:ship_from_postal_code] if level_3_data[:ship_from_postal_code]
+        xml.ssl_discount_amount         level_3_data[:discount_amount] if level_3_data[:discount_amount]
+        xml.ssl_duty_amount             level_3_data[:duty_amount] if level_3_data[:duty_amount]
+        xml.ssl_national_tax_indicator  level_3_data[:national_tax_indicator] if level_3_data[:national_tax_indicator]
+        xml.ssl_national_tax_amount     level_3_data[:national_tax_amount] if level_3_data[:national_tax_amount]
+        xml.ssl_order_date              level_3_data[:order_date] if level_3_data[:order_date]
+        xml.ssl_other_tax               level_3_data[:other_tax] if level_3_data[:other_tax]
+        xml.ssl_summary_commodity_code  level_3_data[:summary_commodity_code] if level_3_data[:summary_commodity_code]
+        xml.ssl_merchant_vat_number     level_3_data[:merchant_vat_number] if level_3_data[:merchant_vat_number]
+        xml.ssl_customer_vat_number     level_3_data[:customer_vat_number] if level_3_data[:customer_vat_number]
+        xml.ssl_freight_tax_amount      level_3_data[:freight_tax_amount] if level_3_data[:freight_tax_amount]
+        xml.ssl_vat_invoice_number      level_3_data[:vat_invoice_number] if level_3_data[:vat_invoice_number]
+        xml.ssl_tracking_number         level_3_data[:tracking_number] if level_3_data[:tracking_number]
+        xml.ssl_shipping_company        level_3_data[:shipping_company] if level_3_data[:shipping_company]
+        xml.ssl_other_fees              level_3_data[:other_fees] if level_3_data[:other_fees]
+        add_line_items(xml, level_3_data) if level_3_data[:line_items]
+      end
+
+      def add_line_items(xml, level_3_data)
+        xml.LineItemProducts {
+          level_3_data[:line_items].each do |line_item|
+            xml.product {
+              line_item.each do |key, value|
+                prefixed_key = "ssl_line_Item_#{key}"
+                xml.send(prefixed_key, value)
+              end
+            }
           end
-          items << item
+        }
+      end
+
+      def add_stored_credential(xml, options)
+        network_transaction_id = options.dig(:stored_credential, :network_transaction_id)
+        case
+        when network_transaction_id.nil?
+          return
+        when network_transaction_id.to_s.include?('|')
+          oar_data, ps2000_data = options[:stored_credential][:network_transaction_id].split('|')
+          xml.ssl_oar_data oar_data unless oar_data.nil? || oar_data.empty?
+          xml.ssl_ps2000_data ps2000_data unless ps2000_data.nil? || ps2000_data.empty?
+        when network_transaction_id.to_s.length > 22
+          xml.ssl_oar_data options.dig(:stored_credential, :network_transaction_id)
+        else
+          xml.ssl_ps2000_data options.dig(:stored_credential, :network_transaction_id)
         end
-        form[:LineItemProducts] = { product: items }
       end
 
-      def message_from(response)
-        success?(response) ? response['result_message'] : response['errorMessage']
+      def merchant_initiated_unscheduled(options)
+        return options[:merchant_initiated_unscheduled] if options[:merchant_initiated_unscheduled]
+        return 'Y' if options.dig(:stored_credential, :initiator) == 'merchant' && options.dig(:stored_credential, :reason_type) == 'unscheduled'
       end
 
-      def success?(response)
-        !response.has_key?('errorMessage')
+      def entry_mode(options)
+        return options[:entry_mode] if options[:entry_mode]
+        return 12 if options[:stored_credential]
       end
 
-      def commit(action, money, parameters, options)
-        parameters[:amount] = amount(money)
-        parameters[:transaction_type] = self.actions[action]
+      def build_xml_request
+        builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+          xml.txn do
+            xml.ssl_merchant_id       @options[:login]
+            xml.ssl_user_id           @options[:user]
+            xml.ssl_pin               @options[:password]
+            yield(xml)
+          end
+        end
+
+        builder.to_xml.gsub("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n", '')
+      end
 
-        response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(parameters, options)))
+      def commit(request)
+        request = "xmldata=#{request}".delete('&')
 
-        Response.new(response['result'] == '0', message_from(response), response,
+        response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
+
+        Response.new(
+          response[:result] == '0',
+          response[:result_message] || response[:errorMessage],
+          response,
           test: @options[:test] || test?,
           authorization: authorization_from(response),
-          avs_result: { code: response['avs_response'] },
-          cvv_result: response['cvv2_response']
+          error_code: response[:errorCode],
+          avs_result: { code: response[:avs_response] },
+          cvv_result: response[:cvv2_response],
+          network_transaction_id: build_network_transaction_id(response)
         )
       end
 
-      def post_data(parameters, options)
-        result = preamble
-        result.merge!(parameters)
-        result.collect { |key, value| post_data_string(key, value, options) }.join('&')
+      def build_network_transaction_id(response)
+        "#{response[:oar_data]}|#{response[:ps2000_data]}"
       end
 
-      def post_data_string(key, value, options)
-        if custom_field?(key, options) || key == :LineItemProducts
-          "#{key}=#{CGI.escape(value.to_s)}"
-        else
-          "ssl_#{key}=#{CGI.escape(value.to_s)}"
-        end
+      def headers
+        {
+          'Accept' => 'application/xml',
+          'Content-type' => 'application/x-www-form-urlencoded'
+        }
       end
 
-      def custom_field?(field_name, options)
-        return true if options[:custom_fields]&.include?(field_name.to_sym)
+      def parse(body)
+        xml = Nokogiri::XML(body)
+        response = Hash.from_xml(xml.to_s)['txn']
 
-        field_name == :customer_number
+        response.deep_transform_keys { |key| key.gsub('ssl_', '').to_sym }
       end
 
-      def preamble
-        result = {
-          'merchant_id'   => @options[:login],
-          'pin'           => @options[:password],
-          'show_form'     => 'false',
-          'result_format' => 'ASCII'
-        }
-
-        result['user_id'] = @options[:user] unless empty?(@options[:user])
-        result
+      def authorization_from(response)
+        [response[:approval_code], response[:txn_id]].join(';')
       end
 
-      def parse(msg)
-        resp = {}
-        msg.split(self.delimiter).collect { |li|
-          key, value = li.split('=')
-          resp[key.to_s.strip.gsub(/^ssl_/, '')] = value.to_s.strip
-        }
-        resp
+      def truncate(value, size)
+        return nil unless value
+
+        difference = value.force_encoding('iso-8859-1').length - value.length
+
+        return value.to_s[0, (size - difference)]
       end
     end
   end