activemerchant 1.24.0 → 1.25.0

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

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'LitleOnline'
 
 module ActiveMerchant #:nodoc:

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

@@ -0,0 +1,323 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # For more information on the Metrics Global Payment Gateway, visit the {Metrics Global website}[www.metricsglobal.com].
+    # Further documentation on AVS and CVV response codes are available under the support section of the Metrics Global
+    # control panel.
+    #
+    # === Metrics Global Payment Gateway Authentication
+    #
+    # The login and password for the gateway are the same as the username and password used to log in to the Metrics Global
+    # control panel. Contact Metrics Global support to receive credentials for the control panel.
+    #
+    # === Demo Account
+    #
+    # There is a public demo account available with the following credentials:
+    #
+    # Login: demo
+    # Password: password
+    class MetricsGlobalGateway < Gateway
+      API_VERSION = '3.1'
+
+      class_attribute :test_url, :live_url
+
+      self.test_url = "https://secure.metricsglobalgateway.com/gateway/transact.dll?testing=true"
+      self.live_url = "https://secure.metricsglobalgateway.com/gateway/transact.dll"
+
+      class_attribute :duplicate_window
+
+      APPROVED, DECLINED, ERROR, FRAUD_REVIEW = 1, 2, 3, 4
+
+      RESPONSE_CODE, RESPONSE_REASON_CODE, RESPONSE_REASON_TEXT = 0, 2, 3
+      AVS_RESULT_CODE, TRANSACTION_ID, CARD_CODE_RESPONSE_CODE  = 5, 6, 38
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+      self.homepage_url = 'http://www.metricsglobal.com'
+      self.display_name = 'Metrics Global'
+
+      CARD_CODE_ERRORS = %w( N S )
+      AVS_ERRORS = %w( A E N R W Z )
+      AVS_REASON_CODES = %w(27 45)
+
+      # Creates a new MetricsGlobalGateway
+      #
+      # The gateway requires that a valid login and password be passed
+      # in the +options+ hash.
+      #
+      # ==== Options
+      #
+      # * <tt>:login</tt> -- The username required to access the Metrics Global control panel. (REQUIRED)
+      # * <tt>:password</tt> -- The password required to access the Metrics Global control panel. (REQUIRED)
+      # * <tt>:test</tt> -- +true+ or +false+. If true, perform transactions against the test server. 
+      #   Otherwise, perform transactions against the production server.
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+
+      # Performs an authorization, which reserves the funds on the customer's credit card, but does not
+      # charge the card.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt> -- The amount to be authorized as an Integer value in cents.
+      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
+      # * <tt>options</tt> -- A hash of optional parameters.
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_duplicate_window(post)
+
+        commit('AUTH_ONLY', money, post)
+      end
+
+      # Perform a purchase, which is essentially an authorization and capture in a single operation.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt> -- The amount to be purchased as an Integer value in cents.
+      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
+      # * <tt>options</tt> -- A hash of optional parameters.
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_duplicate_window(post)
+
+        commit('AUTH_CAPTURE', money, post)
+      end
+
+      # Captures the funds from an authorized transaction.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt> -- The amount to be captured as an Integer value in cents.
+      # * <tt>authorization</tt> -- The authorization returned from the previous authorize request.
+      def capture(money, authorization, options = {})
+        post = {:trans_id => authorization}
+        add_customer_data(post, options)
+        commit('PRIOR_AUTH_CAPTURE', money, post)
+      end
+
+      # Void a previous transaction
+      #
+      # ==== Parameters
+      #
+      # * <tt>authorization</tt> - The authorization returned from the previous authorize request.
+      def void(authorization, options = {})
+        post = {:trans_id => authorization}
+        add_duplicate_window(post)
+        commit('VOID', nil, post)
+      end
+
+      # Refund a transaction.
+      #
+      # This transaction indicates to the gateway that
+      # money should flow from the merchant to the customer.
+      #
+      # ==== Parameters
+      #
+      # * <tt>money</tt> -- The amount to be credited to the customer as an Integer value in cents.
+      # * <tt>identification</tt> -- The ID of the original transaction against which the refund is being issued.
+      # * <tt>options</tt> -- A hash of parameters.
+      #
+      # ==== Options
+      #
+      # * <tt>:card_number</tt> -- The credit card number the refund is being issued to. (REQUIRED)
+      # * <tt>:first_name</tt> -- The first name of the account being refunded.
+      # * <tt>:last_name</tt> -- The last name of the account being refunded.
+      # * <tt>:zip</tt> -- The postal code of the account being refunded.
+      def refund(money, identification, options = {})
+        requires!(options, :card_number)
+
+        post = { :trans_id => identification,
+                 :card_num => options[:card_number]
+               }
+
+        post[:first_name] = options[:first_name] if options[:first_name]
+        post[:last_name] = options[:last_name] if options[:last_name]
+        post[:zip] = options[:zip] if options[:zip]
+
+        add_invoice(post, options)
+        add_duplicate_window(post)
+
+        commit('CREDIT', money, post)
+      end
+
+      def credit(money, identification, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, identification, options)
+      end
+
+      private
+      
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money) unless action == 'VOID'
+
+        # Only activate the test_request when the :test option is passed in
+        parameters[:test_request] = @options[:test] ? 'TRUE' : 'FALSE'
+
+        url = test? ? self.test_url : self.live_url
+        data = ssl_post url, post_data(action, parameters)
+
+        response = parse(data)
+
+        message = message_from(response)
+
+        # Return the response. The authorization can be taken out of the transaction_id
+        # Test Mode on/off is something we have to parse from the response text.
+        # It usually looks something like this
+        #
+        #   (TESTMODE) Successful Sale
+        test_mode = test? || message =~ /TESTMODE/
+
+        Response.new(success?(response), message, response, 
+          :test => test_mode, 
+          :authorization => response[:transaction_id],
+          :fraud_review => fraud_review?(response),
+          :avs_result => { :code => response[:avs_result_code] },
+          :cvv_result => response[:card_code]
+        )
+      end
+
+      def success?(response)
+        response[:response_code] == APPROVED
+      end
+
+      def fraud_review?(response)
+        response[:response_code] == FRAUD_REVIEW
+      end
+
+      def parse(body)
+        fields = split(body)
+
+        results = {
+          :response_code => fields[RESPONSE_CODE].to_i,
+          :response_reason_code => fields[RESPONSE_REASON_CODE], 
+          :response_reason_text => fields[RESPONSE_REASON_TEXT],
+          :avs_result_code => fields[AVS_RESULT_CODE],
+          :transaction_id => fields[TRANSACTION_ID],
+          :card_code => fields[CARD_CODE_RESPONSE_CODE]
+        }
+        results
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+
+        post[:version]        = API_VERSION
+        post[:login]          = @options[:login]
+        post[:tran_key]       = @options[:password]
+        post[:relay_response] = "FALSE"
+        post[:type]           = action
+        post[:delim_data]     = "TRUE"
+        post[:delim_char]     = ","
+        post[:encap_char]     = "$"
+        post[:solution_ID]    = application_id if application_id.present? && application_id != "ActiveMerchant"
+
+        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+
+      def add_invoice(post, options)
+        post[:invoice_num] = options[:order_id]
+        post[:description] = options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:card_num]   = creditcard.number
+        post[:card_code]  = creditcard.verification_value if creditcard.verification_value?
+        post[:exp_date]   = expdate(creditcard)
+        post[:first_name] = creditcard.first_name
+        post[:last_name]  = creditcard.last_name
+      end
+
+      def add_customer_data(post, options)
+        if options.has_key? :email
+          post[:email] = options[:email]
+          post[:email_customer] = false
+        end
+
+        if options.has_key? :customer
+          post[:cust_id] = options[:customer]
+        end
+
+        if options.has_key? :ip
+          post[:customer_ip] = options[:ip]
+        end
+      end
+      
+      # x_duplicate_window won't be sent by default, because sending it changes the response.
+      # "If this field is present in the request with or without a value, an enhanced duplicate transaction response will be sent."
+      def add_duplicate_window(post)
+        unless duplicate_window.nil?
+          post[:duplicate_window] = duplicate_window
+        end
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:address] = address[:address1].to_s
+          post[:company] = address[:company].to_s
+          post[:phone]   = address[:phone].to_s
+          post[:zip]     = address[:zip].to_s
+          post[:city]    = address[:city].to_s
+          post[:country] = address[:country].to_s
+          post[:state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+        
+        if address = options[:shipping_address]
+          post[:ship_to_first_name] = address[:first_name].to_s
+          post[:ship_to_last_name] = address[:last_name].to_s
+          post[:ship_to_address] = address[:address1].to_s
+          post[:ship_to_company] = address[:company].to_s
+          post[:ship_to_phone]   = address[:phone].to_s
+          post[:ship_to_zip]     = address[:zip].to_s
+          post[:ship_to_city]    = address[:city].to_s
+          post[:ship_to_country] = address[:country].to_s
+          post[:ship_to_state]   = address[:state].blank?  ? 'n/a' : address[:state]
+        end
+      end
+
+      # Make a ruby type out of the response string
+      def normalize(field)
+        case field
+        when "true"   then true
+        when "false"  then false
+        when ""       then nil
+        when "null"   then nil
+        else field
+        end
+      end
+
+      def message_from(results)  
+        if results[:response_code] == DECLINED
+          return CVVResult.messages[ results[:card_code] ] if CARD_CODE_ERRORS.include?(results[:card_code])
+          if AVS_REASON_CODES.include?(results[:response_reason_code]) && AVS_ERRORS.include?(results[:avs_result_code])
+            return AVSResult.messages[ results[:avs_result_code] ] 
+          end
+        end
+
+        (results[:response_reason_text] ? results[:response_reason_text].chomp('.') : '')
+      end
+
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+
+      def split(response)
+        response[1..-2].split(/\$,\$/)
+      end
+
+    end
+  end
+end

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

@@ -152,7 +152,6 @@ module ActiveMerchant #:nodoc:
         if address = options[:billing_address] || options[:address]
           add_avs_details(xml, address)
           xml.tag! :AVSname, creditcard.name
-          xml.tag! :AVScountryCode, address[:country]
         end
       end
 
@@ -175,14 +174,18 @@ module ActiveMerchant #:nodoc:
       end
       
       def add_avs_details(xml, address)
-        return unless AVS_SUPPORTED_COUNTRIES.include?(address[:country].to_s)
-
-        xml.tag! :AVSzip, address[:zip]
-        xml.tag! :AVSaddress1, address[:address1]
-        xml.tag! :AVSaddress2, address[:address2]
-        xml.tag! :AVScity, address[:city]
-        xml.tag! :AVSstate, address[:state]
-        xml.tag! :AVSphoneNum, address[:phone] ? address[:phone].scan(/\d/).join.to_s : nil
+        if AVS_SUPPORTED_COUNTRIES.include?(address[:country].to_s)
+          xml.tag! :AVSzip, address[:zip]
+          xml.tag! :AVSaddress1, address[:address1]
+          xml.tag! :AVSaddress2, address[:address2]
+          xml.tag! :AVScity, address[:city]
+          xml.tag! :AVSstate, address[:state]
+          xml.tag! :AVSphoneNum, address[:phone] ? address[:phone].scan(/\d/).join.to_s : nil
+          country_code = address[:country]
+        else
+          country_code = ''
+        end
+        xml.tag! :AVScountryCode, country_code
       end
 
 

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

@@ -133,6 +133,7 @@ module ActiveMerchant #:nodoc:
 
       def add_invoice(post, options)
         post[:invoice] = options[:order_id]
+        post[:description] = options[:description]
       end
 
       def add_credit_card(post, credit_card)
@@ -167,12 +168,11 @@ module ActiveMerchant #:nodoc:
         }.delete_if{|k, v| v.nil?}
       end
 
