activemerchant 1.79.2 → 1.129.0

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

@@ -7,15 +7,15 @@ module ActiveMerchant #:nodoc:
       AUTHORIZATION_EMV_SUCCESS = '8A023030'
       AUTHORIZATION_EMV_DECLINE = '8A023035'
 
-      SUCCESS_MESSAGE = "Bogus Gateway: Forced success"
-      FAILURE_MESSAGE = "Bogus Gateway: Forced failure"
-      NUMBER_ERROR_MESSAGE = "Bogus Gateway: Use CreditCard number ending in 1 for success, 2 for exception and anything else for error"
-      AMOUNT_ERROR_MESSAGE = "Bogus Gateway: Use amount ending in 00 for success, 05 for failure and anything else for exception"
-      UNSTORE_ERROR_MESSAGE = "Bogus Gateway: Use trans_id ending in 1 for success, 2 for exception and anything else for error"
-      CAPTURE_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
-      VOID_ERROR_MESSAGE = "Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success"
-      REFUND_ERROR_MESSAGE = "Bogus Gateway: Use trans_id number ending in 1 for exception, 2 for error and anything else for success"
-      CHECK_ERROR_MESSAGE = "Bogus Gateway: Use bank account number ending in 1 for success, 2 for exception and anything else for error"
+      SUCCESS_MESSAGE = 'Bogus Gateway: Forced success'
+      FAILURE_MESSAGE = 'Bogus Gateway: Forced failure'
+      NUMBER_ERROR_MESSAGE = 'Bogus Gateway: Use CreditCard number ending in 1 for success, 2 for exception and anything else for error'
+      AMOUNT_ERROR_MESSAGE = 'Bogus Gateway: Use amount ending in 00 for success, 05 for failure and anything else for exception'
+      UNSTORE_ERROR_MESSAGE = 'Bogus Gateway: Use trans_id ending in 1 for success, 2 for exception and anything else for error'
+      CAPTURE_ERROR_MESSAGE = 'Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success'
+      VOID_ERROR_MESSAGE = 'Bogus Gateway: Use authorization number ending in 1 for exception, 2 for error and anything else for success'
+      REFUND_ERROR_MESSAGE = 'Bogus Gateway: Use trans_id number ending in 1 for exception, 2 for error and anything else for success'
+      CHECK_ERROR_MESSAGE = 'Bogus Gateway: Use bank account number ending in 1 for success, 2 for exception and anything else for error'
 
       self.supported_countries = []
       self.supported_cardtypes = [:bogus]
@@ -47,9 +47,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case normalize(paysource)
         when /1$/
-          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true )
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end
@@ -61,9 +61,9 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, REFUND_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
-          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true)
         end
       end
 
@@ -73,9 +73,9 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, CAPTURE_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
-          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true)
         end
       end
 
@@ -84,18 +84,22 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, VOID_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:authorization => reference, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { authorization: reference, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
-          Response.new(true, SUCCESS_MESSAGE, {:authorization => reference}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, { authorization: reference }, test: true)
         end
       end
 
+      def verify(credit_card, options = {})
+        authorize(0, credit_card, options)
+      end
+
       def store(paysource, options = {})
         case normalize(paysource)
         when /1$/
-          Response.new(true, SUCCESS_MESSAGE, {:billingid => '1'}, :test => true, :authorization => AUTHORIZATION)
+          Response.new(true, SUCCESS_MESSAGE, { billingid: '1' }, test: true, authorization: AUTHORIZATION)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:billingid => nil, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { billingid: nil, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end
@@ -104,9 +108,9 @@ module ActiveMerchant #:nodoc:
       def unstore(reference, options = {})
         case reference
         when /1$/
-          Response.new(true, SUCCESS_MESSAGE, {}, :test => true)
+          Response.new(true, SUCCESS_MESSAGE, {}, test: true)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:error => FAILURE_MESSAGE },:test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, UNSTORE_ERROR_MESSAGE
         end
@@ -118,9 +122,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case money
         when /00$/
-          Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money}, :test => true, :authorization => AUTHORIZATION, :emv_authorization => AUTHORIZATION_EMV_SUCCESS)
+          Response.new(true, SUCCESS_MESSAGE, { authorized_amount: money }, test: true, authorization: AUTHORIZATION, emv_authorization: AUTHORIZATION_EMV_SUCCESS)
         when /05$/
