activemerchant 1.114.0 → 1.120.0

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

@@ -70,7 +70,7 @@ module ActiveMerchant #:nodoc:
 
       # MiGS works by merchants being either purchase only or authorize/capture
       # So authorize is the same as purchase when in authorize mode
-      alias_method :authorize, :purchase
+      alias authorize purchase
 
       # ==== Options
       #
@@ -123,7 +123,7 @@ module ActiveMerchant #:nodoc:
         refund(money, authorization, options)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -286,8 +286,7 @@ module ActiveMerchant #:nodoc:
           authorization: response[:TransactionNo],
           fraud_review: fraud_review?(response),
           avs_result: { code: avs_response_code },
-          cvv_result: cvv_result_code
-        )
+          cvv_result: cvv_result_code)
       end
 
       def success?(response)

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

@@ -148,15 +148,13 @@ module ActiveMerchant #:nodoc:
       def commit(action, params)
         data = ssl_post(url(action), build_request(action, params),
           { 'Content-Type' => 'text/xml; charset=utf-8',
-            'SOAPAction' => "#{xmlns(action)}#{action}" }
-        )
+            'SOAPAction' => "#{xmlns(action)}#{action}" })
 
         response = parse(action, data)
         Response.new(successful?(action, response), message_from(action, response), response,
           test: test?,
           authorization: authorization_from(action, response),
-          avs_result: { code: response[:avs_code] }
-        )
+          avs_result: { code: response[:avs_code] })
       end
 
       def authorization_from(action, response)

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

@@ -29,7 +29,7 @@ module ActiveMerchant #:nodoc:
       #           :login      User login
       #           :pwd        User password
       #
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :sender_id, :channel_id, :login, :pwd)
         super
       end
@@ -45,7 +45,7 @@ module ActiveMerchant #:nodoc:
       #               :currency         Sale currency to override money object or default (optional)
       #
       # Returns Active Merchant response object
-      def purchase(money, credit_card, options={})
+      def purchase(money, credit_card, options = {})
         execute_new_order(:purchase, money, credit_card, options)
       end
 
@@ -60,7 +60,7 @@ module ActiveMerchant #:nodoc:
       #               :currency         Sale currency to override money object or default (optional)
       #
       # Returns Active Merchant response object
-      def authorize(money, credit_card, options={})
+      def authorize(money, credit_card, options = {})
         execute_new_order(:authorize, money, credit_card, options)
       end
 
@@ -76,7 +76,7 @@ module ActiveMerchant #:nodoc:
       # Note: you should pass either order_id or description
       #
       # Returns Active Merchant response object
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         execute_dependant(:capture, money, authorization, options)
       end
 
@@ -92,7 +92,7 @@ module ActiveMerchant #:nodoc:
       # Note: you should pass either order_id or description
       #
       # Returns Active Merchant response object
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         execute_dependant(:refund, money, authorization, options)
       end
 
@@ -103,7 +103,7 @@ module ActiveMerchant #:nodoc:
       #                 :order_id         Merchant created id for the authorization (optional)
       #
       # Returns Active Merchant response object
-      def void(authorization, options={})
+      def void(authorization, options = {})
         execute_dependant(:void, nil, authorization, options)
       end
 
@@ -117,7 +117,7 @@ module ActiveMerchant #:nodoc:
       #               :currency         Sale currency to override money object or default (optional)
       #
       # Returns Active Merchant response object of Authorization operation
-      def verify(credit_card, options={})
+      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) }

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

@@ -133,7 +133,7 @@ module ActiveMerchant #:nodoc:
         commit 'refund', crediting_params(authorization, amount: amount(money))
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         requires!(options, :order_id)
         post = {}
         add_payment_source(post, credit_card, options)
@@ -302,9 +302,10 @@ module ActiveMerchant #:nodoc:
           message_from(response[:message]),
           response,
           test: test?,
-          avs_result: {code: response[:avs_result_code]},
+          avs_result: { code: response[:avs_result_code] },
           cvv_result: response[:cvd_result_code] && response[:cvd_result_code][-1, 1],
-          authorization: authorization_from(response))
+          authorization: authorization_from(response)
+        )
       end
 
       # Generates a Moneris authorization string of the form 'trans_id;receipt_id'.

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

@@ -116,9 +116,8 @@ module ActiveMerchant #:nodoc:
         Response.new(success?(response), message, response,
           test: test?,
           authorization: response['transactionid'],
-          avs_result: {code: response['avsresponse']},
-          cvv_result: response['cvvresponse']
-        )
+          avs_result: { code: response['avsresponse'] },
+          cvv_result: response['cvvresponse'])
       end
 
       def success?(response)

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

@@ -28,48 +28,50 @@ module ActiveMerchant #:nodoc:
         '500' => 'An internal error occurred;'
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :api_key)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_customer_data(post, options) unless payment.is_a?(String)
         add_shipping_address(post, options)
         add_payment(post, payment, options)