-
       def commit(action, parameters)
         response = parse( ssl_post(URL, post_data(action, parameters)) )
 
         Response.new(response[:status] == 'Approved', message_from(response), response,
-          :test => @options[:test] || test?,
+          :test => test?,
           :authorization => response[:ref_num],
           :cvv_result => response[:cvv2_result_code],
           :avs_result => { :code => response[:avs_result_code] }
@@ -192,10 +192,14 @@ module ActiveMerchant #:nodoc:
         parameters[:command]  = TRANSACTIONS[action]
         parameters[:key] = @options[:login]
         parameters[:software] = 'Active Merchant'
-        parameters[:testmode] = @options[:test] ? 1 : 0
+        parameters[:testmode] = (@options[:test] ? 1 : 0)
 
         parameters.collect { |key, value| "UM#{key}=#{CGI.escape(value.to_s)}" }.join("&")
       end
+
+      def test?
+        @options[:test] || super
+      end
     end
   end
 end

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

@@ -5,7 +5,7 @@ module ActiveMerchant #:nodoc:
     class WirecardGateway < Gateway
       # Test server location
       TEST_URL = 'https://c3-test.wirecard.com/secure/ssl-gateway'
-     
+
       # Live server location
       LIVE_URL = 'https://c3.wirecard.com/secure/ssl-gateway'
 
@@ -13,24 +13,23 @@ module ActiveMerchant #:nodoc:
       # It's just specified here for completeness.
       ENVELOPE_NAMESPACES = {
         'xmlns:xsi' => 'http://www.w3.org/1999/XMLSchema-instance',
-				'xsi:noNamespaceSchemaLocation' => 'wirecard.xsd'
-			}
+        'xsi:noNamespaceSchemaLocation' => 'wirecard.xsd'
+      }
 
