activemerchant 1.43.3 → 1.44.0

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

@@ -63,6 +63,13 @@ module ActiveMerchant #:nodoc:
         commit(:refund, post)
       end
 
+      def verify(creditcard, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(1, creditcard, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
       def void(authorization, options = {})
         post = { :refNum => authorization }
         commit(:void, post)

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

@@ -86,7 +86,7 @@ module ActiveMerchant #:nodoc:
 
       def credit(money, credit_card_or_authorization, options = {})
         if credit_card_or_authorization.is_a?(String)
-          deprecated CREDIT_DEPRECATION_MESSAGE
+          ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
           refund(money, credit_card_or_authorization, options)
         else
           sale_authorization_or_credit_template(:credit, money, credit_card_or_authorization, options)
@@ -125,13 +125,6 @@ module ActiveMerchant #:nodoc:
         post[:cvv]       = credit_card.verification_value
       end
 
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
       def add_addresses(post, options)
         if billing_address = options[:billing_address] || options[:address]
           post[:company]    = billing_address[:company]

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

@@ -169,12 +169,6 @@ module ActiveMerchant #:nodoc:
         result.collect { |key, value| "ssl_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
       end
 
-      def expdate(creditcard)
-        year  = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-        "#{month}#{year[2..3]}"
-      end
-
       # Parse the response message
       def parse(msg)
         resp = {}

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

@@ -1,9 +1,3 @@
-begin
-  require "vindicia-api"
-rescue LoadError
-  raise "Could not load the vindicia-api gem.  Use `gem install vindicia-api` to install it."
-end
-
 require 'i18n/core_ext/string/interpolate'
 
 module ActiveMerchant #:nodoc:
@@ -46,24 +40,9 @@ module ActiveMerchant #:nodoc:
       # * <tt>:cvn_success</tt> -- Array of valid CVN Check return values - defaults to [M, P] (OPTIONAL)
       # * <tt>:avs_success</tt> -- Array of valid AVS Check return values - defaults to [X, Y, A, W, Z] (OPTIONAL)
       def initialize(options = {})
-        requires!(options, :login, :password)
+        requires!(options, :login, :password, :account_id)
         super
 
-        config = lambda do |config|
-          config.login = options[:login]
-          config.password = options[:password]
-          config.api_version = options[:api_version] || "3.6"
-          config.endpoint = test? ? self.test_url : self.live_url
-          config.namespace = "http://soap.vindicia.com"
-        end
-
-        if Vindicia.config.is_configured?
-          config.call(Vindicia.config)
-        else
-          Vindicia.configure(&config)
-        end
-
-        requires!(options, :account_id)
         @account_id = options[:account_id]
 
         @transaction_prefix = options[:transaction_prefix] || "X"
@@ -121,9 +100,9 @@ module ActiveMerchant #:nodoc:
       # * <tt>money</tt> -- The amount to be captured as an Integer value in cents.
       # * <tt>identification</tt> -- The authorization returned from the previous authorize request.
       def capture(money, identification, options = {})
-        response = post(Vindicia::Transaction.capture({
-          :transactions => [{ :merchantTransactionId => identification }]
-        }))
+        response = post(:capture) do |xml|
+          add_hash(xml, transactions: [{ merchantTransactionId: identification }])
+        end
 
         if response[:return][:returnCode] != '200' || response[:qtyFail].to_i > 0
           return fail(response)
@@ -139,13 +118,13 @@ module ActiveMerchant #:nodoc:
       # * <tt>identification</tt> - The authorization returned from the previous authorize request.
       # * <tt>options</tt> - Extra options (currently only :ip used)
       def void(identification, options = {})
-        response = post(Vindicia::Transaction.cancel({
-          :transactions => [{
-            :account => { :merchantAccountId => @account_id },
-            :merchantTransactionId => identification,
-            :sourceIp => options[:ip]
-          }]
-        }))
+        response = post(:cancel) do |xml|
+          add_hash(xml, transactions: [{
+            account: {merchantAccountId: @account_id},
+            merchantTransactionId: identification,
+            sourceIp: options[:ip]
+          }])
+        end
 
         if response[:return][:returnCode] == '200' && response[:qtyFail].to_i == 0
           success(response, identification)
@@ -167,6 +146,8 @@ module ActiveMerchant #:nodoc:
       # * <tt>:product_sku</tt> -- The subscription product's sku
       # * <tt>:autobill_prefix</tt> -- Prefix to order id for subscriptions - defaults to 'A' (OPTIONAL)
       def recurring(money, creditcard, options={})
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         options[:recurring] = true
         @autobill_prefix = options[:autobill_prefix] || "A"
 
@@ -193,10 +174,56 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      protected
+      private
+
+      def add_hash(xml, hash)
+        hash.each do |k,v|
+          add_element(xml, k, v)
+        end
+      end
+
+      def add_array(xml, elem, val)
+        val.each do |v|
+          add_element(xml, elem, v)
+        end
+      end
+
+      def add_element(xml, elem, val)
+        if val.is_a?(Hash)
+          xml.tag!(elem.to_s.camelize(:lower)) do |env|
+            add_hash(env, val)
+          end
+        elsif val.is_a?(Array)
+          add_array(xml, elem, val)
+        else
+          xml.tag!(elem.to_s.camelize(:lower), val.to_s)
+        end
+      end
+
+      def post(action, kind="Transaction")
+        xml = Builder::XmlMarkup.new
+        xml.instruct!(:xml, :encoding => "UTF-8")
+        xml.env :Envelope,
+          "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+          "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+          "xmlns:tns" => "http://soap.vindicia.com/v3_6/#{kind}",
+          "xmlns:env" => "http://schemas.xmlsoap.org/soap/envelope/" do
+
+          xml.env :Body do
+            xml.tns action.to_sym do
+              xml.auth do
+                xml.tag! :login, @options[:login]
+                xml.tag! :password, @options[:password]
+                xml.tag! :version, "3.6"
+              end
+
+              yield(xml)
+            end
+          end
+        end
 
-      def post(body)
-        parse(ssl_post(Vindicia.config.endpoint, body, "Content-Type" => "text/xml"))
+        url = (test? ? self.test_url : self.live_url)
+        parse(ssl_post(url, xml.target!, "Content-Type" => "text/xml"))
       end
 
       def parse(response)
@@ -240,10 +267,9 @@ module ActiveMerchant #:nodoc:
         add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard, options)
 
-        post(Vindicia::Transaction.auth({
-          :transaction => parameters,
-          :minChargebackProbability => @min_chargeback_probability
-        }))
+        post(:auth) do |xml|
+          add_hash(xml, transaction: parameters, minChargebackProbability: @min_chargeback_probability)
+        end
       end
 
       def add_account_data(parameters, options)
@@ -282,11 +308,9 @@ module ActiveMerchant #:nodoc:
         add_account_data(parameters, options)
         add_subscription_information(parameters, options)
 
-        post(Vindicia::AutoBill.update({
-          :autobill => parameters,
-          :validatePaymentMethod => false,
-          :minChargebackProbability => 100
-        }))
+        post(:update, "AutoBill") do |xml|
+          add_hash(xml, autobill: parameters, validatePaymentMethod: false, minChargebackProbability: 100)
+        end
       end
 
       def check_subscription(vindicia_transaction)

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

@@ -71,18 +71,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def headers(options = {})
-        @@ua ||= JSON.dump({
-          :bindings_version => ActiveMerchant::VERSION,
-          :lang => 'ruby',
-          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
-          :platform => RUBY_PLATFORM,
-          :publisher => 'active_merchant'
-        })
-
         {
           "Authorization" => "Basic " + Base64.encode64(@api_key.to_s + ":").strip,
           "User-Agent" => "Webpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-          "X-Webpay-Client-User-Agent" => @@ua,
+          "X-Webpay-Client-User-Agent" => user_agent,
           "X-Webpay-Client-User-Metadata" => {:ip => options[:ip]}.to_json
         }
       end

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

@@ -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,6 +85,46 @@ 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
 
       private
       def clean_description(description)
@@ -90,6 +146,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)
@@ -107,8 +170,8 @@ module ActiveMerchant #:nodoc:
         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"
@@ -146,10 +209,18 @@ 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]
@@ -227,7 +298,7 @@ module ActiveMerchant #:nodoc:
         if root = REXML::XPath.first(xml, "#{basepath}/W_JOB")
           parse_response(response, root)
         elsif root = REXML::XPath.first(xml, "//ERROR")
