activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,237 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WepayGateway < Gateway
+      self.test_url = 'https://stage.wepayapi.com/v2'
+      self.live_url = 'https://wepayapi.com/v2'
+
+      self.supported_countries = ['US', 'CA']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'https://www.wepay.com/'
+      self.default_currency = 'USD'
+      self.display_name = 'WePay'
+
+      def initialize(options = {})
+        requires!(options, :client_id, :account_id, :access_token)
+        super(options)
+      end
+
+      def purchase(money, payment_method, options = {})
+        post = {}
+        if payment_method.is_a?(String)
+          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 { 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 = {}
+        if payment_method.is_a?(String)
+          authorize_with_token(post, money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { store(payment_method, 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] = 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, options)
+      end
+
+      def refund(money, identifier, options = {})
+        checkout_id, original_amount = split_authorization(identifier)
+
+        post = {}
+        post[:checkout_id] = checkout_id
+        if(money && (original_amount != amount(money)))
+          post[:amount] = amount(money)
+        end
+        post[:refund_reason] = (options[:description] || 'Refund')
+        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, options)
+      end
+
+      def store(creditcard, options = {})
+        post = {}
+        post[:client_id] = @options[:client_id]
+        post[:user_name] = "#{creditcard.first_name} #{creditcard.last_name}"
+        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
+
+        if(billing_address = (options[:billing_address] || options[:address]))
+          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, options)
+        else
+          post[:original_device] = options[:device_fingerprint] if options[:device_fingerprint]
+          post[:original_ip] = options[:ip] if options[:ip]
+          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 authorize_with_token(post, money, token, options)
+        add_token(post, token)
+        add_product_data(post, money, options)
+        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[: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[: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]
+        post[:require_shipping] = options[:require_shipping] if options[:require_shipping]
+        post[:shipping_fee] = options[:shipping_fee] if options[:shipping_fee]
+        post[:charge_tax] = options[:charge_tax] if options[:charge_tax]
+        post[:mode] = options[:mode] if options[:mode]
+        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]
+        post[:payer_rbits] = options[:payer_rbits] if options[:payer_rbits]
+        post[:transaction_rbits] = options[:transaction_rbits] if options[:transaction_rbits]
+        add_fee(post, options)
+      end
+
+      def add_token(post, token)
+        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)
+        JSON.parse(response)
+      end
+
+      def commit(action, params, options={})
+        begin
+          response = parse(ssl_post(
+            ((test? ? test_url : live_url) + action),
+            params.to_json,
+            headers(options)
+          ))
+        rescue ResponseError => e
+          response = parse(e.response.body)
+        end
+
+        return Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, params),
+          test: test?
+        )
+      rescue JSON::ParserError
+        return unparsable_response(response)
+      end
+
+      def success_from(response)
+        (!response['error'])
+      end
+
+      def message_from(response)
+        (response['error'] ? response['error_description'] : 'Success')
+      end
+
+      def authorization_from(response, params)
+        return response['credit_card_id'].to_s if response['credit_card_id']
+
+        original_amount = response['amount'].nil? ? nil : sprintf('%0.02f', response['amount'])
+        [response['checkout_id'], original_amount].join('|')
+      end
+
+      def split_authorization(authorization)
+        auth, original_amount = authorization.to_s.split('|')
+        [auth, original_amount]
+      end
+
+      def unparsable_response(raw_response)
+        message = 'Invalid JSON response received from WePay. Please contact WePay support 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
+
+      def headers(options)
+        headers = {
+          'Content-Type'      => 'application/json',
+          'User-Agent'        => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'Authorization'     => "Bearer #{@options[:access_token]}"
+        }
+        headers['Api-Version'] = options[:version] if options[:version]
+        headers['Client-IP'] = options[:ip] if options[:ip]
+        headers['WePay-Risk-Token'] = options[:risk_token] if options[:risk_token]
+
+        headers
+      end
+    end
+  end
+end

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

@@ -26,7 +26,7 @@ module ActiveMerchant #:nodoc:
       # number 5551234 within area code 202 (country code 1).
       VALID_PHONE_FORMAT = /\+\d{1,3}(\(?\d{3}\)?)?\d{3}-\d{4}-\d{3}/
 