-			PERMITTED_TRANSACTIONS = %w[ AUTHORIZATION CAPTURE_AUTHORIZATION PURCHASE ]
+      PERMITTED_TRANSACTIONS = %w[ AUTHORIZATION CAPTURE_AUTHORIZATION PURCHASE ]
 
       RETURN_CODES = %w[ ACK NOK ]
 
-      # Wirecard only allows phone numbers with a format like this: +xxx(yyy)zzz-zzzz-ppp, where: 
-      #   xxx = Country code 
-      #   yyy = Area or city code 
-      #   zzz-zzzz = Local number 
-      #   ppp = PBX extension 
-      # For example, a typical U.S. or Canadian number would be "+1(202)555-1234-739" indicating PBX extension 739 at phone 
+      # Wirecard only allows phone numbers with a format like this: +xxx(yyy)zzz-zzzz-ppp, where:
+      #   xxx = Country code
+      #   yyy = Area or city code
+      #   zzz-zzzz = Local number
+      #   ppp = PBX extension
+      # For example, a typical U.S. or Canadian number would be "+1(202)555-1234-739" indicating PBX extension 739 at phone
       # number 5551234 within area code 202 (country code 1).
       VALID_PHONE_FORMAT = /\+\d{1,3}(\(?\d{3}\)?)?\d{3}-\d{4}-\d{3}/