-          parse_error(response, root)
+          parse_error_only_response(response, root)
         else
           response[:Message] = "No valid XML response message received. \
                                 Propably wrong credentials supplied with HTTP header."
@@ -236,6 +307,12 @@ 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
@@ -253,7 +330,14 @@ module ActiveMerchant #:nodoc:
           end
 
           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")
@@ -292,7 +376,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}"
@@ -303,6 +387,28 @@ 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
+        "F" => "D"  # Street address and zip code match
+      }
+
+      # 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

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

@@ -7,9 +7,9 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'GBP'
       self.money_format = :cents
       self.supported_countries = %w(HK US GB AU AD BE CH CY CZ DE DK ES FI FR GI GR HU IE IL IT LI LU MC MT NL NO NZ PL PT SE SG SI SM TR UM VA)
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :laser]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :laser, :switch]
       self.homepage_url = 'http://www.worldpay.com/'
-      self.display_name = 'WorldPay'
+      self.display_name = 'Worldpay'
 
       CARD_CODES = {
         'visa'             => 'VISA-SSL',
@@ -19,7 +19,8 @@ module ActiveMerchant #:nodoc:
         'jcb'              => 'JCB-SSL',
         'maestro'          => 'MAESTRO-SSL',
         'laser'            => 'LASER-SSL',
-        'diners_club'      => 'DINERS-SSL'
+        'diners_club'      => 'DINERS-SSL',
+        'switch'           => 'MAESTRO-SSL'
       }
 
       def initialize(options = {})