-          Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error], :emv_authorization => AUTHORIZATION_EMV_DECLINE)
+          Response.new(false, FAILURE_MESSAGE, { authorized_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error], emv_authorization: AUTHORIZATION_EMV_DECLINE)
         else
           raise Error, error_message(paysource)
         end
@@ -129,10 +133,10 @@ module ActiveMerchant #:nodoc:
       def authorize_swipe(money, paysource, options = {})
         money = amount(money)
         case normalize(paysource)
-        when /1$/
-          Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money}, :test => true, :authorization => AUTHORIZATION )
+        when /1$/, AUTHORIZATION
+          Response.new(true, SUCCESS_MESSAGE, { authorized_amount: money }, test: true, authorization: AUTHORIZATION)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { authorized_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end
@@ -142,9 +146,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case money
         when /00$/
-          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true, :authorization => AUTHORIZATION, :emv_authorization => AUTHORIZATION_EMV_SUCCESS)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true, authorization: AUTHORIZATION, emv_authorization: AUTHORIZATION_EMV_SUCCESS)
         when /05$/
-          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error], :emv_authorization => AUTHORIZATION_EMV_DECLINE)
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error], emv_authorization: AUTHORIZATION_EMV_DECLINE)
         else
           raise Error, error_message(paysource)
         end
@@ -154,9 +158,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case normalize(paysource)
         when /1$/, AUTHORIZATION
-          Response.new(true, SUCCESS_MESSAGE, {:paid_amount => money}, :test => true, :authorization => AUTHORIZATION)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true, authorization: AUTHORIZATION)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {:paid_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end

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

@@ -1,43 +1,59 @@
-require "nokogiri"
+require 'nokogiri'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class BorgunGateway < Gateway
-      self.display_name = "Borgun"
+      self.display_name = 'Borgun'
       self.homepage_url = 'http://www.borgun.com'
 
       self.test_url = 'https://gatewaytest.borgun.is/ws/Heimir.pub.ws:Authorization'
       self.live_url = 'https://gateway01.borgun.is/ws/Heimir.pub.ws:Authorization'
 
-      self.supported_countries = ['IS', 'GB', 'HU', 'CZ', 'DE', 'DK', 'SE' ]
+      self.supported_countries = %w[IS GB HU CZ DE DK SE]
       self.default_currency = 'ISK'
       self.money_format = :cents
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :discover, :jcb]
+      self.supported_cardtypes = %i[visa master american_express diners_club discover jcb]
 
       self.homepage_url = 'https://www.borgun.is/'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :processor, :merchant_id, :username, :password)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
-        post[:TransType] = '1'
+        action = ''
+        if options[:apply_3d_secure] == '1'
+          add_3ds_preauth_fields(post, options)
+          action = '3ds_preauth'
+        else
+          post[:TransType] = '1'
+          add_3ds_fields(post, options)
+          action = 'sale'
+        end
         add_invoice(post, money, options)
         add_payment_method(post, payment)
-        commit('sale', post)
+        commit(action, post, options)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
-        post[:TransType] = '5'
+        action = ''
+        if options[:apply_3d_secure] == '1'
+          add_3ds_preauth_fields(post, options)
+          action = '3ds_preauth'
+        else
+          post[:TransType] = '5'
+          add_3ds_fields(post, options)
+          action = 'authonly'
+        end
         add_invoice(post, money, options)
         add_payment_method(post, payment)
-        commit('authonly', post)
+        commit(action, post, options)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         post[:TransType] = '1'
         add_invoice(post, money, options)
