activemerchant 1.38.0 → 1.78.0

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

@@ -1,334 +1,25 @@
 require 'rexml/document'
 require 'digest/md5'
 
+require 'active_merchant/billing/gateways/quickpay/quickpay_v10'
+require 'active_merchant/billing/gateways/quickpay/quickpay_v4to7'
+
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class QuickpayGateway < Gateway
-      self.live_url = self.test_url = 'https://secure.quickpay.dk/api'
-
-      self.default_currency = 'DKK'
-      self.money_format = :cents
-      self.supported_cardtypes = [:dankort, :forbrugsforeningen, :visa, :master, :american_express, :diners_club, :jcb, :maestro]
-      self.supported_countries = ['DK', 'SE']
-      self.homepage_url = 'http://quickpay.dk/'
-      self.display_name = 'Quickpay'
-
-      MD5_CHECK_FIELDS = {
-        3 => {
-          :authorize => %w(protocol msgtype merchant ordernumber amount
-                           currency autocapture cardnumber expirationdate
-                           cvd cardtypelock testmode),
-
-          :capture   => %w(protocol msgtype merchant amount transaction),
-
-          :cancel    => %w(protocol msgtype merchant transaction),
-
-          :refund    => %w(protocol msgtype merchant amount transaction),
-
-          :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                           expirationdate cvd cardtypelock description testmode),
-
-          :recurring => %w(protocol msgtype merchant ordernumber amount
-                           currency autocapture transaction),
-
-          :status    => %w(protocol msgtype merchant transaction),
-
-          :chstatus  => %w(protocol msgtype merchant)
-        },
-
-        4 => {
-          :authorize => %w(protocol msgtype merchant ordernumber amount
-                           currency autocapture cardnumber expirationdate cvd
-                           cardtypelock testmode fraud_remote_addr
-                           fraud_http_accept fraud_http_accept_language
-                           fraud_http_accept_encoding fraud_http_accept_charset
-                           fraud_http_referer fraud_http_user_agent apikey),
-
-          :capture   => %w(protocol msgtype merchant amount transaction apikey),
-
-          :cancel    => %w(protocol msgtype merchant transaction apikey),
-
-          :refund    => %w(protocol msgtype merchant amount transaction apikey),
-
-          :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                           expirationdate cvd cardtypelock description testmode
-                           fraud_remote_addr fraud_http_accept fraud_http_accept_language
-                           fraud_http_accept_encoding fraud_http_accept_charset
-                           fraud_http_referer fraud_http_user_agent apikey),
-
-          :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                           autocapture transaction apikey),
-
-          :status    => %w(protocol msgtype merchant transaction apikey),
-
-          :chstatus  => %w(protocol msgtype merchant apikey)
-        },
-
-        5 => {
-          :authorize => %w(protocol msgtype merchant ordernumber amount
-                           currency autocapture cardnumber expirationdate cvd
-                           cardtypelock testmode fraud_remote_addr
-                           fraud_http_accept fraud_http_accept_language
-                           fraud_http_accept_encoding fraud_http_accept_charset
-                           fraud_http_referer fraud_http_user_agent apikey),
-
-          :capture   => %w(protocol msgtype merchant amount transaction apikey),
-
-          :cancel    => %w(protocol msgtype merchant transaction apikey),
-
-          :refund    => %w(protocol msgtype merchant amount transaction apikey),
-
-          :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                           expirationdate cvd cardtypelock description testmode
-                           fraud_remote_addr fraud_http_accept fraud_http_accept_language
-                           fraud_http_accept_encoding fraud_http_accept_charset
-                           fraud_http_referer fraud_http_user_agent apikey),
-
-          :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                           autocapture transaction apikey),
-
-          :status    => %w(protocol msgtype merchant transaction apikey),
-
-          :chstatus  => %w(protocol msgtype merchant apikey)
-        },
-
-        6 => {
-          :authorize => %w(protocol msgtype merchant ordernumber amount
-                           currency autocapture cardnumber expirationdate cvd
-                           cardtypelock testmode fraud_remote_addr
-                           fraud_http_accept fraud_http_accept_language
-                           fraud_http_accept_encoding fraud_http_accept_charset
-                           fraud_http_referer fraud_http_user_agent apikey),
-
-          :capture   => %w(protocol msgtype merchant amount transaction
-                           apikey),
-
-          :cancel    => %w(protocol msgtype merchant transaction apikey),
-
-          :refund    => %w(protocol msgtype merchant amount transaction apikey),
-
-          :subscribe => %w(protocol msgtype merchant ordernumber cardnumber
-                           expirationdate cvd cardtypelock description testmode
-                           fraud_remote_addr fraud_http_accept fraud_http_accept_language
-                           fraud_http_accept_encoding fraud_http_accept_charset
-                           fraud_http_referer fraud_http_user_agent apikey),
-
-          :recurring => %w(protocol msgtype merchant ordernumber amount currency
-                           autocapture transaction apikey),
-
-          :status    => %w(protocol msgtype merchant transaction apikey),
-
-          :chstatus  => %w(protocol msgtype merchant apikey)
-        }
-      }
-
-      APPROVED = '000'
-
-      # The login is the QuickpayId
-      # The password is the md5checkword from the Quickpay manager
-      # To use the API-key from the Quickpay manager, specify :api-key
-      # Using the API-key, requires that you use version 4+. Specify :version => 4/5/6 in options.
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        @protocol = options.delete(:version) || 3 # default to protocol version 3
-        super
-      end
-
-      def authorize(money, credit_card_or_reference, options = {})
-        post = {}
-
-        action = recurring_or_authorize(credit_card_or_reference)
-
-        add_amount(post, money, options)
-        add_invoice(post, options)
-        add_creditcard_or_reference(post, credit_card_or_reference, options)
-        add_autocapture(post, false)
-        add_fraud_parameters(post, options) if action.eql?(:authorize)
-        add_testmode(post)
-
-        commit(action, post)
-      end
-
-      def purchase(money, credit_card_or_reference, options = {})
-        post = {}
-
-        action = recurring_or_authorize(credit_card_or_reference)
-
-        add_amount(post, money, options)
-        add_creditcard_or_reference(post, credit_card_or_reference, options)
-        add_invoice(post, options)
-        add_fraud_parameters(post, options) if action.eql?(:authorize)
-        add_autocapture(post, true)
-
-        commit(action, post)
-      end
-
-      def capture(money, authorization, options = {})
-        post = {}
-
-        add_reference(post, authorization)
-        add_amount_without_currency(post, money)
-        commit(:capture, post)
-      end
-
-      def void(identification, options = {})
-        post = {}
-
-        add_reference(post, identification)
-
-        commit(:cancel, post)
-      end
-
-      def refund(money, identification, options = {})
-        post = {}
+      self.abstract_class = true
 
