activemerchant 1.38.0 → 1.79.2

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

@@ -10,39 +10,31 @@ module ActiveMerchant #:nodoc:
 
       class_attribute :test_periodic_url, :live_periodic_url
 
-      self.test_url = 'https://transact.nab.com.au/test/xmlapi/payment'
+      self.test_url = 'https://demo.transact.nab.com.au/xmlapi/payment'
       self.live_url = 'https://transact.nab.com.au/live/xmlapi/payment'
       self.test_periodic_url = 'https://transact.nab.com.au/xmlapidemo/periodic'
       self.live_periodic_url = 'https://transact.nab.com.au/xmlapi/periodic'
 
       self.supported_countries = ['AU']
-
-      # The card types supported by the payment gateway
-      # Note that support for Diners, Amex, and JCB require extra
-      # steps in setting up your account, as detailed in the NAB Transact API
       self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
 
       self.homepage_url = 'http://transact.nab.com.au'
       self.display_name = 'NAB Transact'
-
-      cattr_accessor :request_timeout
-      self.request_timeout = 60
-
       self.money_format = :cents
       self.default_currency = 'AUD'
 
       #Transactions currently accepted by NAB Transact XML API
       TRANSACTIONS = {
-        :purchase => 0,         #Standard Payment
-        :refund => 4,           #Refund
-        :void => 6,             #Client Reversal (Void)
-        :authorization => 10,   #Preauthorise
-        :capture => 11          #Preauthorise Complete (Advice)
+        :purchase => 0,           #Standard Payment
+        :refund => 4,             #Refund
+        :void => 6,               #Client Reversal (Void)
+        :unmatched_refund => 666, #Unmatched Refund
+        :authorization => 10,     #Preauthorise
+        :capture => 11            #Preauthorise Complete (Advice)
       }
 
       PERIODIC_TYPES = {
         :addcrn    => 5,
-        :editcrn   => 5,
         :deletecrn => 5,
         :trigger   => 8
       }
@@ -57,15 +49,16 @@ module ActiveMerchant #:nodoc:
 
       def purchase(money, credit_card_or_stored_id, options = {})
         if credit_card_or_stored_id.respond_to?(:number)
-          #Credit card for instant payment
           commit :purchase, build_purchase_request(money, credit_card_or_stored_id, options)
         else
-          #Triggered payment for an existing stored credit card
-          options[:billing_id] = credit_card_or_stored_id.to_s
-          commit_periodic build_periodic_item(:trigger, money, nil, options)
+          commit_periodic(:trigger, build_purchase_using_stored_card_request(money, credit_card_or_stored_id, options))
         end
       end
 
+      def credit(money, credit_card, options = {})
+        commit :unmatched_refund, build_purchase_request(money, credit_card, options)
+      end
+
       def refund(money, authorization, options = {})
         commit :refund, build_reference_request(money, authorization, options)
       end
@@ -78,14 +71,24 @@ module ActiveMerchant #:nodoc:
         commit :capture, build_reference_request(money, authorization, options)
       end
 
-      def store(creditcard, options = {})
-        requires!(options, :billing_id, :amount)
-        commit_periodic(build_periodic_item(:addcrn, options[:amount], creditcard, options))
+      def store(credit_card, options = {})
+        commit_periodic(:addcrn, build_store_request(credit_card, options))
       end
 
       def unstore(identification, options = {})
-        options[:billing_id] = identification
-        commit_periodic(build_periodic_item(:deletecrn, options[:amount], nil, options))
+        commit_periodic(:deletecrn, build_unstore_request(identification, options))
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        return "" if transcript.blank?
+        transcript.
+          gsub(%r((<cardNumber>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<cvv>)[^<]+(<))i, '\1[FILTERED]\2').
+          gsub(%r((<password>)[^<]+(<))i, '\1[FILTERED]\2')
       end
 
       private
@@ -101,7 +104,7 @@ module ActiveMerchant #:nodoc:
 
       def build_purchase_request(money, credit_card, options)
         xml = Builder::XmlMarkup.new