-      
+
       # The countries the gateway supports merchants from as 2 digit ISO country codes
-      # TODO: Check supported countries
       self.supported_countries = ['DE']
 
       # Wirecard supports all major credit and debit cards:
@@ -69,35 +68,28 @@ module ActiveMerchant #:nodoc:
 
       # Authorization
       def authorize(money, creditcard, options = {})
-        prepare_options_hash(options)
-        @options[:credit_card] = creditcard
-        request = build_request(:authorization, money, @options)
-        commit(request)
+        options[:credit_card] = creditcard
+        commit(:authorization, money, options)
       end
 
-
       # Capture Authorization
       def capture(money, authorization, options = {})
-        prepare_options_hash(options)
-        @options[:authorization] = authorization
-        request = build_request(:capture_authorization, money, @options)
-        commit(request)
+        options[:authorization] = authorization
+        commit(:capture_authorization, money, options)
       end
 
-
       # Purchase
       def purchase(money, creditcard, options = {})
-        prepare_options_hash(options)
-        @options[:credit_card] = creditcard
-        request = build_request(:purchase, money, @options)
-        commit(request)
+        options[:credit_card] = creditcard
+        commit(:purchase, money, options)
       end
 
-    private
+      private
 
       def prepare_options_hash(options)
-        @options.update(options)
-        setup_address_hash!(options)
+        result = @options.merge(options)
+        setup_address_hash!(result)
+        result
       end
 
       # Create all address hash key value pairs so that