-        add_amount_without_currency(post, money)
-        add_reference(post, identification)
+      def self.new(options = {})
+        options.fetch(:login) { raise ArgumentError.new("Missing required parameter: login") }
 
-        commit(:refund, post)
-      end
-
-      def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
-        refund(money, identification, options)
-      end
-
-      def store(creditcard, options = {})
-        post = {}
-
-        add_creditcard(post, creditcard, options)
-        add_invoice(post, options)
-        add_description(post, options)
-        add_fraud_parameters(post, options)
-        add_testmode(post)
-
-        commit(:subscribe, post)
-      end
-
-      private
-
-      def add_amount(post, money, options = {})
-        post[:amount]   = amount(money)
-        post[:currency] = options[:currency] || currency(money)
-      end
-
-      def add_amount_without_currency(post, money, options = {})
-        post[:amount] = amount(money)
-      end
-
-      def add_invoice(post, options)
-        post[:ordernumber] = format_order_number(options[:order_id])
-      end
-
-      def add_creditcard(post, credit_card, options)
-        post[:cardnumber]     = credit_card.number
-        post[:cvd]            = credit_card.verification_value
-        post[:expirationdate] = expdate(credit_card)
-        post[:cardtypelock]   = options[:cardtypelock] unless options[:cardtypelock].blank?
-      end
-
-      def add_reference(post, identification)
-        post[:transaction] = identification
-      end
-
-      def add_creditcard_or_reference(post, credit_card_or_reference, options)
-        if credit_card_or_reference.is_a?(String)
-          add_reference(post, credit_card_or_reference)
+        version = options[:login].to_i < 10000000 ? 10 : 7
+        if version <= 7
+          QuickpayV4to7Gateway.new(options)
         else
