activemerchant 1.45.0 → 1.126.0

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

@@ -0,0 +1,163 @@
+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 = %i[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)
+        response[:msoft_code] || response[:phard_code] unless success_from(response)
+      end
+    end
+  end
+end

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

@@ -24,7 +24,7 @@ module ActiveMerchant
     class NetRegistryGateway < Gateway
       self.live_url = self.test_url = 'https://paygate.ssllock.net/external2.pl'
 
-      FILTERED_PARAMS = [ 'card_no', 'card_expiry', 'receipt_array' ]
+      FILTERED_PARAMS = %w[card_no card_expiry receipt_array]
 
       self.supported_countries = ['AU']
 
@@ -32,16 +32,16 @@ module ActiveMerchant
       # steps in setting up your account, as detailed in
       # "Programming for NetRegistry's E-commerce Gateway."
       # [http://rubyurl.com/hNG]
-      self.supported_cardtypes = [:visa, :master, :diners_club, :american_express, :jcb]
+      self.supported_cardtypes = %i[visa master diners_club american_express jcb]
       self.display_name = 'NetRegistry'
       self.homepage_url = 'http://www.netregistry.com.au'
 
       TRANSACTIONS = {
-        :authorization => 'preauth',
-        :purchase => 'purchase',
-        :capture => 'completion',
-        :status => 'status',
-        :refund => 'refund'
+        authorization: 'preauth',
+        purchase: 'purchase',
+        capture: 'completion',
+        status: 'status',
+        refund: 'refund'
       }
 
       # Create a new NetRegistry gateway.
@@ -122,6 +122,7 @@ module ActiveMerchant
       end
 
       private
+
       def add_request_details(params, options)
         params['COMMENT'] = options[:description] unless options[:description].blank?
       end
@@ -130,7 +131,7 @@ module ActiveMerchant
       # format for a command.
       def expiry(credit_card)
         month = format(credit_card.month, :two_digits)
-        year  = format(credit_card.year , :two_digits)
+        year  = format(credit_card.year,  :two_digits)
         "#{month}/#{year}"
       end
 
@@ -141,17 +142,16 @@ module ActiveMerchant
       # omitted if nil.
       def commit(action, params)
         # get gateway response
-        response = parse( ssl_post(self.live_url, post_data(action, params)) )
+        response = parse(ssl_post(self.live_url, post_data(action, params)))
 
         Response.new(response['status'] == 'approved', message_from(response), response,
-          :authorization => authorization_from(response, action)
-        )
+          authorization: authorization_from(response, action))
       end
 
       def post_data(action, params)
         params['COMMAND'] = TRANSACTIONS[action]
         params['LOGIN'] = "#{@options[:login]}/#{@options[:password]}"
-        escape_uri(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

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

@@ -7,10 +7,10 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://epayment.bbs.no/'
 
       # The countries the gateway supports merchants from as 2 digit ISO country codes
-      self.supported_countries = ['NO', 'DK', 'SE', 'FI']
+      self.supported_countries = %w[NO DK SE FI]
 
       # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_cardtypes = %i[visa master american_express]
 
       # The homepage URL of the gateway
       self.homepage_url = 'http://www.betalingsterminal.no/Netthandel-forside/'
@@ -31,8 +31,8 @@ module ActiveMerchant #:nodoc:
         requires!(options, :order_id)
 
         MultiResponse.run do |r|
-          r.process{authorize(money, creditcard, options)}
-          r.process{capture(money, r.authorization, options)}
+          r.process { authorize(money, creditcard, options) }
+          r.process { capture(money, r.authorization, options) }
         end
       end
 
@@ -40,9 +40,9 @@ module ActiveMerchant #:nodoc:
         requires!(options, :order_id)
 
         MultiResponse.run do |r|
-          r.process{setup_transaction(money, options)}
-          r.process{add_and_auth_credit_card(r.authorization, creditcard, options)}
-          r.process{query_transaction(r.authorization, options)}
+          r.process { setup_transaction(money, options) }
+          r.process { add_and_auth_credit_card(r.authorization, creditcard, options) }
+          r.process { query_transaction(r.authorization, options) }
         end
       end
 
@@ -50,24 +50,24 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization, money)
-        post[:operation] = "Capture"
-        commit("Netaxept/process.aspx", post)
+        post[:operation] = 'Capture'
+        commit('Netaxept/process.aspx', post)
       end
 
       def refund(money, authorization, options = {})
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization, money)
-        post[:operation] = "Credit"
-        commit("Netaxept/process.aspx", post)
+        post[:operation] = 'Credit'
+        commit('Netaxept/process.aspx', post)
       end
 
       def void(authorization, options = {})
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization)
-        post[:operation] = "Annul"
-        commit("Netaxept/process.aspx", post)
+        post[:operation] = 'Annul'
+        commit('Netaxept/process.aspx', post)
       end
 
       private