@@ -111,15 +103,17 @@ module ActiveMerchant #:nodoc:
 
       # Contact WireCard, make the XML request, and parse the
       # reply into a Response object
-      def commit(request)
-	      headers = { 'Content-Type' => 'text/xml',
-	                  'Authorization' => encoded_credentials }
+      def commit(action, money, options)
+        request = build_request(action, money, options)
+
+        headers = { 'Content-Type' => 'text/xml',
+                    'Authorization' => encoded_credentials }
 
-	      response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, request, headers))
+        response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, request, headers))
         # Pending Status also means Acknowledged (as stated in their specification)
-	      success = response[:FunctionResult] == "ACK" || response[:FunctionResult] == "PENDING"
-	      message = response[:Message]
-        authorization = (success && @options[:action] == :authorization) ? response[:GuWID] : nil
+        success = response[:FunctionResult] == "ACK" || response[:FunctionResult] == "PENDING"
+        message = response[:Message]
+        authorization = (success && action == :authorization) ? response[:GuWID] : nil
 
         Response.new(success, message, response,
           :test => test?,
@@ -127,52 +121,55 @@ module ActiveMerchant #:nodoc:
           :avs_result => { :code => response[:avsCode] },
           :cvv_result => response[:cvCode]
         )
+      rescue ResponseError => e
+        if e.response.code == "401"
+          return Response.new(false, "Invalid Login")
+        else
+          raise
+        end
       end
 
       # Generates the complete xml-message, that gets sent to the gateway
-      def build_request(action, money, options = {})
-				xml = Builder::XmlMarkup.new :indent => 2
-				xml.instruct!
-				xml.tag! 'WIRECARD_BXML' do
-				  xml.tag! 'W_REQUEST' do
+      def build_request(action, money, options)
+        options = prepare_options_hash(options)
+        options[:action] = action
+        xml = Builder::XmlMarkup.new :indent => 2
+        xml.instruct!
+        xml.tag! 'WIRECARD_BXML' do
+          xml.tag! 'W_REQUEST' do
           xml.tag! 'W_JOB' do
-              # TODO: OPTIONAL, check what value needs to be insert here
-              xml.tag! 'JobID', 'test dummy data'
+              xml.tag! 'JobID', ''
               # UserID for this transaction
               xml.tag! 'BusinessCaseSignature', options[:signature] || options[:login]
               # Create the whole rest of the message
-              add_transaction_data(xml, action, money, options)
-				    end
-				  end
-				end
-				xml.target!
+              add_transaction_data(xml, money, options)
+            end
+          end
+        end
+        xml.target!
       end
 
       # Includes the whole transaction data (payment, creditcard, address)
-      def add_transaction_data(xml, action, money, options = {})
-        options[:action] = action
-        # TODO: require order_id instead of auto-generating it if not supplied
+      def add_transaction_data(xml, money, options)
         options[:order_id] ||= generate_unique_id
-        transaction_type = action.to_s.upcase
-
-        xml.tag! "FNC_CC_#{transaction_type}" do
-          # TODO: OPTIONAL, check which param should be used here
-          xml.tag! 'FunctionID', options[:description] || 'Test dummy FunctionID'
 