-          add_creditcard(post, credit_card_or_reference, options)
-        end
-      end
-
-      def add_autocapture(post, autocapture)
-        post[:autocapture] = autocapture ? 1 : 0
-      end
-
-      def recurring_or_authorize(credit_card_or_reference)
-        credit_card_or_reference.is_a?(String) ? :recurring : :authorize
-      end
-
-      def add_description(post, options)
-        post[:description] = options[:description]
-      end
-
-      def add_testmode(post)
-        return if post[:transaction].present?
-        post[:testmode] = test? ? '1' : '0'
-      end
-
-      def add_fraud_parameters(post, options)
-        if @protocol >= 4
-          post[:fraud_remote_addr] = options[:fraud_remote_addr] if options[:fraud_remote_addr]
-          post[:fraud_http_accept] = options[:fraud_http_accept] if options[:fraud_http_accept]
-          post[:fraud_http_accept_language] = options[:fraud_http_accept_language] if options[:fraud_http_accept_language]
-          post[:fraud_http_accept_encoding] = options[:fraud_http_accept_encoding] if options[:fraud_http_accept_encoding]
-          post[:fraud_http_accept_charset] = options[:fraud_http_accept_charset] if options[:fraud_http_accept_charset]
-          post[:fraud_http_referer] = options[:fraud_http_referer] if options[:fraud_http_referer]
-          post[:fraud_http_user_agent] = options[:fraud_http_user_agent] if options[:fraud_http_user_agent]
-        end
-      end
-
-      def commit(action, params)
-        response = parse(ssl_post(self.live_url, post_data(action, params)))
-
-        Response.new(successful?(response), message_from(response), response,
-          :test => test?,
-          :authorization => response[:transaction]
-        )
-      end
-
-      def successful?(response)
-        response[:qpstat] == APPROVED
-      end
-
-      def parse(data)
-        response = {}
-
-        doc = REXML::Document.new(data)
-
-        doc.root.elements.each do |element|
-          response[element.name.to_sym] = element.text
+          QuickpayV10Gateway.new(options)
         end
-
-        response
       end
 
-      def message_from(response)
-        response[:qpstatmsg].to_s
-      end
-
-      def post_data(action, params = {})
-        params[:protocol] = @protocol
-        params[:msgtype]  = action.to_s
-        params[:merchant] = @options[:login]
-        params[:apikey] = @options[:apikey] if @options[:apikey]
-        params[:md5check] = generate_check_hash(action, params)
-
-        params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
-      end
-
-      def generate_check_hash(action, params)
-        string = MD5_CHECK_FIELDS[@protocol][action].collect do |key|
-          params[key.to_sym]
-        end.join('')
-
-        # Add the md5checkword
-        string << @options[:password].to_s
-
-        Digest::MD5.hexdigest(string)
-      end
-
-      def expdate(credit_card)
-        year  = format(credit_card.year, :two_digits)
-        month = format(credit_card.month, :two_digits)
-
-        "#{year}#{month}"
-      end
-
-      # Limited to 20 digits max
-      def format_order_number(number)
-        number.to_s.gsub(/[^\w_]/, '').rjust(4, "0")[0...20]
-      end
     end
   end
 end

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