-      self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :jcb, :switch ]
+      self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :jcb ]
       self.supported_countries = %w(AD CY GI IM MT RO CH AT DK GR IT MC SM TR BE EE HU LV NL SK GB BG FI IS LI NO SI VA FR IL LT PL ES CZ DE IE LU PT SE)
       self.homepage_url = 'http://www.wirecard.com'
       self.display_name = 'Wirecard'
@@ -44,8 +44,16 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      def authorize(money, creditcard, options = {})
-        options[:credit_card] = creditcard
+      # Authorization - the second parameter may be a CreditCard or
+      # a String which represents a GuWID reference to an earlier
+      # transaction.  If a GuWID is given, rather than a CreditCard,
+      # then then the :recurring option will be forced to "Repeated"
+      def authorize(money, payment_method, options = {})
+        if payment_method.respond_to?(:number)
+          options[:credit_card] = payment_method
+        else
+          options[:preauthorization] = payment_method
+        end
         commit(:preauthorization, money, options)
       end
 
@@ -54,8 +62,16 @@ module ActiveMerchant #:nodoc:
         commit(:capture, money, options)
       end
 
-      def purchase(money, creditcard, options = {})
-        options[:credit_card] = creditcard
+      # Purchase - the second parameter may be a CreditCard or
+      # a String which represents a GuWID reference to an earlier
+      # transaction.  If a GuWID is given, rather than a CreditCard,
+      # then then the :recurring option will be forced to "Repeated"
+      def purchase(money, payment_method, options = {})
+        if payment_method.respond_to?(:number)
+          options[:credit_card] = payment_method
+        else
+          options[:preauthorization] = payment_method
+        end
         commit(:purchase, money, options)
       end
 
@@ -69,10 +85,62 @@ module ActiveMerchant #:nodoc:
         commit(:bookback, money, options)
       end
 
+      # Store card - Wirecard supports the notion of "Recurring
+      # Transactions" by allowing the merchant to provide a reference
+      # to an earlier transaction (the GuWID) rather than a credit
+      # card.  A reusable reference (GuWID) can be obtained by sending
+      # a purchase or authorization transaction with the element
+      # "RECURRING_TRANSACTION/Type" set to "Initial".  Subsequent
+      # transactions can then use the GuWID in place of a credit
+      # card by setting "RECURRING_TRANSACTION/Type" to "Repeated".
+      #
+      # This implementation of card store utilizes a Wirecard
+      # "Authorization Check" (a Preauthorization that is automatically
+      # reversed).  It defaults to a check amount of "100" (i.e.
+      # $1.00) but this can be overriden (see below).
+      #
+      # IMPORTANT: In order to reuse the stored reference, the
+      # +authorization+ from the response should be saved by
+      # your application code.
+      #
+      # ==== Options specific to +store+
+      #
+      # * <tt>:amount</tt> -- The amount, in cents, that should be
+      #   "validated" by the Authorization Check.  This amount will
+      #   be reserved and then reversed.  Default is 100.
+      #
+      # Note: This is not the only way to achieve a card store
+      # operation at Wirecard.  Any +purchase+ or +authorize+
+      # can be sent with +options[:recurring] = 'Initial'+ to make
+      # the returned authorization/GuWID usable in later transactions
+      # with +options[:recurring] = 'Repeated'+.
+      def store(creditcard, options = {})
+        options[:credit_card] = creditcard
+        options[:recurring] = 'Initial'
+        money = options.delete(:amount) || 100
+        # Amex does not support authorization_check
+        if creditcard.brand == 'american_express'
+          commit(:preauthorization, money, options)
+        else
+          commit(:authorization_check, money, options)
+        end
+      end
+
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((<CreditCardNumber>)\d+(</CreditCardNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<CVC2>)[^<]+(</CVC2>)), '\1[FILTERED]\2')
+      end
 
       private
+
       def clean_description(description)
-        description.to_s.slice(0,32).encode("US-ASCII", invalid: :replace, undef: :replace, replace: '?')
+        description.to_s.slice(0, 32).encode('US-ASCII', invalid: :replace, undef: :replace, replace: '?')
       end
 
       def prepare_options_hash(options)
@@ -90,6 +158,13 @@ module ActiveMerchant #:nodoc:
         options[:billing_address][:email] = options[:email] if options[:email]
       end
 
