activemerchant 1.38.0 → 1.78.0

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

@@ -2,7 +2,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class MerchantWareVersionFourGateway < Gateway
       self.live_url = 'https://ps1.merchantware.net/Merchantware/ws/RetailTransaction/v4/Credit.asmx'
-      self.test_url = 'https://staging.merchantware.net/Merchantware/ws/RetailTransaction/v4/Credit.asmx'
+      self.test_url = 'https://ps1.merchantware.net/Merchantware/ws/RetailTransaction/v4/Credit.asmx'
 
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
@@ -20,7 +20,7 @@ module ActiveMerchant #:nodoc:
         :reference_purchase => 'RepeatSale',
         :authorize => "PreAuthorizationKeyed",
         :capture   => "PostAuthorization",
-        :void      => "VoidPreAuthorization",
+        :void      => "Void",
         :refund    => "Refund"
       }
 
@@ -108,6 +108,24 @@ module ActiveMerchant #:nodoc:
         commit(:refund, request)
       end
 
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<merchantKey>).+?(</merchantKey>))i, '\1[FILTERED]\2').
+          gsub(%r((<cardNumber>).+?(</cardNumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<cardSecurityCode>).+?(</cardSecurityCode>))i, '\1[FILTERED]\2')
+      end
+
       private
 
       def soap_request(action)
@@ -129,7 +147,7 @@ module ActiveMerchant #:nodoc:
       def build_purchase_request(action, money, payment_source, options)
         requires!(options, :order_id)
 
-        request = soap_request(action) do |xml|
+        soap_request(action) do |xml|
           add_invoice(xml, options)
           add_amount(xml, money)
           add_payment_source(xml, payment_source)
@@ -140,22 +158,15 @@ module ActiveMerchant #:nodoc:
       def build_capture_request(action, money, identification, options)
         reference, options[:order_id] = split_reference(identification)
 
-        request = soap_request(action) do |xml|
+        soap_request(action) do |xml|
           add_reference_token(xml, reference)
           add_invoice(xml, options)
           add_amount(xml, money)
         end
       end
 
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-
       def add_invoice(xml, options)
-        xml.tag! "invoiceNumber", options[:order_id].to_s.gsub(/[^\w]/, '').slice(0, 25)
+        xml.tag! "invoiceNumber", truncate(options[:order_id].to_s.gsub(/[^\w]/, ''), 8)
       end
 
       def add_amount(xml, money, tag = "amount")
@@ -234,7 +245,7 @@ module ActiveMerchant #:nodoc:
 
         response[:message] = response["ErrorMessage"].to_s.gsub("\n", " ")
         response
-      rescue REXML::ParseException => e
+      rescue REXML::ParseException
         response[:http_body]        = http_response.body
         response[:message]          = "Failed to parse the failed response"
         response

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

@@ -12,9 +12,9 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['AU']
       self.supported_cardtypes = [:visa, :master, :american_express,
-                                  :diners_club, :discover]
-      self.homepage_url = 'http://www.merchantwarrior.com/'
-      self.display_name = 'MerchantWarrior'
+                                  :diners_club, :discover, :jcb]
+      self.homepage_url = 'https://www.merchantwarrior.com/'
+      self.display_name = 'Merchant Warrior'
 
       self.money_format = :dollars
       self.default_currency = 'AUD'
@@ -27,7 +27,7 @@ module ActiveMerchant #:nodoc:
       def authorize(money, payment_method, options = {})
         post = {}
         add_amount(post, money, options)
-        add_product(post, options)
+        add_order_id(post, options)
         add_address(post, options)
         add_payment_method(post, payment_method)
         commit('processAuth', post)
@@ -36,13 +36,13 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment_method, options = {})
         post = {}
         add_amount(post, money, options)
-        add_product(post, options)
+        add_order_id(post, options)
         add_address(post, options)
         add_payment_method(post, payment_method)
         commit('processCard', post)
       end
 
-      def capture(money, identification)
+      def capture(money, identification, options = {})
         post = {}
         add_amount(post, money, options)
         add_transaction(post, identification)
@@ -50,7 +50,7 @@ module ActiveMerchant #:nodoc:
         commit('processCapture', post)
       end
 
-      def refund(money, identification)
+      def refund(money, identification, options = {})
         post = {}
         add_amount(post, money, options)
         add_transaction(post, identification)