@@ -45,7 +61,7 @@ module ActiveMerchant #:nodoc:
         commit('capture', post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         post[:TransType] = '3'
         add_invoice(post, money, options)
@@ -53,7 +69,7 @@ module ActiveMerchant #:nodoc:
         commit('refund', post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         # TransType, TrAmount, and currency must match original values from auth or purchase.
         _, _, _, _, _, transtype, tramount, currency = split_authorization(authorization)
@@ -76,14 +92,31 @@ module ActiveMerchant #:nodoc:
 
       private
 
-      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}")}
-      CURRENCY_CODES["ISK"] = "352"
-      CURRENCY_CODES["EUR"] = "978"
-      CURRENCY_CODES["USD"] = "840"
+      CURRENCY_CODES = Hash.new { |_h, k| raise ArgumentError.new("Unsupported currency for HDFC: #{k}") }
+      CURRENCY_CODES['ISK'] = '352'
+      CURRENCY_CODES['EUR'] = '978'
+      CURRENCY_CODES['USD'] = '840'
+
+      def add_3ds_fields(post, options)
+        post[:ThreeDSMessageId] = options[:three_ds_message_id] if options[:three_ds_message_id]
+        post[:ThreeDS_PARes] = options[:three_ds_pares] if options[:three_ds_pares]
+        post[:ThreeDS_CRes] = options[:three_ds_cres] if options[:three_ds_cres]
+      end
+
+      def add_3ds_preauth_fields(post, options)
+        post[:SaleDescription] = options[:sale_description] || ''
+        post[:MerchantReturnURL] = options[:merchant_return_url] if options[:merchant_return_url]
+      end
 
       def add_invoice(post, money, options)
         post[:TrAmount] = amount(money)
         post[:TrCurrency] = CURRENCY_CODES[options[:currency] || currency(money)]
+        # The ISK currency must have a currency exponent of 2 on the 3DS request but not on the auth request
+        if post[:TrCurrency] == '352' && options[:apply_3d_secure] == '1'
+          post[:TrCurrencyExponent] = 2
+        else
+          post[:TrCurrencyExponent] = 0
+        end
         post[:TerminalID] = options[:terminal_id] || '1'
       end
 
@@ -91,28 +124,28 @@ module ActiveMerchant #:nodoc:
         post[:PAN] = payment_method.number
         post[:ExpDate] = format(payment_method.year, :two_digits) + format(payment_method.month, :two_digits)
         post[:CVC2] = payment_method.verification_value
-        post[:DateAndTime] = Time.now.strftime("%y%m%d%H%M%S")
+        post[:DateAndTime] = Time.now.strftime('%y%m%d%H%M%S')
         post[:RRN] = 'AMRCNT' + six_random_digits
       end
 
       def add_reference(post, authorization)
-        dateandtime, batch, transaction, rrn, authcode, _, _, _ = split_authorization(authorization)
+        dateandtime, _batch, transaction, rrn, authcode, = split_authorization(authorization)
         post[:DateAndTime] = dateandtime
         post[:Transaction] = transaction
         post[:RRN] = rrn
         post[:AuthCode] = authcode
       end
 
-      def parse(xml)
+      def parse(xml, options = nil)
         response = {}
 
         doc = Nokogiri::XML(CGI.unescapeHTML(xml))
-        body = doc.xpath('//getAuthorizationReply')
+        body = options[:apply_3d_secure] == '1' ? doc.xpath('//get3DSAuthenticationReply') : doc.xpath('//getAuthorizationReply')
         body = doc.xpath('//cancelAuthorizationReply') if body.length == 0
         body.children.each do |node|
           if node.text?
             next
-          elsif (node.elements.size == 0)
+          elsif node.elements.size == 0
             response[node.name.downcase.to_sym] = node.text
           else
             node.elements.each do |childnode|
@@ -121,19 +154,17 @@ module ActiveMerchant #:nodoc:
             end
           end
         end
-
         response
       end
 
-      def commit(action, post)
+      def commit(action, post, options = {})
         post[:Version] = '1000'
         post[:Processor] = @options[:processor]
         post[:MerchantID] = @options[:merchant_id]
 
-        url = (test? ? test_url : live_url)
-        request = build_request(action, post)
+        request = build_request(action, post, options)
         raw = ssl_post(url(action), request, headers)
-        pairs = parse(raw)
+        pairs = parse(raw, options)
         success = success_from(pairs)
 
         Response.new(
@@ -146,12 +177,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response)
-        (response[:actioncode] == '000')
+        (response[:actioncode] == '000') || (response[:status_resultcode] == '0')
       end
 
       def message_from(succeeded, response)
         if succeeded
-          "Succeeded"
+          'Succeeded'
         else
           response[:message] || "Error with ActionCode=#{response[:actioncode]}"
         end
@@ -167,46 +198,65 @@ module ActiveMerchant #:nodoc:
           response[:transtype],
           response[:tramount],
           response[:trcurrency]
-        ].join("|")
+        ].join('|')
       end
 
       def split_authorization(authorization)
-        dateandtime, batch, transaction, rrn, authcode, transtype, tramount, currency = authorization.split("|")
+        dateandtime, batch, transaction, rrn, authcode, transtype, tramount, currency = authorization.split('|')
         [dateandtime, batch, transaction, rrn, authcode, transtype, tramount, currency]
       end
 
       def headers
         {
-          'Authorization' => 'Basic ' + Base64.strict_encode64(@options[:username].to_s + ':' + @options[:password].to_s),
+          'Authorization' => 'Basic ' + Base64.strict_encode64(@options[:username].to_s + ':' + @options[:password].to_s)
         }
       end
 