-        xml.tag! 'amount', amount(money)
+        xml.tag! 'amount', localized_amount(money, options[:currency] || currency(money))
         xml.tag! 'currency', options[:currency] || currency(money)
         xml.tag! 'purchaseOrderNo', options[:order_id].to_s.gsub(/[ ']/, '')
 
@@ -121,24 +124,26 @@ module ActiveMerchant #:nodoc:
 
         transaction_id, order_id, preauth_id, original_amount = reference.split('*')
 
-        xml.tag! 'amount', (money ? amount(money) : original_amount)
+        xml.tag! 'amount', (money ? localized_amount(money, options[:currency] || currency(money)) : original_amount)
         xml.tag! 'currency', options[:currency] || currency(money)
         xml.tag! 'txnID', transaction_id
         xml.tag! 'purchaseOrderNo', order_id
         xml.tag! 'preauthID', preauth_id
 
+        add_metadata(xml, options)
+
         xml.target!
       end
 
       #Generate payment request XML
-      # - API is set to allow multiple Txn's but currentlu only allows one
+      # - API is set to allow multiple Txn's but currently only allows one
       # - txnSource = 23 - (XML)
       def build_request(action, body)
         xml = Builder::XmlMarkup.new
         xml.instruct!
         xml.tag! 'NABTransactMessage' do
           xml.tag! 'MessageInfo' do
-            xml.tag! 'messageID', Utils.generate_unique_id.slice(0, 30)
+            xml.tag! 'messageID', SecureRandom.hex(15)
             xml.tag! 'messageTimestamp', generate_timestamp
             xml.tag! 'timeoutValue', request_timeout
             xml.tag! 'apiVersion', API_VERSION
@@ -164,32 +169,12 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
-      def build_periodic_item(action, money, credit_card, options)
-        xml = Builder::XmlMarkup.new
-
-        xml.tag! 'actionType', action.to_s
-        xml.tag! 'periodicType', PERIODIC_TYPES[action] if PERIODIC_TYPES[action]
-        xml.tag! 'currency', options[:currency] || currency(money)
-        xml.tag! 'crn', options[:billing_id]
-
-        if credit_card
-          xml.tag! 'CreditCardInfo' do
-            xml.tag! 'cardNumber', credit_card.number
-            xml.tag! 'expiryDate', expdate(credit_card)
-            xml.tag! 'cvv', credit_card.verification_value if credit_card.verification_value?
-          end
-        end
-        xml.tag! 'amount', amount(money)
-
-        xml.target!
-      end
-
-      def build_periodic_request(body)
+      def build_periodic_request(action, body)
         xml = Builder::XmlMarkup.new
         xml.instruct!
         xml.tag! 'NABTransactMessage' do
           xml.tag! 'MessageInfo' do
-            xml.tag! 'messageID', ActiveMerchant::Utils.generate_unique_id.slice(0, 30)
+            xml.tag! 'messageID', SecureRandom.hex(15)
             xml.tag! 'messageTimestamp', generate_timestamp
             xml.tag! 'timeoutValue', request_timeout
             xml.tag! 'apiVersion', PERIODIC_API_VERSION
@@ -204,6 +189,8 @@ module ActiveMerchant #:nodoc:
           xml.tag! 'Periodic' do
             xml.tag! 'PeriodicList', "count" => 1 do
               xml.tag! 'PeriodicItem', "ID" => 1 do
+                xml.tag! 'actionType', action.to_s
+                xml.tag! 'periodicType', PERIODIC_TYPES[action] if PERIODIC_TYPES[action]
                 xml << body
               end
             end
@@ -213,20 +200,50 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def build_purchase_using_stored_card_request(money, identification, options)
+        xml = Builder::XmlMarkup.new
+
+        xml.tag! 'crn', identification
+        xml.tag! 'currency', options[:currency] || currency(money)
+        xml.tag! 'amount', localized_amount(money, options[:currency] || currency(money))
+
+        xml.target!
+      end
+
+      def build_store_request(credit_card, options)
+        xml = Builder::XmlMarkup.new
+
+        xml.tag! 'crn', options[:billing_id] || SecureRandom.hex(10)
+        xml.tag! 'CreditCardInfo' do
+          xml.tag! 'cardNumber', credit_card.number
+          xml.tag! 'expiryDate', expdate(credit_card)
+          xml.tag! 'cvv', credit_card.verification_value if credit_card.verification_value?
+        end
+
+        xml.target!
+      end
+
+      def build_unstore_request(identification, options)
+        xml = Builder::XmlMarkup.new
+
+        xml.tag! 'crn', identification
+        xml.target!
+      end
+
       def commit(action, request)
         response = parse(ssl_post(test? ? self.test_url : self.live_url, build_request(action, request)))
 
         Response.new(success?(response), message_from(response), response,
           :test => test?,
-          :authorization => authorization_from(response)
+          :authorization => authorization_from(action, response)
         )
       end
 
-      def commit_periodic(request)
-        response = parse(ssl_post(test? ? self.test_periodic_url : self.live_periodic_url, build_periodic_request(request)))
+      def commit_periodic(action, request)
+        response = parse(ssl_post(test? ? self.test_periodic_url : self.live_periodic_url, build_periodic_request(action, request)))
         Response.new(success?(response), message_from(response), response,
           :test => test?,
-          :authorization => authorization_from(response)
+          :authorization => authorization_from(action, response)
         )
       end
 
@@ -234,8 +251,12 @@ module ActiveMerchant #:nodoc:
         SUCCESS_CODES.include?(response[:response_code])
       end
 
-      def authorization_from(response)
-        [response[:txn_id], response[:purchase_order_no], response[:preauth_id], response[:amount]].join('*')
+      def authorization_from(action, response)
+        if action == :addcrn
+          response[:crn]
+        else
+          [response[:txn_id], response[:purchase_order_no], response[:preauth_id], response[:amount]].join('*')
+        end
       end
 
       def message_from(response)
@@ -272,6 +293,10 @@ module ActiveMerchant #:nodoc:
         time.strftime("%Y%d%m%H%M%S#{time.usec}+000")
       end
 
+      def request_timeout
+        @options[:request_timeout] || 60
+      end
+
     end
   end
 end

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

@@ -0,0 +1,165 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NcrSecurePayGateway < Gateway
+      self.test_url = 'https://testbox.monetra.com:8665/'
+      self.live_url = 'https://portal.ncrsecurepay.com:8444/'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      self.homepage_url = 'http://www.ncrretailonline.com'
+      self.display_name = 'NCR Secure Pay'
+
+      def initialize(options={})
+        requires!(options, :username, :password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, payment)
+        add_address(post, payment, options)
+
+        commit('preauth', post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, money, options)
+
+        commit('preauthcomplete', post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        add_invoice(post, money, options)
+
+        commit('credit', post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+        commit('void', post)
+      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((<password>)[^<]*(</password>))i, '\1[FILTERED]\2').
+          gsub(%r((<account>)[^<]*(</account>))i, '\1[FILTERED]\2').
+          gsub(%r((<cv>)[^<]*(</cv>))i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_reference(post, reference)
+        post[:ttid] = reference
+      end
+
+      def add_address(post, payment, options)
+        address = options[:billing_address] || options[:address]
+        post[:zip] = address[:zip]
+        post[:street] = address[:address1]
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:descmerch] = options[:merchant] if options[:merchant]
+        post[:ordernum] = options[:order_id] if options[:order_id]
+        post[:comments] = options[:description] if options[:description]
+      end
+
+      def add_payment(post, payment)
+        post[:cardholdername] = payment.name
+        post[:account] = payment.number
+        post[:cv] = payment.verification_value
+        post[:expdate] = expdate(payment)
+      end
+
+      def parse(body)
+        doc = Nokogiri::XML(body)
+        doc.remove_namespaces!
+        response = doc.xpath("/MonetraResp/Resp")[0]
+        resp_params = {}
+
+        response.elements.each do |node|
+          resp_params[node.name.downcase.to_sym] = node.text
+        end
+        resp_params
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_post(url, request_body(action, parameters)))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response[:code] == "AUTH"
+      end
+
+      def message_from(response)
+        response[:verbiage]
+      end
+
+      def authorization_from(response)
+        response[:ttid]
+      end
+
+      def request_body(action, parameters = {})
+        Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |xml|
+          xml.MonetraTrans do
+            xml.Trans(identifier: parameters.delete(:identifier) || "1") do
+              xml.username(options[:username])
+              xml.password(options[:password])
+              xml.action(action)
+              parameters.each do |name, value|
+                xml.send(name, value)
+              end
+            end
+          end
+        end.to_xml
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          response[:msoft_code] || response[:phard_code]
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module ActiveMerchant
     # response will contain a 'receipt' parameter
     # (response.params['receipt']) if a receipt was issued by the gateway.
     class NetRegistryGateway < Gateway
-      self.live_url = self.test_url = 'https://4tknox.au.com/cgi-bin/themerchant.au.com/ecom/external2.pl'
+      self.live_url = self.test_url = 'https://paygate.ssllock.net/external2.pl'
 
       FILTERED_PARAMS = [ 'card_no', 'card_expiry', 'receipt_array' ]
 
@@ -104,7 +104,7 @@ module ActiveMerchant
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
@@ -151,7 +151,12 @@ module ActiveMerchant
       def post_data(action, params)
         params['COMMAND'] = TRANSACTIONS[action]
         params['LOGIN'] = "#{@options[:login]}/#{@options[:password]}"
-        URI.encode(params.map{|k,v| "#{k}=#{v}"}.join('&'))
+        escape_uri(params.map{|k,v| "#{k}=#{v}"}.join('&'))
+      end
+
+      # The upstream is picky and so we can't use CGI.escape like we want to
+      def escape_uri(uri)
+        URI::DEFAULT_PARSER.escape(uri)
       end
 
       def parse(response)