@@ -60,7 +60,7 @@ module ActiveMerchant #:nodoc:
 
       def store(creditcard, options = {})
         post = {
-          'cardName' => creditcard.name,
+          'cardName' => scrub_name(creditcard.name),
           'cardNumber' => creditcard.number,
           'cardExpiryMonth' => format(creditcard.month, :two_digits),
           'cardExpiryYear'  => format(creditcard.year, :two_digits)
@@ -75,18 +75,21 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_address(post, options)
-        return unless(address = options[:address])
+        return unless(address = (options[:billing_address] || options[:address]))
 
-        post['customerName'] = address[:name]
+        post['customerName'] = scrub_name(address[:name])
         post['customerCountry'] = address[:country]
-        post['customerState'] = address[:state]
+        post['customerState'] = address[:state] || 'N/A'
         post['customerCity'] = address[:city]
         post['customerAddress'] = address[:address1]
         post['customerPostCode'] = address[:zip]
+        post['customerIP'] = address[:ip]
+        post['customerPhone'] = address[:phone]
+        post['customerEmail'] = address[:email]
       end
 
-      def add_product(post, options)
-        post['transactionProduct'] = options[:transaction_product]
+      def add_order_id(post, options)
+        post['transactionProduct'] = truncate(options[:order_id], 34) || SecureRandom.hex(15)
       end
 
       def add_payment_method(post, payment_method)
@@ -103,11 +106,15 @@ module ActiveMerchant #:nodoc:
 
       def add_creditcard(post, creditcard)
         post['paymentCardNumber'] = creditcard.number
-        post['paymentCardName'] = creditcard.name
+        post['paymentCardName'] = scrub_name(creditcard.name)
         post['paymentCardExpiry'] = creditcard.expiry_date.expiration.strftime("%m%y")
         post['paymentCardCSC'] = creditcard.verification_value if creditcard.verification_value?
       end
 
+      def scrub_name(name)
+        name.gsub(/[^a-zA-Z\. -]/, '')
+      end
+
       def add_amount(post, money, options)
         currency = (options[:currency] || currency(money))
 

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

@@ -12,16 +12,22 @@ module ActiveMerchant #:nodoc:
     # and +refund+ will become mandatory.
     class MercuryGateway < Gateway
       URLS = {
-        :test => 'https://w1.mercurydev.net/ws/ws.asmx',
+        :test => 'https://w1.mercurycert.net/ws/ws.asmx',
         :live => 'https://w1.mercurypay.com/ws/ws.asmx'
       }
 
       self.homepage_url = 'http://www.mercurypay.com'
       self.display_name = 'Mercury'
-      self.supported_countries = ['US']
+      self.supported_countries = ['US','CA']
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
       self.default_currency = 'USD'
 
+      STANDARD_ERROR_CODE_MAPPING = {
+        '100204' => STANDARD_ERROR_CODE[:invalid_number],
+        '100205' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '000000' => STANDARD_ERROR_CODE[:card_declined]
+      }
+
       def initialize(options = {})
         requires!(options, :login, :password)
         @use_tokenization = (!options.has_key?(:tokenization) || options[:tokenization])
@@ -66,17 +72,28 @@ module ActiveMerchant #:nodoc:
       def void(authorization, options={})
         requires!(options, :credit_card) unless @use_tokenization
 
-        if options[:try_reversal]
-          request = build_authorized_request('VoidSale', nil, authorization, options[:credit_card], options.merge(:reversal => true))
-          response = commit('VoidSale', request)
-
-          return response if response.success?
-        end
-
         request = build_authorized_request('VoidSale', nil, authorization, options[:credit_card], options)
         commit('VoidSale', request)
       end
 
+      def store(credit_card, options={})
+        request = build_card_lookup_request(credit_card, options)
+        commit('CardLookup', request)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r(&lt;), "<").
+          gsub(%r(&gt;), ">").
+          gsub(%r((<pw>).*(</pw>))i, '\1[FILTERED]\2').
+          gsub(%r((<AcctNo>)(\d|x)*(</AcctNo>))i, '\1[FILTERED]\3').
+          gsub(%r((<CVVData>)\d*(</CVVData>))i, '\1[FILTERED]\2')
+      end
+
       private
 
       def build_non_authorized_request(action, money, credit_card, options)
@@ -86,7 +103,7 @@ module ActiveMerchant #:nodoc:
           xml.tag! "Transaction" do
             xml.tag! 'TranType', 'Credit'
             xml.tag! 'TranCode', action
-            if action == 'PreAuth' || action == 'Sale'
+            if options[:allow_partial_auth] && (action == 'PreAuth' || action == 'Sale')
               xml.tag! "PartialAuth", "Allow"
             end
             add_invoice(xml, options[:order_id], nil, options)
@@ -94,7 +111,7 @@ module ActiveMerchant #:nodoc:
             add_customer_data(xml, options)
             add_amount(xml, money, options)
             add_credit_card(xml, credit_card, action)
-            add_address(xml, options)
+            add_address(xml, options) unless credit_card.track_data.present?
           end
         end
         xml = xml.target!