-      def build_request(action, post)
-        mode = (action == 'void') ? 'cancel' : 'get'
-        xml = Builder::XmlMarkup.new :indent => 18
-        xml.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
-        xml.tag!("#{mode}Authorization") do
+      def build_request(action, post, options = {})
+        mode = action == 'void' ? 'cancel' : 'get'
+        transaction_type = action == '3ds_preauth' ? '3DSAuthentication' : 'Authorization'
+        xml = Builder::XmlMarkup.new indent: 18
+        xml.instruct!(:xml, version: '1.0', encoding: 'utf-8')
+        xml.tag!("#{mode}#{transaction_type}") do
           post.each do |field, value|
             xml.tag!(field, value)
           end
+          build_airline_xml(xml, options[:passenger_itinerary_data]) if options[:passenger_itinerary_data]
         end
         inner = CGI.escapeHTML(xml.target!)
-        envelope(mode).sub(/{{ :body }}/,inner)
+        envelope(mode, action).sub(/{{ :body }}/, inner)
       end
 
-      def envelope(mode)
-        <<-EOS
+      def build_airline_xml(xml, airline_data)
+        xml.tag!('PassengerItineraryData') do
+          xml.tag!('A1') do
+            airline_data.each do |field, value|
+              xml.tag!(field, value)
+            end
+          end
+        end
+      end
+
+      def envelope(mode, action)
+        if action == '3ds_preauth'
+          transaction_action = "#{mode}3DSAuthentication"
+          request_action = "#{mode}Auth3DSReqXml"
+        else
+          transaction_action = "#{mode}AuthorizationInput"
+          request_action = "#{mode}AuthReqXml"
+        end
+        <<-XML
           <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:aut="http://Borgun/Heimir/pub/ws/Authorization">
             <soapenv:Header/>
             <soapenv:Body>
-              <aut:#{mode}AuthorizationInput>
-                <#{mode}AuthReqXml>
+              <aut:#{transaction_action}>
+                <#{request_action}>
                 {{ :body }}
-                </#{mode}AuthReqXml>
-              </aut:#{mode}AuthorizationInput>
+                </#{request_action}>
+              </aut:#{transaction_action}>
             </soapenv:Body>
           </soapenv:Envelope>
-        EOS
+        XML
       end
 
       def url(action)
@@ -214,7 +264,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def six_random_digits
-        (0...6).map { (48 + rand(10)).chr }.join
+        (0...6).map { rand(48..57).chr }.join
       end
     end
   end

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

@@ -7,17 +7,17 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['AU']
       self.default_currency = 'AUD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+      self.supported_cardtypes = %i[visa master american_express diners_club]
 
       self.homepage_url = 'https://www.bpoint.com.au/bpoint'
       self.display_name = 'BPoint'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :username, :password, :merchant_number)
         super
       end
 
-      def store(credit_card, options={})
+      def store(credit_card, options = {})
         options[:crn1] ||= 'DEFAULT'
         request_body = soap_request do |xml|
           add_token(xml, credit_card, options)
@@ -25,7 +25,7 @@ module ActiveMerchant #:nodoc:
         commit(request_body)
       end
 
-      def purchase(amount, credit_card, options={})
+      def purchase(amount, credit_card, options = {})
         request_body = soap_request do |xml|
           process_payment(xml) do |payment_xml|
             add_purchase(payment_xml, amount, credit_card, options)
@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
         commit(request_body)
       end
 
-      def authorize(amount, credit_card, options={})
+      def authorize(amount, credit_card, options = {})
         request_body = soap_request do |xml|
           process_payment(xml) do |payment_xml|
             add_authorize(payment_xml, amount, credit_card, options)
@@ -43,7 +43,7 @@ module ActiveMerchant #:nodoc:
         commit(request_body)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         request_body = soap_request do |xml|
           process_payment(xml) do |payment_xml|
             add_capture(payment_xml, amount, authorization, options)
@@ -52,7 +52,7 @@ module ActiveMerchant #:nodoc:
         commit(request_body)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         request_body = soap_request do |xml|
           process_payment(xml) do |payment_xml|
             add_refund(payment_xml, amount, authorization, options)
