activemerchant 1.38.0 → 1.78.0

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

@@ -0,0 +1,152 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MoneyMoversGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.mmoagateway.com/api/transact.php'
+
+      APPROVED, DECLINED, ERROR = 1, 2, 3
+
+      self.homepage_url = 'http://mmoa.us/'
+      self.display_name = 'MoneyMovers'
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        @options = options
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        commit('sale', money, post)
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        commit('auth', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        options[:transactionid] = authorization
+        commit('capture', money, options)
+      end
+
+      def void(authorization, options = {})
+        options[:transactionid] = authorization
+        commit('void', nil, options)
+      end
+
+      def refund(money, authorization, options = {})
+        commit('refund', money, options.merge(:transactionid => authorization))
+      end
+
+      def credit(money, authorization, options = {})
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, authorization, options)
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post[:firstname] = options[:first_name]
+        post[:lastname] = options[:last_name]
+
+        post[:email] = options[:email]
+      end
+
+      def add_address(post, options)
+        if address = (options[:billing_address] || options[:address])
+          post[:company] = address[:company]
+          post[:address1] = address[:address1]
+          post[:address2] = address[:address2]
+          post[:city]    = address[:city]
+          post[:state]   = address[:state]
+          post[:zip]     = address[:zip]
+          post[:country] = address[:country]
+          post[:phone] = address[:phone]
+        end
+        if address = options[:shipping_address]
+          post[:shipping_firstname] = address[:first_name]
+          post[:shipping_lastname] = address[:last_name]
+          post[:shipping_company] = address[:company]
+          post[:shipping_address1] = address[:address1]
+          post[:shipping_address2] = address[:address2]
+          post[:shipping_city]    = address[:city]
+          post[:shipping_state]   = address[:state]
+          post[:shipping_zip]     = address[:zip]
+          post[:shipping_country] = address[:country]
+          post[:shipping_email]   = address[:email]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:ccnumber] = creditcard.number
+        post[:ccexp] = expdate(creditcard)
+        post[:cvv] = creditcard.verification_value
+      end
+
+      def parse(body)
+        body.split('&').inject({}) do |memo, x|
+          k, v = x.split('=')
+          memo[k] = v
+          memo
+        end
+      end
+
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money)
+
+        data = ssl_post(self.live_url, post_data(action, parameters))
+        response = parse(data)
+        message = message_from(response)
+
+        Response.new(success?(response), message, response,
+          :test => test?,
+          :authorization => response['transactionid'],
+          :avs_result => {:code =>  response['avsresponse']},
+          :cvv_result => response['cvvresponse']
+        )
+      end
+
+      def success?(response)
+        response['response'] == '1'
+      end
+
+      def test?
+        (@options[:login].eql?('demo')) && (@options[:password].eql?('password'))
+      end
+
+      def message_from(response)
+        case response['response'].to_i
+        when APPROVED
+          "Transaction Approved"
+        when DECLINED
+          "Transaction Declined"
+        else
+          "Error in transaction data or system error"
+        end
+      end
+
+      def post_data(action, parameters = {})
+        parameters[:type] = action
+        parameters[:username] = @options[:login]
+        parameters[:password] = @options[:password]
+        parameters.map{|k, v| "#{k}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+    end
+  end
+end
+

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

@@ -16,33 +16,25 @@ module ActiveMerchant #:nodoc:
       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
@@ -127,18 +130,20 @@ module ActiveMerchant #:nodoc:
         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', amount(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)