+        add_submerchant(post, options)
 
         commit('sale', post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_customer_data(post, options) unless payment.is_a?(String)
         add_shipping_address(post, options)
         add_payment(post, payment, options)
         add_capture_flag(post, payment)
+        add_submerchant(post, options)
         commit('authonly', post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         post[:code] = authorization
         add_invoice(post, money, options)
         commit('capture', post, authorization)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         add_invoice(post = {}, money, options)
         commit('refund', post, authorization)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         commit('void', nil, authorization)
       end
 
-      def store(payment, options={})
+      def store(payment, options = {})
         post = {}
         options.update(name: payment.name)
         options = add_customer(options) unless options[:customer_id]
@@ -77,7 +79,7 @@ module ActiveMerchant #:nodoc:
         commit('store', post, options[:customer_id])
       end
 
-      def verify(credit_card, options={})
+      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) }
@@ -202,6 +204,31 @@ module ActiveMerchant #:nodoc:
         %w[sodexo vr].include? card_brand(payment)
       end
 
+      def add_submerchant(post, options)
+        if submerchant = options[:submerchant]
+          post[:SubMerchant] = {}
+          post[:SubMerchant][:Merchant_Category_Code] = submerchant[:merchant_category_code] if submerchant[:merchant_category_code]
+          post[:SubMerchant][:Payment_Facilitator_Code] = submerchant[:payment_facilitator_code] if submerchant[:payment_facilitator_code]
+          post[:SubMerchant][:Code] = submerchant[:code] if submerchant[:code]
+          post[:SubMerchant][:Name] = submerchant[:name] if submerchant[:name]
+          post[:SubMerchant][:Document] = submerchant[:document] if submerchant[:document]
+          post[:SubMerchant][:Type] = submerchant[:type] if submerchant[:type]
+          post[:SubMerchant][:Phone] = {}
+          post[:SubMerchant][:Phone][:Country_Code] = submerchant[:phone][:country_code] if submerchant.dig(:phone, :country_code)
+          post[:SubMerchant][:Phone][:Number] = submerchant[:phone][:number] if submerchant.dig(:phone, :number)
+          post[:SubMerchant][:Phone][:Area_Code] = submerchant[:phone][:area_code] if submerchant.dig(:phone, :area_code)
+          post[:SubMerchant][:Address] = {}
+          post[:SubMerchant][:Address][:Street] = submerchant[:address][:street] if submerchant.dig(:address, :street)
+          post[:SubMerchant][:Address][:Number] = submerchant[:address][:number] if submerchant.dig(:address, :number)
+          post[:SubMerchant][:Address][:Complement] = submerchant[:address][:complement] if submerchant.dig(:address, :complement)
+          post[:SubMerchant][:Address][:Neighborhood] = submerchant[:address][:neighborhood] if submerchant.dig(:address, :neighborhood)
+          post[:SubMerchant][:Address][:City] = submerchant[:address][:city] if submerchant.dig(:address, :city)
+          post[:SubMerchant][:Address][:State] = submerchant[:address][:state] if submerchant.dig(:address, :state)
+          post[:SubMerchant][:Address][:Country] = submerchant[:address][:country] if submerchant.dig(:address, :country)
+          post[:SubMerchant][:Address][:Zip_Code] = submerchant[:address][:zip_code] if submerchant.dig(:address, :zip_code)
+        end
+      end
+
       def headers
         {
           'Authorization' => 'Basic ' + Base64.strict_encode64("#{@options[:api_key]}:"),
@@ -275,7 +302,7 @@ module ActiveMerchant #:nodoc:
         parsed_response_body = parse(error.response.body)
         message = parsed_response_body['message']
 
-        parsed_response_body['errors']&.each do |type, descriptions|
+        parsed_response_body['errors']&.each do |_type, descriptions|
           message += ' | '
           message += descriptions.join(', ')
         end
@@ -291,7 +318,7 @@ module ActiveMerchant #:nodoc:
         error_string = ''
 
         response['last_transaction']['gateway_response']['errors']&.each do |error|
-          error.each do |key, value|
+          error.each do |_key, value|
             error_string += ' | ' unless error_string.blank?
             error_string += value
           end

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

@@ -235,16 +235,14 @@ module ActiveMerchant #:nodoc:
 
         Response.new(success?(response), message_from(response), response,
           test: test?,
-          authorization: authorization_from(action, response)
-        )
+          authorization: authorization_from(action, response))
       end
 
       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(action, response)
-        )
+          authorization: authorization_from(action, response))
       end
 
       def success?(response)

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

@@ -13,12 +13,12 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'http://www.ncrretailonline.com'
       self.display_name = 'NCR Secure Pay'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :username, :password)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment(post, payment)