@@ -88,8 +89,8 @@ module ActiveMerchant #:nodoc:
 
       def build_request
         xml = Builder::XmlMarkup.new :indent => 2
-        xml.instruct! :xml, :encoding => 'ISO-8859-1'
-        xml.declare! :DOCTYPE, :paymentService, :PUBLIC, "-//WorldPay//DTD WorldPay PaymentService v1//EN", "http://dtd.wp3.rbsworldpay.com/paymentService_v1.dtd"
+        xml.instruct! :xml, :encoding => 'UTF-8'
+        xml.declare! :DOCTYPE, :paymentService, :PUBLIC, "-//WorldPay//DTD WorldPay PaymentService v1//EN", "http://dtd.worldpay.com/paymentService_v1.dtd"
         xml.tag! 'paymentService', 'version' => "1.4", 'merchantCode' => @options[:login] do
           yield xml
         end
@@ -126,6 +127,7 @@ module ActiveMerchant #:nodoc:
                 end
               end
               add_payment_method(xml, money, payment_method, options)
+              add_email(xml, options)
             end
           end
         end
@@ -174,8 +176,14 @@ module ActiveMerchant #:nodoc:
 
       def add_payment_method(xml, amount, payment_method, options)
         if payment_method.is_a?(String)
-          xml.tag! 'payAsOrder', 'orderCode' => payment_method do
-            add_amount(xml, amount, options)
+          if options[:merchant_code]
+            xml.tag! 'payAsOrder', 'orderCode' => payment_method, 'merchantCode' => options[:merchant_code] do
+              add_amount(xml, amount, options)
+            end
+          else
+            xml.tag! 'payAsOrder', 'orderCode' => payment_method do
+              add_amount(xml, amount, options)
+            end
           end
         else
           xml.tag! 'paymentDetails' do
@@ -188,38 +196,58 @@ module ActiveMerchant #:nodoc:
               xml.tag! 'cardHolderName', payment_method.name
               xml.tag! 'cvc', payment_method.verification_value
 
-              add_address(xml, 'cardAddress', (options[:billing_address] || options[:address]))
+              add_address(xml, (options[:billing_address] || options[:address]))
+            end
+            if options[:ip]
+              xml.tag! 'session', 'shopperIPAddress' => options[:ip]
             end
           end
         end
       end
 
-      def add_address(xml, element, address)
-        return if address.nil?
+      def add_email(xml, options)
+        return unless options[:email]
+        xml.tag! 'shopper' do
+          xml.tag! 'shopperEmailAddress', options[:email]
+        end
+      end
+
+      def add_address(xml, address)
+        address = address_with_defaults(address)
 
-        xml.tag! element do
+        xml.tag! 'cardAddress' do
           xml.tag! 'address' do
             if m = /^\s*([^\s]+)\s+(.+)$/.match(address[:name])
               xml.tag! 'firstName', m[1]
               xml.tag! 'lastName', m[2]
             end
-            if m = /^\s*(\d+)\s+(.+)$/.match(address[:address1])
-              xml.tag! 'street', m[2]
-              house_number = m[1]
-            else
-              xml.tag! 'street', address[:address1]
-            end
-            xml.tag! 'houseName', address[:address2] if address[:address2]
-            xml.tag! 'houseNumber', house_number if house_number.present?
-            xml.tag! 'postalCode', (address[:zip].present? ? address[:zip] : "0000")
-            xml.tag! 'city', address[:city] if address[:city]
-            xml.tag! 'state', (address[:state].present? ? address[:state] : 'N/A')
+            xml.tag! 'address1', address[:address1]
+            xml.tag! 'address2', address[:address2] if address[:address2]
+            xml.tag! 'postalCode', address[:zip]
+            xml.tag! 'city', address[:city]
+            xml.tag! 'state', address[:state]
             xml.tag! 'countryCode', address[:country]
             xml.tag! 'telephoneNumber', address[:phone] if address[:phone]
           end
         end
       end
 
+      def address_with_defaults(address)
+        address ||= {}
+        address.delete_if { |_, v| v.blank? }
+        address.reverse_merge!(default_address)
+      end
+
+      def default_address
+        {
+          address1: 'N/A',
+          zip: '0000',
+          city: 'N/A',
+          state: 'N/A',
+          country: 'US'
+        }
+      end
+
       def parse(action, xml)
         parse_element({:action => action}, REXML::Document.new(xml))
       end