+      # If a GuWID (string-based reference) is passed rather than a
+      # credit card, then the :recurring type needs to be forced to
+      # "Repeated"
+      def setup_recurring_flag(options)
+        options[:recurring] = 'Repeated' if options[:preauthorization].present?
+      end
+
       # Contact WireCard, make the XML request, and parse the
       # reply into a Response object
       def commit(action, money, options)
@@ -100,19 +175,19 @@ module ActiveMerchant #:nodoc:
 
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request, headers))
         # Pending Status also means Acknowledged (as stated in their specification)
-        success = response[:FunctionResult] == "ACK" || response[:FunctionResult] == "PENDING"
+        success = response[:FunctionResult] == 'ACK' || response[:FunctionResult] == 'PENDING'
         message = response[:Message]
         authorization = response[:GuWID]
 
         Response.new(success, message, response,
           :test => test?,
           :authorization => authorization,
-          :avs_result => { :code => response[:avsCode] },
-          :cvv_result => response[:cvCode]
+          :avs_result => { :code => avs_code(response, options) },
+          :cvv_result => response[:CVCResponseCode]
         )
       rescue ResponseError => e
-        if e.response.code == "401"
-          return Response.new(false, "Invalid Login")
+        if e.response.code == '401'
+          return Response.new(false, 'Invalid Login')
         else
           raise
         end
@@ -126,7 +201,7 @@ module ActiveMerchant #:nodoc:
         xml.instruct!
         xml.tag! 'WIRECARD_BXML' do
           xml.tag! 'W_REQUEST' do
-          xml.tag! 'W_JOB' do
+            xml.tag! 'W_JOB' do
               xml.tag! 'JobID', ''
               # UserID for this transaction
               xml.tag! 'BusinessCaseSignature', options[:signature] || options[:login]
@@ -146,24 +221,33 @@ module ActiveMerchant #:nodoc:
           xml.tag! 'FunctionID', clean_description(options[:description])
           xml.tag! 'CC_TRANSACTION' do
             xml.tag! 'TransactionID', options[:order_id]
+            xml.tag! 'CommerceType', options[:commerce_type] if options[:commerce_type]
             case options[:action]
-            when :preauthorization, :purchase
+            when :preauthorization, :purchase, :authorization_check
+              setup_recurring_flag(options)
               add_invoice(xml, money, options)
-              add_creditcard(xml, options[:credit_card])
+
+              if options[:credit_card]
+                add_creditcard(xml, options[:credit_card])
+              else
+                xml.tag! 'GuWID', options[:preauthorization]
+              end
+
               add_address(xml, options[:billing_address])
             when :capture, :bookback
               xml.tag! 'GuWID', options[:preauthorization]
-              add_amount(xml, money)
+              add_amount(xml, money, options)
             when :reversal
               xml.tag! 'GuWID', options[:preauthorization]
             end
+            add_customer_data(xml, options)
           end
         end
       end
 
       # Includes the payment (amount, currency, country) to the transaction-xml
       def add_invoice(xml, money, options)
-        add_amount(xml, money)
+        add_amount(xml, money, options)
         xml.tag! 'Currency', options[:currency] || currency(money)
         xml.tag! 'CountryCode', options[:billing_address][:country]
         xml.tag! 'RECURRING_TRANSACTION' do
@@ -172,13 +256,13 @@ module ActiveMerchant #:nodoc:
       end
 
       # Include the amount in the transaction-xml
-      def add_amount(xml, money)
-        xml.tag! 'Amount', amount(money)
+      def add_amount(xml, money, options)
+        xml.tag! 'Amount', localized_amount(money, options[:currency] || currency(money))
       end
 
       # Includes the credit-card data to the transaction-xml
       def add_creditcard(xml, creditcard)
-        raise "Creditcard must be supplied!" if creditcard.nil?
+        raise 'Creditcard must be supplied!' if creditcard.nil?
         xml.tag! 'CREDIT_CARD_DATA' do
           xml.tag! 'CreditCardNumber', creditcard.number
           xml.tag! 'CVC2', creditcard.verification_value
@@ -226,8 +310,8 @@ module ActiveMerchant #:nodoc:
         xml = REXML::Document.new(xml)
         if root = REXML::XPath.first(xml, "#{basepath}/W_JOB")
           parse_response(response, root)