@@ -61,19 +61,19 @@ module ActiveMerchant #:nodoc:
         commit(request_body)
       end
 
-      def void(amount, authorization, options={})
+      def void(authorization, options = {})
         request_body = soap_request do |xml|
           process_payment(xml) do |payment_xml|
-            add_void(payment_xml, amount, authorization, options)
+            add_void(payment_xml, authorization, options)
           end
         end
         commit(request_body)
       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(100, r.authorization, options) }
+          r.process(:ignore_result) { void(r.authorization, options.merge(amount: 100)) }
         end
       end
 
@@ -91,7 +91,7 @@ module ActiveMerchant #:nodoc:
       private
 
       def soap_request
-        Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |xml|
+        Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
           xml.send('soap12:Envelope', soap_envelope_attributes) {
             xml.send('soap12:Body') {
               yield(xml) if block_given?
@@ -154,7 +154,9 @@ module ActiveMerchant #:nodoc:
         transaction_number_xml(xml, transaction_number)
       end
 
-      def add_void(xml, amount, transaction_number, options)
+      def add_void(xml, transaction_number, options)
+        # The amount parameter is required for void requests on BPoint.
+        amount = options[:amount]
         payment_xml(xml, 'REVERSAL', amount, options)
         transaction_number_xml(xml, transaction_number)
       end
@@ -163,10 +165,10 @@ module ActiveMerchant #:nodoc:
         xml.send('PaymentType', payment_type)
         xml.send('TxnType', 'WEB_SHOP')
         xml.send('BillerCode', options.fetch(:biller_code, ''))
-        xml.send('MerchantReference', '')
-        xml.send('CRN1', '')
-        xml.send('CRN2', '')
-        xml.send('CRN3', '')
+        xml.send('MerchantReference', options[:order_id]) if options[:order_id]
+        xml.send('CRN1', options[:crn1]) if options[:crn1]
+        xml.send('CRN2', options[:crn2]) if options[:crn2]
+        xml.send('CRN3', options[:crn3]) if options[:crn3]
         xml.send('Amount', amount)
       end
 
@@ -185,7 +187,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def request_headers
-        { "Content-Type" => "application/soap+xml; charset=utf-8" }
+        { 'Content-Type' => 'application/soap+xml; charset=utf-8' }
       end
 
       def parse(body)
@@ -240,7 +242,6 @@ module ActiveMerchant #:nodoc:
       end
 
       class ProcessPaymentResponse < BPointResponse
-
         private
 
         def authorization_key
@@ -257,7 +258,6 @@ module ActiveMerchant #:nodoc:
       end
 
       class AddTokenResponse < BPointResponse
-
         private
 
         def authorization_key

data/lib/active_merchant/billing/gateways/braintree/braintree_common.rb

@@ -1,7 +1,7 @@
 module BraintreeCommon
   def self.included(base)
     base.supported_countries = %w(US CA AD AT BE BG HR CY CZ DK EE FI FR GI DE GR GG HU IS IM IE IT JE LV LI LT LU MT MC NL NO PL PT RO SM SK SI ES SE CH TR GB SG HK MY AU NZ)
-    base.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+    base.supported_cardtypes = %i[visa master american_express discover jcb diners_club maestro]
     base.homepage_url = 'http://www.braintreepaymentsolutions.com'
     base.display_name = 'Braintree'
     base.default_currency = 'USD'
@@ -13,10 +13,16 @@ module BraintreeCommon
   end
 
   def scrub(transcript)
-    return "" if transcript.blank?
+    return '' if transcript.blank?
+
     transcript.
       gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
       gsub(%r((&?ccnumber=)\d*(&?)), '\1[FILTERED]\2').
-      gsub(%r((&?cvv=)\d*(&?)), '\1[FILTERED]\2')
+      gsub(%r((&?cvv=)\d*(&?)), '\1[FILTERED]\2').
+      gsub(%r((<account-number>)\d+(</account-number>)), '\1[FILTERED]\2').
+      gsub(%r((<payment-method-nonce>)[^<]+(</payment-method-nonce>)), '\1[FILTERED]\2').
+      gsub(%r((<payment-method-token>)[^<]+(</payment-method-token>)), '\1[FILTERED]\2').
+      gsub(%r((<value>)[^<]{100,}(</value>)), '\1[FILTERED]\2').
+      gsub(%r((<token>)[^<]+(</token>)), '\1[FILTERED]\2')
   end
 end