@@ -0,0 +1,236 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class QvalentGateway < Gateway
+      self.display_name = "Qvalent"
+      self.homepage_url = "https://www.qvalent.com/"
+
+      self.test_url = "https://ccapi.client.support.qvalent.com/post/CreditCardAPIReceiver"
+      self.live_url = "https://ccapi.client.qvalent.com/post/CreditCardAPIReceiver"
+
+      self.supported_countries = ["AU"]
+      self.default_currency = "AUD"
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners]
+
+      def initialize(options={})
+        requires!(options, :username, :password, :merchant, :pem, :pem_password)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_order_number(post, options)
+        add_payment_method(post, payment_method)
+        add_verification_value(post, payment_method)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("capture", post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_order_number(post, options)
+        add_payment_method(post, payment_method)
+        add_verification_value(post, payment_method)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("preauth", post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization, options)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("captureWithoutAuth", post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization, options)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("refund", post)
+      end
+
+      # Credit requires the merchant account to be enabled for "Adhoc Refunds"
+      def credit(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_order_number(post, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("refund", post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization, options)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("reversal", post)
+      end
+
+      def store(payment_method, options = {})
+        post = {}
+        add_payment_method(post, payment_method)
+        add_card_reference(post)
+
+        commit("registerAccount", post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((&?customer.password=)[^&]*), '\1[FILTERED]').
+          gsub(%r((&?card.PAN=)[^&]*), '\1[FILTERED]').
+          gsub(%r((&?card.CVN=)[^&]*), '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
+      CURRENCY_CODES["AUD"] = "AUD"
+      CURRENCY_CODES["INR"] = "INR"
+
+      def add_soft_descriptors(post, options)
+        post["customer.merchantName"] = options[:customer_merchant_name] if options[:customer_merchant_name]
+        post["customer.merchantStreetAddress"] = options[:customer_merchant_street_address] if options[:customer_merchant_street_address]
+        post["customer.merchantLocation"] = options[:customer_merchant_location] if options[:customer_merchant_location]
+        post["customer.merchantState"] = options[:customer_merchant_state] if options[:customer_merchant_state]
+        post["customer.merchantCountry"] = options[:customer_merchant_country] if options[:customer_merchant_country]
+        post["customer.merchantPostCode"] = options[:customer_merchant_post_code] if options[:customer_merchant_post_code]
+        post["customer.subMerchantId"] = options[:customer_sub_merchant_id] if options[:customer_sub_merchant_id]
+      end
+
+      def add_invoice(post, money, options)
+        post["order.amount"] = amount(money)
+        post["card.currency"] = CURRENCY_CODES[options[:currency] || currency(money)]
+        post["order.ECI"] = options[:eci] ? options[:eci] : "SSL"
+      end
+
+      def add_payment_method(post, payment_method)
+        post["card.cardHolderName"] = payment_method.name
+        post["card.PAN"] = payment_method.number
+        post["card.expiryYear"] = format(payment_method.year, :two_digits)
+        post["card.expiryMonth"] = format(payment_method.month, :two_digits)
+      end
+
+      def add_verification_value(post, payment_method)
+        post["card.CVN"] = payment_method.verification_value
+      end
+
+      def add_card_reference(post)
+        post["customer.customerReferenceNumber"] = options[:order_id]
+      end
+
+      def add_reference(post, authorization, options)
+        post["customer.originalOrderNumber"] = authorization
+        add_order_number(post, options)
+      end
+
+      def add_order_number(post, options)
+        post["customer.orderNumber"] = options[:order_id] || SecureRandom.uuid
+      end
+
+      def add_customer_data(post, options)
+        post["order.ipAddress"] = options[:ip] || "127.0.0.1"
+        post["order.xid"] = options[:xid] if options[:xid]
+        post["order.cavv"] = options[:cavv] if options[:cavv]
+      end
+
+      def commit(action, post)
+        post["customer.username"] = @options[:username]
+        post["customer.password"] = @options[:password]
+        post["customer.merchant"] = @options[:merchant]
+        post["order.type"] = action
+
+        data = build_request(post)
+        raw = parse(ssl_post(url(action), data, headers))
+
+        succeeded = success_from(raw["response.responseCode"])
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          authorization: raw["response.orderNumber"] || raw["response.customerReferenceNumber"],
+          error_code: error_code_from(succeeded, raw),
+          test: test?
+        )
+      end
+
+      def headers
+        {
+          "Content-Type"  => "application/x-www-form-urlencoded"
+        }
+      end
+
+      def build_request(post)
+        post.to_query + "&message.end"
+      end
+
+      def url(action)
+        (test? ? test_url : live_url)
+      end
+
+      def parse(body)
+        result = {}
+        body.to_s.each_line do |pair|
+          result[$1] = $2 if pair.strip =~ /\A([^=]+)=(.+)\Z/im
+        end
+        result
+      end
+
+      def parse_element(response, node)
+        if node.has_elements?
+          node.elements.each{|element| parse_element(response, element) }
+        else
+          response[node.name.underscore.to_sym] = node.text
+        end
+      end
+
+      SUCCESS_CODES = %w(00 08 10 11 16 QS QZ)
+
+      def success_from(response)
+        SUCCESS_CODES.include?(response)
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response["response.text"] || "Unable to read error message"
+        end
+      end
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        "14" => STANDARD_ERROR_CODE[:invalid_number],
+        "QQ" => STANDARD_ERROR_CODE[:invalid_cvc],
+        "33" => STANDARD_ERROR_CODE[:expired_card],
+        "NT" => STANDARD_ERROR_CODE[:incorrect_address],
+        "12" => STANDARD_ERROR_CODE[:card_declined],
+        "06" => STANDARD_ERROR_CODE[:processing_error],
+        "01" => STANDARD_ERROR_CODE[:call_issuer],
+        "04" => STANDARD_ERROR_CODE[:pickup_card],
+      }
+
+      def error_code_from(succeeded, response)
+        succeeded ? nil : STANDARD_ERROR_CODE_MAPPING[response["response.responseCode"]]
+      end
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ module ActiveMerchant
     # login - The unique id of the merchant
     # password - The secret is used to digitally sign the request
     # account - This is an optional third part of the authentication process
-    # and is used if the merchant wishes do distuinguish cc traffic from the different sources
+    # and is used if the merchant wishes do distinguish cc traffic from the different sources
     # by using a different account. This must be created in advance
     #
     # the Realex team decided to make the orderid unique per request,
@@ -28,13 +28,14 @@ module ActiveMerchant
         'diners_club'       => 'DINERS',
         'switch'            => 'SWITCH',
         'solo'              => 'SWITCH',
-        'laser'             => 'LASER'
+        'laser'             => 'LASER',
+        'maestro'           => 'MC'
       }
 
       self.money_format = :cents
       self.default_currency = 'EUR'
       self.supported_cardtypes = [ :visa, :master, :american_express, :diners_club, :switch, :solo, :laser ]
-      self.supported_countries = [ 'IE', 'GB' ]
+      self.supported_countries = %w(IE GB FR BE NL LU IT)
       self.homepage_url = 'http://www.realexpayments.com/'
       self.display_name = 'Realex'
 
@@ -73,7 +74,7 @@ module ActiveMerchant
       end
 
       def credit(money, authorization, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, authorization, options)
       end
 
@@ -82,18 +83,28 @@ module ActiveMerchant
         commit(request)
       end
 
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+        gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+        gsub(%r((<number>)\d+(</number>))i, '\1[FILTERED]\2')
+      end
+
       private
       def commit(request)
         response = parse(ssl_post(self.live_url, request))
 
-        Response.new(response[:result] == "00", message_from(response), response,
-          :test => response[:message] =~ /\[ test system \]/,
+        Response.new(
+          (response[:result] == "00"),
+          message_from(response),
+          response,
+          :test => (response[:message] =~ %r{\[ test system \]}),
           :authorization => authorization_from(response),
-          :cvv_result => response[:cvnresult],
-          :avs_result => {
-            :street_match => response[:avspostcoderesponse],
-            :postal_match => response[:avspostcoderesponse]
-          }
+          avs_result: AVSResult.new(code: response[:avspostcoderesponse]),
+          cvv_result: CVVResult.new(response[:cvnresult])
         )
       end
 
@@ -187,14 +198,14 @@ module ActiveMerchant
 
           if billing_address
             xml.tag! 'address', 'type' => 'billing' do
-              xml.tag! 'code', format_shipping_zip_code(billing_address[:zip])
+              xml.tag! 'code', format_address_code(billing_address)
               xml.tag! 'country', billing_address[:country]
             end
           end
 
           if shipping_address
             xml.tag! 'address', 'type' => 'shipping' do
-              xml.tag! 'code', format_shipping_zip_code(shipping_address[:zip])
+              xml.tag! 'code', format_address_code(shipping_address)
               xml.tag! 'country', shipping_address[:country]
             end
           end
@@ -240,8 +251,9 @@ module ActiveMerchant
         end
       end
 
-      def format_shipping_zip_code(zip)
-        zip.to_s.gsub(/\W/, '')
+      def format_address_code(address)
+        code = [address[:zip].to_s, address[:address1].to_s + address[:address2].to_s]
+        code.collect{|e| e.gsub(/\D/, "")}.reject{|e| e.empty?}.join("|")
       end
 
       def new_timestamp
@@ -261,16 +273,6 @@ module ActiveMerchant
         "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
       end
 
-      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(response)
         message = nil
         case response[:result]