-        elsif root = REXML::XPath.first(xml, "//ERROR")
-          parse_error(response, root)
+        elsif root = REXML::XPath.first(xml, '//ERROR')
+          parse_error_only_response(response, root)
         else
           response[:Message] = "No valid XML response message received. \
                                 Propably wrong credentials supplied with HTTP header."
@@ -236,31 +320,49 @@ module ActiveMerchant #:nodoc:
         response
       end
 
+      def parse_error_only_response(response, root)
+        error_code = REXML::XPath.first(root, 'Number')
+        response[:ErrorCode] = error_code.text if error_code
+        response[:Message] = parse_error(root)
+      end
+
       # Parse the <ProcessingStatus> Element which contains all important information
       def parse_response(response, root)
         status = nil
-        # get the root element for this Transaction
+
         root.elements.to_a.each do |node|
           if node.name =~ /FNC_CC_/
-            status = REXML::XPath.first(node, "CC_TRANSACTION/PROCESSING_STATUS")
+            status = REXML::XPath.first(node, 'CC_TRANSACTION/PROCESSING_STATUS')
           end
         end
-        message = ""
+
+        message = ''
         if status
           if info = status.elements['Info']
             message << info.text
           end
-          # Get basic response information
+
           status.elements.to_a.each do |node|
-            response[node.name.to_sym] = (node.text || '').strip
+            if node.elements.size == 0
+              response[node.name.to_sym] = (node.text || '').strip
+            else
+              node.elements.each do |childnode|
+                name = "#{node.name}_#{childnode.name}"
+                response[name.to_sym] = (childnode.text || '').strip
+              end
+            end
           end
+
+          error_code = REXML::XPath.first(status, 'ERROR/Number')
+          response['ErrorCode'] = error_code.text if error_code
         end
+
         parse_error(root, message)
         response[:Message] = message
       end
 
       # Parse a generic error response from the gateway
-      def parse_error(root, message = "")
+      def parse_error(root, message = '')
         # Get errors if available and append them to the message
         errors = errors_to_string(root)
         unless errors.strip.blank?
@@ -275,7 +377,7 @@ module ActiveMerchant #:nodoc:
       def errors_to_string(root)
         # Get context error messages (can be 0..*)
         errors = []
-        REXML::XPath.each(root, "//ERROR") do |error_elem|
+        REXML::XPath.each(root, '//ERROR') do |error_elem|
           error = {}
           error[:Advice] = []
           error[:Message] = error_elem.elements['Message'].text
@@ -287,7 +389,7 @@ module ActiveMerchant #:nodoc:
         # Convert all messages to a single string
         string = ''
         errors.each do |error|
-          string << error[:Message]
+          string << error[:Message] if error[:Message]
           error[:Advice].each_with_index do |advice, index|
             string << ' (' if index == 0
             string << "#{index+1}. #{advice}"
@@ -298,13 +400,33 @@ module ActiveMerchant #:nodoc:
         string
       end
 
+      # Amex have different AVS response codes
+      AMEX_TRANSLATED_AVS_CODES = {
+        'A' => 'B', # CSC and Address Matched
+        'F' => 'D', # All Data Matched
+        'N' => 'I', # CSC Match
+        'U' => 'U', # Data Not Checked
+        'Y' => 'D', # All Data Matched
+        'Z' => 'P', # CSC and Postcode Matched
+      }
+
+      # Amex have different AVS response codes to visa etc
+      def avs_code(response, options)
+        if response.has_key?(:AVS_ProviderResultCode)
+          if options[:credit_card].present? && ActiveMerchant::Billing::CreditCard.brand?(options[:credit_card].number) == 'american_express'
+            AMEX_TRANSLATED_AVS_CODES[response[:AVS_ProviderResultCode]]
+          else
+            response[:AVS_ProviderResultCode]
+          end
+        end
+      end
+
       # Encode login and password in Base64 to supply as HTTP header
       # (for http basic authentication)
       def encoded_credentials
         credentials = [@options[:login], @options[:password]].join(':')
-        "Basic " << Base64.encode64(credentials).strip
+        'Basic ' << Base64.encode64(credentials).strip
       end
     end
   end
 end
-