@@ -76,7 +76,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_credentials(post, options)
         add_order(post, money, options)
-        commit("Netaxept/Register.aspx", post)
+        commit('Netaxept/Register.aspx', post)
       end
 
       def add_and_auth_credit_card(authorization, creditcard, options)
@@ -84,22 +84,22 @@ module ActiveMerchant #:nodoc:
         add_credentials(post, options, false)
         add_authorization(post, authorization)
         add_creditcard(post, creditcard)
-        commit("terminal/default.aspx", post, false)
+        commit('terminal/default.aspx', post, false)
       end
 
       def query_transaction(authorization, options)
         post = {}
         add_credentials(post, options)
         add_authorization(post, authorization)
-        commit("Netaxept/query.aspx", post)
+        commit('Netaxept/query.aspx', post)
       end
 
-      def add_credentials(post, options, secure=true)
+      def add_credentials(post, options, secure = true)
         post[:merchantId] = @options[:login]
         post[:token] = @options[:password] if secure
       end
 
-      def add_authorization(post, authorization, money=nil)
+      def add_authorization(post, authorization, money = nil)
         post[:transactionId] = authorization
         post[:transactionAmount] = amount(money) if money
       end
@@ -109,7 +109,7 @@ module ActiveMerchant #:nodoc:
         post[:orderNumber] = options[:order_id]
         post[:amount] = amount(money)
         post[:currencyCode] = (options[:currency] || currency(money))
-        post[:autoAuth] = "true"
+        post[:autoAuth] = 'true'
       end
 
       def add_creditcard(post, options)
@@ -118,17 +118,17 @@ module ActiveMerchant #:nodoc:
         post[:securityCode] = options.verification_value
       end
 
-      def commit(path, parameters, xml=true)
+      def commit(path, parameters, xml = true)
         raw = parse(ssl_get(build_url(path, parameters)), xml)
 
         success = false
-        authorization = (raw["TransactionId"] || parameters[:transactionId])
-        if raw[:container] =~ /Exception|Error/
-          message = (raw["Message"] || raw["Error"]["Message"])
-        elsif raw["Error"] && !raw["Error"].empty?
-          message = (raw["Error"]["ResponseText"] || raw["Error"]["ResponseCode"])
+        authorization = (raw['TransactionId'] || parameters[:transactionId])
+        if /Exception|Error/.match?(raw[:container])
+          message = (raw['Message'] || raw['Error']['Message'])
+        elsif raw['Error'] && !raw['Error'].empty?
+          message = (raw['Error']['ResponseText'] || raw['Error']['ResponseCode'])
         else
-          message = (raw["ResponseText"] || raw["ResponseCode"] || "OK")
+          message = (raw['ResponseText'] || raw['ResponseCode'] || 'OK')
           success = true
         end
 
@@ -136,17 +136,17 @@ module ActiveMerchant #:nodoc:
           success,
           message,
           raw,
-          :test => test?,
-          :authorization => authorization
+          test: test?,
+          authorization: authorization
         )
       end
 
-      def parse(result, expects_xml=true)
+      def parse(result, expects_xml = true)
         if expects_xml
           doc = REXML::Document.new(result)
-          extract_xml(doc.root).merge(:container => doc.root.name)
+          extract_xml(doc.root).merge(container: doc.root.name)
         else
-          {:result => result}
+          { result: result }
         end
       end
 
@@ -162,7 +162,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def build_url(base, parameters=nil)
+      def build_url(base, parameters = nil)
         url = (test? ? self.test_url : self.live_url).dup
         url << base
         if parameters
@@ -173,9 +173,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def encode(hash)
-        hash.collect{|(k,v)| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"}.join('&')
+        hash.collect { |(k, v)| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
       end
     end
   end
 end
-