@@ -27,7 +27,7 @@ module ActiveMerchant #:nodoc:
         commit('sale', post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment(post, payment)
@@ -36,7 +36,7 @@ module ActiveMerchant #:nodoc:
         commit('preauth', post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         add_reference(post, authorization)
         add_invoice(post, money, options)
@@ -44,7 +44,7 @@ module ActiveMerchant #:nodoc:
         commit('preauthcomplete', post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         add_reference(post, authorization)
         add_invoice(post, money, options)
@@ -52,13 +52,13 @@ module ActiveMerchant #:nodoc:
         commit('credit', post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_reference(post, authorization)
         commit('void', post)
       end
 
-      def verify(credit_card, options={})
+      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) }

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

@@ -145,8 +145,7 @@ module ActiveMerchant
         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)

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

@@ -94,12 +94,12 @@ module ActiveMerchant #:nodoc:
         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
@@ -118,7 +118,7 @@ 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
@@ -141,12 +141,12 @@ module ActiveMerchant #:nodoc:
         )
       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)
         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

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

@@ -22,12 +22,28 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://processing.paysafe.com/'
       self.display_name = 'Netbanx by PaySafe'
 
-      def initialize(options={})
+      AVS_CODE_CONVERTER = {
+        'MATCH' => 'X',
+        'MATCH_ADDRESS_ONLY' => 'A',
+        'MATCH_ZIP_ONLY' => 'Z',
+        'NO_MATCH' => 'N',
+        'NOT_PROCESSED' => 'U',
+        'UNKNOWN' => 'Q'
+      }
+
+      CVV_CODE_CONVERTER = {
+        'MATCH' => 'M',
+        'NO_MATCH' => 'N',
+        'NOT_PROCESSED' => 'P',
+        'UNKNOWN' => 'U'
+      }
+
+      def initialize(options = {})
         requires!(options, :account_number, :api_key)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         # Do a Verification with AVS prior to purchase
         verification_response = verify(payment, options)
         return verification_response if verification_response.message != 'OK'
@@ -36,11 +52,12 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, money, options)
         add_settle_with_auth(post)
         add_payment(post, payment, options)
+        add_customer_detail_data(post, options)
 
         commit(:post, 'auths', post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         # Do a Verification with AVS prior to Auth + Settle
         verification_response = verify(payment, options)
         return verification_response if verification_response.message != 'OK'
@@ -48,18 +65,19 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_invoice(post, money, options)
         add_payment(post, payment, options)
+        add_customer_detail_data(post, options)
 
         commit(:post, 'auths', post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         add_invoice(post, money, options)
 
         commit(:post, "auths/#{authorization}/settlements", post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         # If the transactions that are pending, API call needs to be Cancellation
         settlement_data = get_settlement(authorization)
         return settlement_data if settlement_data.message != 'OK'
@@ -86,14 +104,14 @@ module ActiveMerchant #:nodoc:
         commit(:get, "settlements/#{authorization}", post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_order_id(post, options)
 
         commit(:post, "auths/#{authorization}/voidauths", post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         post = {}
         add_payment(post, credit_card, options)
         add_order_id(post, options)
@@ -103,7 +121,7 @@ module ActiveMerchant #:nodoc:
 
       # note: when passing options[:customer] we only attempt to add the
       #       card to the profile_id passed as the options[:customer]
-      def store(credit_card, options={})
+      def store(credit_card, options = {})
         # locale can only be one of en_US, fr_CA, en_GB
         requires!(options, :locale)
         post = {}
@@ -147,6 +165,15 @@ module ActiveMerchant #:nodoc:
         post[:locale] = options[:locale]
       end
 
+      def add_customer_detail_data(post, options)
+        post[:profile] ||= {}
+        post[:profile][:email] = options[:email] if options[:email]
+        post[:customerIp] = options[:ip] if options[:ip]
+        if (billing_address = options[:billing_address])
+          post[:profile][:firstName], post[:profile][:lastName] = split_names(billing_address[:name])
+        end
+      end
+
       def add_credit_card(post, credit_card, options = {})
         post[:card] ||= {}
         post[:card][:cardNum]    = credit_card.number
@@ -245,11 +272,19 @@ module ActiveMerchant #:nodoc:
           test: test?,
           error_code: error_code_from(response),
           authorization: authorization_from(success, get_url(uri), method, response),
-          avs_result: AVSResult.new(code: response['avsResponse']),
-          cvv_result: CVVResult.new(response['cvvVerification'])
+          avs_result: avs_result(response),
+          cvv_result: cvv_result(response)
         )
       end
 
+      def avs_result(response)
+        AVSResult.new(code: AVS_CODE_CONVERTER[response['avsResponse']])
+      end
+
+      def cvv_result(response)
+        CVVResult.new(CVV_CODE_CONVERTER[response['cvvVerification']])
+      end
+
       def get_url(uri)
         url = (test? ? test_url : live_url)
         if /^customervault/.match?(uri)