activemerchant 1.56.0 → 1.66.0

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

@@ -77,12 +77,14 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'http://www.usaepay.com/'
       self.display_name = 'USA ePay Advanced SOAP Interface'
 
-      CUSTOMER_OPTIONS = {
+      CUSTOMER_PROFILE_OPTIONS = {
         :id => [:string, 'CustomerID'], # merchant assigned number
         :notes => [:string, 'Notes'],
         :data => [:string, 'CustomData'],
-        :url => [:string, 'URL'],
-        # Recurring Billing
+        :url => [:string, 'URL']
+      } #:nodoc:
+
+      CUSTOMER_RECURRING_BILLING_OPTIONS = {
         :enabled => [:boolean, 'Enabled'],
         :schedule => [:string, 'Schedule'],
         :number_left => [:integer, 'NumLeft'],
@@ -92,18 +94,24 @@ module ActiveMerchant #:nodoc:
         :user => [:string, 'User'],
         :source => [:string, 'Source'],
         :send_receipt => [:boolean, 'SendReceipt'],
-        :receipt_note => [:string, 'ReceiptNote'],
-        # Point of Sale
+        :receipt_note => [:string, 'ReceiptNote']
+      } #:nodoc:
+
+      CUSTOMER_POINT_OF_SALE_OPTIONS = {
         :price_tier => [:string, 'PriceTier'],
         :tax_class => [:string, 'TaxClass'],
         :lookup_code => [:string, 'LookupCode']
       } #:nodoc:
 
-      ADDRESS_OPTIONS = {
+      CUSTOMER_OPTIONS = [
+        CUSTOMER_PROFILE_OPTIONS,
+        CUSTOMER_RECURRING_BILLING_OPTIONS,
+        CUSTOMER_POINT_OF_SALE_OPTIONS
+      ].inject(:merge) #:nodoc:
+
+      COMMON_ADDRESS_OPTIONS = {
         :first_name => [:string, 'FirstName'],
         :last_name => [:string, 'LastName'],
-        :address1 => [:string, 'Street'],
-        :address2 => [:string, 'Street2'],
         :city => [:string, 'City'],
         :state => [:string, 'State'],
         :zip => [:string, 'Zip'],
@@ -114,6 +122,32 @@ module ActiveMerchant #:nodoc:
         :company => [:string, 'Company']
       } #:nodoc:
 
+      ADDRESS_OPTIONS = [
+        COMMON_ADDRESS_OPTIONS,
+        {
+          :address1 => [:string, 'Street'],
+          :address2 => [:string, 'Street2'],
+        }
+      ].inject(:merge) #:nodoc
+
+      CUSTOMER_UPDATE_DATA_FIELDS = [
+        CUSTOMER_PROFILE_OPTIONS,
+        CUSTOMER_RECURRING_BILLING_OPTIONS,
+        COMMON_ADDRESS_OPTIONS,
+        {
+          :address1 => [:string, 'Address'],
+          :address2 => [:string, 'Address2'],
+        },
+        {
+          :card_number => [:string, 'CardNumber'],
+          :card_exp => [:string, 'CardExp'],
+          :account => [:string, 'Account'],
+          :routing => [:string, 'Routing'],
+          :check_format => [:string, 'CheckFormat'],
+          :record_type => [:string, 'RecordType'],
+        }
+      ].inject(:merge) #:nodoc
+
       CUSTOMER_TRANSACTION_REQUEST_OPTIONS = {
         :command => [:string, 'Command'],
         :ignore_duplicate => [:boolean, 'IgnoreDuplicate'],
@@ -354,6 +388,55 @@ module ActiveMerchant #:nodoc:
         commit(__method__, request)
       end
 
+      # Update a customer by replacing only the provided fields.
+      #
+      # ==== Required
+      # * <tt>:customer_number</tt> -- customer to update
+      # * <tt>:update_data</tt> -- FieldValue array of fields to retrieve
+      #   * <tt>:first_name</tt>
+      #   * <tt>:last_name</tt>
+      #   * <tt>:id</tt>
+      #   * <tt>:company</tt>
+      #   * <tt>:address</tt>
+      #   * <tt>:address2</tt>
+      #   * <tt>:city</tt>
+      #   * <tt>:state</tt>
+      #   * <tt>:zip</tt>
+      #   * <tt>:country</tt>
+      #   * <tt>:phone</tt>
+      #   * <tt>:fax</tt>
+      #   * <tt>:email</tt>
+      #   * <tt>:url</tt>
+      #   * <tt>:receipt_note</tt>
+      #   * <tt>:send_receipt</tt>
+      #   * <tt>:notes</tt>
+      #   * <tt>:description</tt>
+      #   * <tt>:order_id</tt>
+      #   * <tt>:enabled</tt>
+      #   * <tt>:schedule</tt>
+      #   * <tt>:next</tt>
+      #   * <tt>:num_left</tt>
+      #   * <tt>:amount</tt>
+      #   * <tt>:custom_data</tt>
+      #   * <tt>:source</tt>
+      #   * <tt>:user</tt>
+      #   * <tt>:card_number</tt>
+      #   * <tt>:card_exp</tt>
+      #   * <tt>:account</tt>
+      #   * <tt>:routing</tt>
+      #   * <tt>:check_format</tt> or <tt>:record_type</tt>
+      #
+      # ==== Response
+      # * <tt>#message</tt> -- boolean; Returns true if successful. Exception thrown all failures.
+      #
+      def quick_update_customer(options={})
+        requires! options, :customer_number
+        requires! options, :update_data
+
+        request = build_request(__method__, options)
+        commit(__method__, request)
+      end
+
       # Enable a customer for recurring billing.
       #
       # Note: Customer does not need to have all recurring parameters to succeed.
@@ -1019,6 +1102,14 @@ module ActiveMerchant #:nodoc:
         build_customer(soap, options, 'deleteCustomer')
       end
 
+      def build_quick_update_customer(soap, options)
+        soap.tag! "ns1:quickUpdateCustomer" do
+          build_token soap, options
+          build_tag soap, :integer, 'CustNum', options[:customer_number]
+          build_field_value_array soap, "UpdateData", "FieldValue", options[:update_data], CUSTOMER_UPDATE_DATA_FIELDS
+        end
+      end
+
       def build_add_customer_payment_method(soap, options)
         soap.tag! "ns1:addCustomerPaymentMethod" do
           build_token soap, options
@@ -1408,6 +1499,21 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def build_field_value_array(soap, tag_name, type, custom_data, fields)
+        soap.tag! tag_name, 'SOAP-ENC:arryType' => "xsd:#{type}[#{options.length}]", 'xsi:type' => "ns1:#{type}Array" do
+          custom_data.each do |k, v|
+            build_field_value soap, fields[k][1], v, fields[k][0] if fields.keys.include? k
+          end
+        end
+      end
+
+      def build_field_value(soap, field, value, value_type)
+        soap.FieldValue 'xsi:type' => 'ns1:FieldValue' do
+          build_tag soap, :string, 'Field', field
+          build_tag soap, value_type, 'Value', value
+        end
+      end
+
       def build_line_items(soap, options) # TODO
       end
 
@@ -1511,4 +1617,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -5,8 +5,8 @@ module ActiveMerchant
     class VancoGateway < Gateway
       include Empty
 
-      self.test_url = 'https://www.vancodev.com/cgi-bin/wstest2.vps'
-      self.live_url = 'https://www.vancoservices.com/cgi-bin/ws2.vps'
+      self.test_url = 'https://uat.vancopayments.com/cgi-bin/ws2.vps'
+      self.live_url = 'https://myvanco.vancopayments.com/cgi-bin/ws2.vps'
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
@@ -22,15 +22,15 @@ module ActiveMerchant
 
       def purchase(money, payment_method, options={})
         MultiResponse.run do |r|
-          r.process { commit(login_request) }
-          r.process { commit(purchase_request(money, payment_method, r.params["response_sessionid"], options)) }
+          r.process { login }
+          r.process { commit(purchase_request(money, payment_method, r.params["response_sessionid"], options), :response_transactionref) }
         end
       end
 
       def refund(money, authorization, options={})
         MultiResponse.run do |r|
-          r.process { commit(login_request) }
-          r.process { commit(refund_request(money, authorization, r.params["response_sessionid"])) }
+          r.process { login }
+          r.process { commit(refund_request(money, authorization, r.params["response_sessionid"]), :response_creditrequestreceived) }
         end
       end
 
@@ -89,10 +89,10 @@ module ActiveMerchant
         end
       end
 
-      def commit(request)
+      def commit(request, success_field_name)
         response = parse(ssl_post(url, request, headers))
+        succeeded = success_from(response, success_field_name)
 
-        succeeded = success_from(response)
         Response.new(
           succeeded,
           message_from(succeeded, response),
@@ -102,8 +102,8 @@ module ActiveMerchant
         )
       end
 
-      def success_from(response)
-        !response[:response_errors]
+      def success_from(response, success_field_name)
+        !empty?(response[success_field_name])
       end
 
       def message_from(succeeded, response)
@@ -252,6 +252,10 @@ module ActiveMerchant
         doc.ClientID(@options[:client_id])
       end
 
+      def login
+        commit(login_request, :response_sessionid)
+      end
+
       def login_request
         build_xml_request do |doc|
           doc.Auth do

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

@@ -0,0 +1,209 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VisanetPeruGateway < Gateway
+      include Empty
+      self.display_name = "VisaNet Peru Gateway"
+      self.homepage_url = "http://www.visanet.com.pe"
+
+      self.test_url = "https://devapi.vnforapps.com/api.tokenization/api/v2/merchant"
+      self.live_url = "https://api.vnforapps.com/api.tokenization/api/v2/merchant"
+
+      self.supported_countries = ["US", "PE"]
+      self.default_currency = "PEN"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :access_key_id, :secret_access_key, :merchant_id)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run() do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        params = {}
+
+        add_invoice(params, amount, options)
+        add_payment_method(params, payment_method)
+        add_antifraud_data(params, options)
+        params[:email] = options[:email] || 'unknown@email.com'
+        params[:createAlias] = false
+
+        commit("authorize", params)
+      end
+
+      def capture(authorization, options={})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit("deposit", params)
+      end
+
+      def void(authorization, options={})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit("void", params)
+      end
+
+      def refund(amount, authorization, options={})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit("cancelDeposit", params)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((\"cardNumber\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv2Code\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
+      CURRENCY_CODES["USD"] = 840
+      CURRENCY_CODES["PEN"] = 604
+
+      def add_invoice(params, money, options)
+        # Visanet Peru expects a 9-digit numeric purchaseNumber
+        params[:purchaseNumber] = (SecureRandom.random_number(900_000_000) + 100_000_000).to_s
+        params[:externalTransactionId] = options[:order_id]
+        params[:amount] = amount(money)
+        params[:currencyId] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_auth_order_id(params, authorization, options)
+        params[:purchaseNumber] = authorization
+        params[:externalTransactionId] = options[:order_id]
+      end
+
+      def add_payment_method(params, payment_method)
+        params[:firstName] = payment_method.first_name
+        params[:lastName] = payment_method.last_name
+        params[:cardNumber] = payment_method.number
+        params[:cvv2Code] = payment_method.verification_value
+        params[:expirationYear] = format(payment_method.year, :four_digits)
+        params[:expirationMonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_antifraud_data(params, options)
+        antifraud = {}
+
+        if billing_address = options[:billing_address] || options[:address]
+          antifraud[:billTo_street1] = billing_address[:address1]
+          antifraud[:billTo_city] = billing_address[:city]
+          antifraud[:billTo_state] = billing_address[:state]
+          antifraud[:billTo_country] = billing_address[:country]
+          antifraud[:billTo_postalCode] = billing_address[:zip]
+        end
+
+        antifraud[:deviceFingerprintId] = options[:device_fingerprint_id] || SecureRandom.hex(16)
+        antifraud[:merchantDefineData] = options[:merchant_define_data] if options[:merchant_define_data]
+
+        params[:antifraud] = antifraud
+      end
+
+      def commit(action, params)
+        begin
+          raw_response = ssl_request(method(action), url(action, params), params.to_json, headers)
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response_error(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          Response.new(
+            success_from(response),
+            message_from(response),
+            response,
+            :test => test?,
+            :authorization => authorization_from(params),
+            :error_code => response["errorCode"]
+          )
+        end
+      end
+
+      def headers
+        {
+          "Authorization" => "Basic " + Base64.strict_encode64("#{@options[:access_key_id]}:#{@options[:secret_access_key]}").strip,
+          "Content-Type"  => "application/json"
+        }
+      end
+
+      def url(action, params)
+        if (action == "authorize")
+          "#{base_url}/#{@options[:merchant_id]}"
+        else
+          "#{base_url}/#{@options[:merchant_id]}/#{action}/#{params[:purchaseNumber]}"
+        end
+      end
+
+      def method(action)
+        (action == "authorize") ? :post : :put
+      end
+
+      def authorization_from(params)
+        params[:purchaseNumber]
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response["errorCode"] == 0
+      end
+
+      def message_from(response)
+        if empty?(response["errorMessage"]) || response["errorMessage"] == "[ ]"
+          response["data"]["DSC_COD_ACCION"]
+        else
+          response["errorMessage"]
+        end
+      end
+
+      def response_error(raw_response)
+        begin
+          response = parse(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          return Response.new(
+            false,
+            message_from(response),
+            response,
+            :test => test?,
+            :authorization => response["transactionUUID"],
+            :error_code => response["errorCode"]
+          )
+        end
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from VisanetPeruGateway. Please contact VisanetPeruGateway if you continue to receive this message."
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end

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

@@ -10,6 +10,8 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'USD'
       self.display_name = 'WePay'
 
+      API_VERSION = "2017-02-01"
+
       def initialize(options = {})
         requires!(options, :client_id, :account_id, :access_token)
         super(options)
@@ -18,38 +20,47 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment_method, options = {})
         post = {}
         if payment_method.is_a?(String)
-          purchase_with_token(post, money, payment_method, options)
+          MultiResponse.run do |r|
+            r.process { authorize_with_token(post, money, payment_method, options) }
+            r.process { capture(money, r.authorization, options) }
+          end
         else
           MultiResponse.run do |r|
             r.process { store(payment_method, options) }
-            r.process { purchase_with_token(post, money, split_authorization(r.authorization).first, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
+            r.process { capture(money, r.authorization, options) }
           end
         end
       end
 
       def authorize(money, payment_method, options = {})
-        post = {auto_capture: 0}
+        post = {}
         if payment_method.is_a?(String)
-          purchase_with_token(post, money, payment_method, options)
+          authorize_with_token(post, money, payment_method, options)
         else
           MultiResponse.run do |r|
             r.process { store(payment_method, options) }
-            r.process { purchase_with_token(post, money, split_authorization(r.authorization).first, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
           end
         end
       end
 
       def capture(money, identifier, options = {})
+        checkout_id, original_amount = split_authorization(identifier)
+
         post = {}
-        post[:checkout_id] = split_authorization(identifier).first
-        commit('/checkout/capture', post)
+        post[:checkout_id] = checkout_id
+        if(money && (original_amount != amount(money)))
+          post[:amount] = amount(money)
+        end
+        commit('/checkout/capture', post, options)
       end
 
       def void(identifier, options = {})
         post = {}
         post[:checkout_id] = split_authorization(identifier).first
         post[:cancel_reason] = (options[:description] || "Void")
-        commit('/checkout/cancel', post)
+        commit('/checkout/cancel', post, options)
       end
 
       def refund(money, identifier, options = {})
@@ -61,10 +72,9 @@ module ActiveMerchant #:nodoc:
           post[:amount] = amount(money)
         end
         post[:refund_reason] = (options[:description] || "Refund")
-        post[:app_fee] = options[:application_fee] if options[:application_fee]
         post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
         post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
-        commit("/checkout/refund", post)
+        commit("/checkout/refund", post, options)
       end
 
       def store(creditcard, options = {})
@@ -76,53 +86,58 @@ module ActiveMerchant #:nodoc:
         post[:email] = options[:email] || "unspecified@example.com"
         post[:cc_number] = creditcard.number
         post[:cvv] = creditcard.verification_value unless options[:recurring]
-        post[:expiration_month] = "#{creditcard.month}"
-        post[:expiration_year] = "#{creditcard.year}"
+        post[:expiration_month] = creditcard.month
+        post[:expiration_year] = creditcard.year
         post[:original_ip] = options[:ip] if options[:ip]
         post[:original_device] = options[:device_fingerprint] if options[:device_fingerprint]
+
         if(billing_address = (options[:billing_address] || options[:address]))
-          post[:address] = {
-            "address1" => billing_address[:address1],
-            "city"     => billing_address[:city],
-            "country"  => billing_address[:country]
-          }
-          if(post[:country] == "US")
-            post[:address]["zip"] = billing_address[:zip]
-            post[:address]["state"] = billing_address[:state]
-          else
-            post[:address]["region"] = billing_address[:state]
-            post[:address]["postcode"] = billing_address[:zip]
-          end
+          post[:address] = {}
+          post[:address]["address1"] = billing_address[:address1] if billing_address[:address1]
+          post[:address]["city"]     = billing_address[:city] if billing_address[:city]
+          post[:address]["country"]  = billing_address[:country]  if billing_address[:country]
+          post[:address]["region"]   = billing_address[:state]  if billing_address[:state]
+          post[:address]["postal_code"] = billing_address[:zip]
         end
 
         if options[:recurring] == true
           post[:client_secret] = @options[:client_secret]
-          commit('/credit_card/transfer', post)
+          commit('/credit_card/transfer', post, options)
         else
-          commit('/credit_card/create', post)
+          commit('/credit_card/create', post, options)
         end
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((\\?"cc_number\\?":\\?")[^\\"]+(\\?"))i, '\1[FILTERED]\2').
+          gsub(%r((\\?"cvv\\?":\\?")[^\\"]+(\\?"))i, '\1[FILTERED]\2').
+          gsub(%r((Authorization: Bearer )\w+)i, '\1[FILTERED]\2')
+      end
+
       private
 
-      def purchase_with_token(post, money, token, options)
+      def authorize_with_token(post, money, token, options)
         add_token(post, token)
         add_product_data(post, money, options)
-        commit('/checkout/create', post)
+        commit('/checkout/create', post, options)
       end
 
       def add_product_data(post, money, options)
         post[:account_id] = @options[:account_id]
         post[:amount] = amount(money)
         post[:short_description] = (options[:description] || "Purchase")
-        post[:type] = (options[:type] || "GOODS")
+        post[:type] = (options[:type] || "goods")
         post[:currency] = (options[:currency] || currency(money))
         post[:long_description] = options[:long_description] if options[:long_description]
         post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
         post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
         post[:reference_id] = options[:order_id] if options[:order_id]
-        post[:app_fee] = options[:application_fee] if options[:application_fee]
-        post[:fee_payer] = options[:fee_payer] if options[:fee_payer]
+        post[:unique_id] = options[:unique_id] if options[:unique_id]
         post[:redirect_uri] = options[:redirect_uri] if options[:redirect_uri]
         post[:callback_uri] = options[:callback_uri] if options[:callback_uri]
         post[:fallback_uri] = options[:fallback_uri] if options[:fallback_uri]
@@ -133,11 +148,26 @@ module ActiveMerchant #:nodoc:
         post[:preapproval_id] = options[:preapproval_id] if options[:preapproval_id]
         post[:prefill_info] = options[:prefill_info] if options[:prefill_info]
         post[:funding_sources] = options[:funding_sources] if options[:funding_sources]
+        add_fee(post, options)
       end
 
       def add_token(post, token)
-        post[:payment_method_id]   = token
-        post[:payment_method_type] = "credit_card"
+        payment_method = {}
+        payment_method[:type] = "credit_card"
+        payment_method[:credit_card] = {
+          id: token,
+          auto_capture: false
+        }
+
+        post[:payment_method] = payment_method
+      end
+
+      def add_fee(post, options)
+        if options[:application_fee] || options[:fee_payer]
+          post[:fee] = {}
+          post[:fee][:app_fee] = options[:application_fee] if options[:application_fee]
+          post[:fee][:fee_payer] = options[:fee_payer] if options[:fee_payer]
+        end
       end
 
       def parse(response)
@@ -149,7 +179,7 @@ module ActiveMerchant #:nodoc:
           response = parse(ssl_post(
             ((test? ? test_url : live_url) + action),
             params.to_json,
-            headers
+            headers(options)
           ))
         rescue ResponseError => e
           response = parse(e.response.body)
@@ -178,7 +208,8 @@ module ActiveMerchant #:nodoc:
       def authorization_from(response, params)
         return response["credit_card_id"].to_s if response["credit_card_id"]
 
-        [response["checkout_id"], params[:amount]].join('|')
+        original_amount = response["amount"].nil? ? nil : sprintf("%0.02f", response["amount"])
+        [response["checkout_id"], original_amount].join('|')
       end
 
       def split_authorization(authorization)
@@ -192,14 +223,18 @@ module ActiveMerchant #:nodoc:
         return Response.new(false, message)
       end
 
-      def headers
+      def headers(options)
         {
           "Content-Type"  => "application/json",
           "User-Agent"    => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-          "Authorization" => "Bearer #{@options[:access_token]}"
+          "Authorization" => "Bearer #{@options[:access_token]}",
+          "Api-Version"   => api_version(options)
         }
       end
+
+      def api_version(options)
+        options[:version] || API_VERSION
+      end
     end
   end
 end
-

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

@@ -239,6 +239,7 @@ module ActiveMerchant #:nodoc:
             when :reversal
               xml.tag! 'GuWID', options[:preauthorization]
             end
+            add_customer_data(xml, options)
           end
         end
       end