@@ -104,12 +121,12 @@ module ActiveMerchant #:nodoc:
         xml = Builder::XmlMarkup.new
 
         invoice_no, ref_no, auth_code, acq_ref_data, process_data, record_no, amount = split_authorization(authorization)
-        ref_no = invoice_no if options[:reversal]
+        ref_no = "1" if ref_no.blank?
 
         xml.tag! "TStream" do
           xml.tag! "Transaction" do
             xml.tag! 'TranType', 'Credit'
-            if action == 'PreAuthCapture'
+            if options[:allow_partial_auth] && (action == 'PreAuthCapture')
               xml.tag! "PartialAuth", "Allow"
             end
             xml.tag! 'TranCode', (@use_tokenization ? (action + "ByRecordNo") : action)
@@ -121,19 +138,32 @@ module ActiveMerchant #:nodoc:
             add_address(xml, options)
             xml.tag! 'TranInfo' do
               xml.tag! "AuthCode", auth_code
-              xml.tag! "AcqRefData", acq_ref_data if options[:reversal]
-              xml.tag! "ProcessData", process_data if options[:reversal]
+              xml.tag! "AcqRefData", acq_ref_data
+              xml.tag! "ProcessData", process_data
             end
           end
         end
         xml = xml.target!
       end
 
-      def add_invoice(xml, invoice_no, ref_no, options)
-        if /^\d+$/ !~ invoice_no.to_s
-          raise ArgumentError.new("order_id '#{invoice_no}' is not numeric as required by Mercury")
+      def build_card_lookup_request(credit_card, options)
+        xml = Builder::XmlMarkup.new
+
+        xml.tag! "TStream" do
+          xml.tag! "Transaction" do
+            xml.tag! 'TranType', 'CardLookup'
+            xml.tag! 'RecordNo', 'RecordNumberRequested'
+            xml.tag! 'Frequency', 'OneTime'
+
+            xml.tag! 'Memo', options[:description]
+            add_customer_data(xml, options)
+            add_credit_card(xml, credit_card, options)
+          end
         end
+        xml.target!
+      end
 
+      def add_invoice(xml, invoice_no, ref_no, options)
         xml.tag! 'InvoiceNo', invoice_no
         xml.tag! 'RefNo', (ref_no || invoice_no)
         xml.tag! 'OperatorID', options[:merchant] if options[:merchant]
@@ -177,22 +207,36 @@ module ActiveMerchant #:nodoc:
 
       def add_credit_card(xml, credit_card, action)
         xml.tag! 'Account' do
-          xml.tag! 'AcctNo', credit_card.number
-          xml.tag! 'ExpDate', expdate(credit_card)
+          if credit_card.track_data.present?
+            # Track 1 has a start sentinel (STX) of '%' and track 2 is ';'
+            # Track 1 and 2 have identical end sentinels (ETX) of '?'
+            # Tracks may or may not have checksum (LRC) after the ETX
+            # If the track has no STX or is corrupt, we send it as track 1, to let Mercury
+            #handle with the validation error as it sees fit.
+            # Track 2 requires having the STX and ETX stripped. Track 1 does not.
+            # Max-length track 1s require having the STX and ETX stripped. Max is 79 bytes including LRC.
+            is_track_2 = credit_card.track_data[0] == ';'
+            etx_index = credit_card.track_data.rindex('?') || credit_card.track_data.length
+            is_max_track1 = etx_index >= 77
+
+            if is_track_2
+              xml.tag! 'Track2', credit_card.track_data[1...etx_index]
+            elsif is_max_track1
+              xml.tag! 'Track1', credit_card.track_data[1...etx_index]
+            else
+              xml.tag! 'Track1', credit_card.track_data
+            end
+          else
+            xml.tag! 'AcctNo', credit_card.number
+            xml.tag! 'ExpDate', expdate(credit_card)
+          end
         end
         xml.tag! 'CardType', CARD_CODES[credit_card.brand] if credit_card.brand
 
-        include_cvv = !%w(Return PreAuthCapture).include?(action)
+        include_cvv = !%w(Return PreAuthCapture).include?(action) && !credit_card.track_data.present?
         xml.tag! 'CVVData', credit_card.verification_value if(include_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_address(xml, options)
         if billing_address = options[:billing_address] || options[:address]
           xml.tag! 'AVS' do
@@ -266,7 +310,8 @@ module ActiveMerchant #:nodoc:
           :test => test?,
           :authorization => authorization_from(response),
           :avs_result => { :code => response[:avs_result] },
-          :cvv_result => response[:cvv_result])
+          :cvv_result => response[:cvv_result],
+          :error_code => success ? nil : STANDARD_ERROR_CODE_MAPPING[response[:dsix_return_code]])
       end
 
       def message_from(response)

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