+        xml.tag! "FNC_CC_#{options[:action].to_s.upcase}" do
+          xml.tag! 'FunctionID', options[:description]
           xml.tag! 'CC_TRANSACTION' do
             xml.tag! 'TransactionID', options[:order_id]
-            if [:authorization, :purchase].include?(action)
+            case options[:action]
+            when :authorization, :purchase
               add_invoice(xml, money, options)
               add_creditcard(xml, options[:credit_card])
               add_address(xml, options[:billing_address])
-            elsif action == :capture_authorization
-              xml.tag! 'GuWID', options[:authorization] if options[:authorization]
+            when :capture_authorization
+              xml.tag! 'GuWID', options[:authorization]
             end
           end
         end
       end
 
-			# Includes the payment (amount, currency, country) to the transaction-xml
+      # Includes the payment (amount, currency, country) to the transaction-xml
       def add_invoice(xml, money, options)
         xml.tag! 'Amount', amount(money)
         xml.tag! 'Currency', options[:currency] || currency(money)
@@ -182,8 +179,8 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-			# Includes the credit-card data to the transaction-xml
-			def add_creditcard(xml, creditcard)
+      # Includes the credit-card data to the transaction-xml
+      def add_creditcard(xml, creditcard)
         raise "Creditcard must be supplied!" if creditcard.nil?
         xml.tag! 'CREDIT_CARD_DATA' do
           xml.tag! 'CreditCardNumber', creditcard.number
@@ -194,38 +191,37 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-			# Includes the IP address of the customer to the transaction-xml
+      # Includes the IP address of the customer to the transaction-xml
       def add_customer_data(xml, options)
         return unless options[:ip]
-				xml.tag! 'CONTACT_DATA' do
-					xml.tag! 'IPAddress', options[:ip]
-				end
-			end
+        xml.tag! 'CONTACT_DATA' do
+          xml.tag! 'IPAddress', options[:ip]
+        end
+      end
 
       # Includes the address to the transaction-xml
       def add_address(xml, address)
         return if address.nil?
         xml.tag! 'CORPTRUSTCENTER_DATA' do
-	        xml.tag! 'ADDRESS' do
-	          xml.tag! 'Address1', address[:address1]
-	          xml.tag! 'Address2', address[:address2] if address[:address2]
-	          xml.tag! 'City', address[:city]
-	          xml.tag! 'ZipCode', address[:zip]
-	          
-	          if address[:state] =~ /[A-Za-z]{2}/ && address[:country] =~ /^(us|ca)$/i
-	            xml.tag! 'State', address[:state].upcase
-	          end
-	          
-	          xml.tag! 'Country', address[:country]
+          xml.tag! 'ADDRESS' do
+            xml.tag! 'Address1', address[:address1]
+            xml.tag! 'Address2', address[:address2] if address[:address2]
+            xml.tag! 'City', address[:city]
+            xml.tag! 'ZipCode', address[:zip]
+
+            if address[:state] =~ /[A-Za-z]{2}/ && address[:country] =~ /^(us|ca)$/i
+              xml.tag! 'State', address[:state].upcase
+            end
+
+            xml.tag! 'Country', address[:country]
             xml.tag! 'Phone', address[:phone] if address[:phone] =~ VALID_PHONE_FORMAT
-	          xml.tag! 'Email', address[:email]
-	        end
-	      end
+            xml.tag! 'Email', address[:email]
+          end
+        end
       end
 
-
       # Read the XML message from the gateway and check if it was successful,
-			# and also extract required return values from the response.
+      # and also extract required return values from the response.
       def parse(xml)
         basepath = '/WIRECARD_BXML/W_RESPONSE'
         response = {}
@@ -311,7 +307,6 @@ module ActiveMerchant #:nodoc:
         credentials = [@options[:login], @options[:password]].join(':')
         "Basic " << Base64.encode64(credentials).strip
       end
-      
     end
   end
 end