@@ -150,7 +150,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
@@ -218,7 +218,7 @@ module ActiveMerchant #:nodoc:
         post[:delim_data]     = "TRUE"
         post[:delim_char]     = ","
         post[:encap_char]     = "$"
-        post[:solution_ID]    = application_id if application_id.present? && application_id != "ActiveMerchant"
+        post[:solution_ID]    = application_id if application_id
 
         request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join("&")
         request
@@ -284,17 +284,6 @@ module ActiveMerchant #:nodoc:
         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])
@@ -306,17 +295,9 @@ module ActiveMerchant #:nodoc:
         (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/micropayment.rb

@@ -0,0 +1,185 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MicropaymentGateway < Gateway
+
+      self.display_name = "micropayment"
+      self.homepage_url = "https://www.micropayment.de/"
+
+      self.test_url = self.live_url = "https://sipg.micropayment.de/public/creditcardpsp/v1/nvp/"
+
+      self.supported_countries = %w(DE)
+      self.default_currency = "EUR"
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express]
+
+
+      def initialize(options={})
+        requires!(options, :access_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_address(post, options)
+        commit("purchase", post)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method, options)
+        add_customer_data(post, options)
+        add_address(post, options)
+        commit("authorize", post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, amount, options)
+        commit("capture", post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        commit("void", post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, amount, options)
+        commit("refund", post)
+      end
+
+      def verify(credit_card, options={})
+
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(250, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((accessKey=)\w+), '\1[FILTERED]').
+          gsub(%r((number=)\d+), '\1[FILTERED]').
+          gsub(%r((cvc2=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        if money
+          post[:amount] = amount(money)
+          post[:currency] = options[:currency] || currency(money)
+        end
+        post[:project] = options[:project] if options[:project]
+        post["params[title]"] = options[:description] if options[:description]
+      end
+
+      def add_payment_method(post, payment_method, options={})
+        post[:number] = payment_method.number
+        post[:recurring] = 1 if options[:recurring] == true
+        post[:cvc2] = payment_method.verification_value
+        post[:expiryYear] = format(payment_method.year, :four_digits)
+        post[:expiryMonth] = format(payment_method.month, :two_digits)
+
+        post["params[firstname]"] = payment_method.first_name
+        post["params[surname]"] = payment_method.last_name
+      end
+
+      def add_customer_data(post, options)
+        post["params[email]"] = options[:email] if options[:email]
+        post["params[ip]"] = options[:ip] || "1.1.1.1"
+        post["params[sendMail]"] = options[:send_mail] || 'false'
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address]
+        return unless address
+
+        post["params[address]"] = address[:address1] if address[:address1]
+        post["params[zipcode]"] = address[:zip] if address[:zip]
+        post["params[town]"] = address[:city] if address[:city]
+        post["params[country]"] = address[:country] if address[:country]
+      end
+
+      def add_reference(post, authorization)
+        session_id, transaction_id = split_authorization(authorization)
+        post[:sessionId] = session_id
+        post[:transactionId] = transaction_id
+      end
+
+      def commit(action, params)
+        params[:testMode] = 1 if test?
+        params[:accessKey] = @options[:access_key]
+        params[:apiKey] = @options[:api_key] || "af1fd841af792f4c50131414ff76e004"
+
+        response = parse(ssl_post(url(action), post_data(action, params), headers))
+
+        Response.new(
+          succeeded = success_from(response),
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response, params),
+          avs_result: AVSResult.new(code: response["some_avs_result_key"]),
+          cvv_result: CVVResult.new(response["some_cvv_result_key"]),
+          test: test?
+        )
+      end
+
+      def headers
+        { "Content-Type"  => "application/x-www-form-urlencoded;charset=UTF-8" }
+      end
+
+      def post_data(action, params)
+        params.map {|k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+
+      def url(action)
+        action_url = test? ? test_url : live_url
+        "#{action_url}?action=#{action}"
+      end
+
+      def parse(body)
+        body.split(/\r?\n/).inject({}) do |acc, pair|
+          key, value = pair.split("=")
+          acc[key] = CGI.unescape(value)
+          acc
+        end
+      end
+
+      def success_from(response)
+        response["error"] == "0" &&
+          response["transactionResultCode"] == "00" &&
+          response["transactionStatus"] == "SUCCESS"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response["errorMessage"] || response["transactionResultMessage"]
+        end
+      end
+
+      def split_authorization(authorization)
+        authorization.split("|")
+      end
+
+      def authorization_from(response, request_params)
+        session_id = response["sessionId"] ? response["sessionId"] : request_params[:sessionId]
+        "#{session_id}|#{response["transactionId"]}"
+      end
+    end
+  end
+end