activemerchant 1.133.0 → 1.138.0

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

@@ -1,7 +1,7 @@
 require 'rexml/document'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class VerifiGateway < Gateway
       class VerifiPostData < PostData
         # Fields that will be sent even if they are blank
@@ -180,10 +180,10 @@ module ActiveMerchant #:nodoc:
         # MD5(username|password|orderid|amount|time)
         now = Time.now.to_i.to_s
         md5 = Digest::MD5.new
-        md5 << @options[:login].to_s + '|'
-        md5 << @options[:password].to_s + '|'
-        md5 << options[:order_id].to_s + '|'
-        md5 << amount(money).to_s + '|'
+        md5 << (@options[:login].to_s + '|')
+        md5 << (@options[:password].to_s + '|')
+        md5 << (options[:order_id].to_s + '|')
+        md5 << (amount(money).to_s + '|')
         md5 << now
         post[:key]  = md5.hexdigest
         post[:time] = now
@@ -194,11 +194,15 @@ module ActiveMerchant #:nodoc:
 
         response = parse(ssl_post(self.live_url, post_data(trx_type, post)))
 
-        Response.new(response[:response].to_i == SUCCESS, message_from(response), response,
+        Response.new(
+          response[:response].to_i == SUCCESS,
+          message_from(response),
+          response,
           test: test?,
           authorization: response[:transactionid],
           avs_result: { code: response[:avsresponse] },
-          cvv_result: response[:cvvresponse])
+          cvv_result: response[:cvvresponse]
+        )
       end
 
       def message_from(response)

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

@@ -0,0 +1,307 @@
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
+    class VersaPayGateway < Gateway
+      self.test_url = 'https://uat.versapay.com'
+      self.live_url = 'https://secure.versapay.com'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://www.versapay.com/'
+      self.display_name = 'VersaPay'
+
+      def initialize(options = {})
+        requires!(options, :api_token, :api_key)
+        @api_token = options[:api_token]
+        @api_key = options[:api_key]
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        transact(money, payment, options)
+      end
+
+      def authorize(money, payment, options = {})
+        transact(money, payment, options, 'auth')
+      end
+
+      def capture(money, authorization, options = {})
+        post = {
+          amount_cents: money,
+          transaction: authorization
+        }
+        commit('capture', post)
+      end
+
+      def verify(credit_card, options = {})
+        transact(0, credit_card, options, 'verify')
+      end
+
+      def void(authorization, options = {})
+        commit('void', { transaction: authorization })
+      end
+
+      def refund(money, authorization, options = {})
+        post = {
+          amount_cents: money,
+          transaction: authorization
+        }
+        commit('refund', post)
+      end
+
+      def credit(money, payment_method, options = {})
+        transact(money, payment_method, options, 'credit')
+      end
+
+      def store(payment_method, options = {})
+        post = {
+          contact: { email: options[:email] }
+        }
+        add_customer_data(post, options)
+        add_payment_method(post, payment_method, options)
+        commit('store', post)
+      end
+
+      def unstore(authorization, options = {})
+        wallet_token, fund_token = authorization.split('|')
+        commit('unstore', {}, :delete, { fund_token:, wallet_token: })
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r(("card_number\\?":\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def transact(money, payment, options = {}, type = 'sale')
+        post = {
+          contact: { email: options[:email] }
+        }
+        add_invoice(post, money, options)
+        add_order(post, money, options)
+        add_payment_method(post, payment, options)
+        commit(type, post)
+      end
+
+      def add_customer_data(post, options)
+        post[:customer_identifier] = options[:customer_identifier] if options[:customer_identifier]
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount_cents] = amount(money)
+        post[:currency] = options[:currency] || currency(money)
+      end
+
+      def add_order(post, money, options = {})
+        order = {
+          identifier: options[:order_id],
+          number: options[:order_number],
+          date: options[:order_date] || Time.now.strftime('%Y-%m-%d'),
+          draft: false,
+          settlement_token: options[:settlement_token] # A settlement token reference (see whoami response structure) representing the merchant/bank processor configuration that should be used for transaction settlement.
+        }.compact
+
+        add_invoice(order, money, options)
+        add_address(order, options, 'shipping')
+        add_address(order, options)
+        post[:order] = order
+      end
+
+      def add_address(post, options, address_key = 'billing', hash = 'order')
+        address = options["#{address_key}_address".to_sym]
+        return unless address
+
+        address_data = {
+          address_1: address[:address1],
+          city: address[:city],
+          province: address[:state],
+          postal_code: address[:zip],
+          country: Country.find(address[:country]).code(:alpha3).value
+        }
+
+        if hash == 'payment_method'
+          post[:address] = address_data
+        else
+          post.merge!({
+            "#{address_key}_name": address[:company],
+            "#{address_key}_address": address[:address1],
+            "#{address_key}_address2": address[:address2],
+            "#{address_key}_city": address[:city],
+            "#{address_key}_country": address_data[:country],
+            "#{address_key}_email": options[:email],
+            "#{address_key}_telephone": address[:phone] || address[:phone_number],
+            "#{address_key}_postalcode": address[:zip],
+            "#{address_key}_state_province": address[:state]
+          }.compact)
+        end
+      end
+
+      def add_payment_method(post, payment_method, options)
+        if payment_method.is_a?(CreditCard)
+          post[:credit_card] = {
+            name: payment_method.name,
+            expiry_month: format(payment_method.month, :two_digits),
+            expiry_year: payment_method.year,
+            card_number: payment_method.number,
+            cvv: payment_method.verification_value
+          }
+          add_address(post[:credit_card], options, 'billing', 'payment_method')
+        elsif payment_method.is_a?(String)
+          fund_token = payment_method.split('|').last
+          post[:fund_token] = fund_token
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body).with_indifferent_access
+      rescue JSON::ParserError => e
+        {
+          errors: body,
+          status: 'Unable to parse JSON response',
+          message: e.message
+        }.with_indifferent_access
+      end
+
+      def commit(action, post, method = :post, options = {})
+        raw_response = ssl_request(method, url(action, options), post.to_json, request_headers)
+        response = parse(raw_response)
+        first_transaction = response['transactions']&.first
+
+        Response.new(
+          success_from(response, action),
+          message_from(response, action),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: dig_avs_code(first_transaction)),
+          cvv_result: CVVResult.new(dig_cvv_code(first_transaction)),
+          test: test?,
+          error_code: error_code_from(response, action)
+        )
+      end
+
+      def success_from(response, action)
+        case action
+        when 'store'
+          response['wallet_token'] || response['fund_token'] || false
+        when 'unstore'
+          response['fund_token'] || false
+        else
+          response['success'] || false
+        end
+      end
+
+      def message_from(response, action)
+        return 'Succeeded' if success_from(response, action)
+
+        first_transaction = response['transactions']&.first
+        gateway_response_errors = gateway_errors_message(response)
+
+        response_message = {
+          error: response.dig('error') || response.dig('wallets', 'error'),
+          errors: response.dig('errors')&.join(', ').presence,
+          gateway_error_message: first_transaction&.dig('gateway_error_message').presence,
+          gateway_response_errors: gateway_response_errors.presence
+        }.compact
+
+        response_message.map { |key, value| "#{key}: #{value}" }.join(' | ')
+      end
+
+      def authorization_from(response)
+        transaction = response['transaction']
+        wallet_token = response['wallet_token'] || response.dig('wallets', 0, 'token')
+        fund_token = response['fund_token'] || response.dig('wallets', 0, 'credit_cards', 0, 'token')
+        [transaction, wallet_token, fund_token].compact.join('|')
+      end
+
+      def error_code_from(response, action)
+        return if success_from(response, action)
+
+        response.dig('transactions', 0, 'gateway_error_code')
+      end
+
+      def gateway_errors_message(response)
+        errors = response.dig('transactions', 0, 'gateway_response', 'errors')
+        return unless errors.is_a?(Hash)
+
+        errors.flat_map do |field, error_details|
+          error_details.flat_map do |error|
+            if error.is_a?(Hash)
+              error.map { |key, messages| "[#{field} - #{key}: #{messages.join(', ')}]" }
+            else
+              "[#{field} - #{error}]"
+            end
+          end
+        end.join(' , ')
+      end
+
+      def url(endpoint, options = {})
+        case endpoint
+        when 'unstore'
+          parameters = "/#{options[:wallet_token]}/methods/#{options[:fund_token]}"
+          "#{test? ? test_url : live_url}/api/gateway/v1/wallets#{parameters}"
+        when 'store'
+          "#{test? ? test_url : live_url}/api/gateway/v1/wallets"
+        else
+          "#{test? ? test_url : live_url}/api/gateway/v1/orders/#{endpoint}"
+        end
+      end
+
+      def basic_auth
+        Base64.strict_encode64("#{@api_token}:#{@api_key}")
+      end
+
+      def request_headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Basic #{basic_auth}"
+        }
+      end
+
+      def dig_cvv_code(first_transaction)
+        return unless first_transaction
+
+        first_transaction.dig('cvv_response') ||
+          first_transaction.dig('gateway_response', 'cvv_response') ||
+          find_cvv_avs_code(first_transaction, 'cvvresponse')
+      end
+
+      def dig_avs_code(first_transaction)
+        return unless first_transaction
+
+        first_transaction.dig('avs_response') ||
+          first_transaction.dig('gateway_response', 'avs_response') ||
+          find_cvv_avs_code(first_transaction, 'avsresponse')
+      end
+
+      def find_cvv_avs_code(first_transaction, to_find)
+        nested_response = first_transaction.dig(
+          'gateway_response',
+          'gateway_response',
+          'response', 'content',
+          'create'
+        )
+        return nil unless nested_response.is_a?(Array)
+
+        nested_response.find { |x| x.dig('transaction', to_find) }&.dig('transaction', to_find)
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200..412
+          response.body
+        else
+          response.body || raise(ResponseError.new(response)) # some errors 500 has the error message
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class ViaklixGateway < Gateway
       class_attribute :test_url, :live_url, :delimiter, :actions
 
@@ -136,11 +136,15 @@ module ActiveMerchant #:nodoc:
 
         response = parse(ssl_post(test? ? self.test_url : self.live_url, post_data(parameters)))
 
-        Response.new(response['result'] == APPROVED, message_from(response), response,
+        Response.new(
+          response['result'] == APPROVED,
+          message_from(response),
+          response,
           test: @options[:test] || test?,
           authorization: authorization_from(response),
           avs_result: { code: response['avs_response'] },
-          cvv_result: response['cvv2_response'])
+          cvv_result: response['cvv2_response']
+        )
       end
 
       def authorization_from(response)

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class VisanetPeruGateway < Gateway
       include Empty
       self.display_name = 'VisaNet Peru Gateway'
@@ -134,7 +134,7 @@ module ActiveMerchant #:nodoc:
         params[:externalReferenceId] = params.delete(:externalTransactionId)
         _, transaction_id = split_authorization(authorization)
 
-        options.update(transaction_id: transaction_id)
+        options.update(transaction_id:)
         params[:ruc] = options[:ruc]
       end
 
@@ -143,12 +143,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def generate_purchase_number_stamp
-        Time.now.to_f.to_s.delete('.')[1..10] + rand(99).to_s
+        rand(('9' * 12).to_i).to_s.center(12, rand(9).to_s)
       end
 
       def commit(action, params, options = {})
         raw_response = ssl_request(method(action), url(action, params, options), params.to_json, headers)
-        response = parse(raw_response)
+        response = parse(raw_response).merge('purchaseNumber' => params[:purchaseNumber])
       rescue ResponseError => e
         raw_response = e.response.body
         response_error(raw_response, options, action)

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

@@ -1,8 +1,8 @@
 require 'digest'
 require 'jwe'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class VposGateway < Gateway
       self.test_url = 'https://vpos.infonet.com.py:8888'
       self.live_url = 'https://vpos.infonet.com.py'
@@ -20,14 +20,15 @@ module ActiveMerchant #:nodoc:
         pci_encryption_key: '/vpos/api/0.3/application/encryption-key',
         pay_pci_buy_encrypted: '/vpos/api/0.3/pci/encrypted',
         pci_buy_rollback: '/vpos/api/0.3/pci_buy/rollback',
-        refund: '/vpos/api/0.3/refunds'
+        refund: '/vpos/api/0.3/refunds',
+        inquire: '/vpos/api/0.3/pci_buy/confirmations'
       }
 
       def initialize(options = {})
         requires!(options, :private_key, :public_key)
         @private_key = options[:private_key]
         @public_key = options[:public_key]
-        @encryption_key = OpenSSL::PKey::RSA.new(options[:encryption_key]) if options[:encryption_key]
+        @encryption_key = OpenSSL::PKey::RSA.new(options[:encryption_key]) if options[:encryption_key].is_a?(String)
         @shop_process_id = options[:shop_process_id] || SecureRandom.random_number(10**15)
         super
       end
@@ -54,12 +55,21 @@ module ActiveMerchant #:nodoc:
         commit(:pay_pci_buy_encrypted, post)
       end
 
+      def inquire(authorization, options = {})
+        _, shop_process_id = authorization.to_s.split('#') if authorization
+        shop_process_id = options[:shop_process_id] if options[:shop_process_id]
+        token = generate_token(shop_process_id, 'get_confirmation')
+
+        post = { token:, shop_process_id: }
+        commit(:inquire, post)
+      end
+
       def void(authorization, options = {})
         _, shop_process_id = authorization.to_s.split('#')
         token = generate_token(shop_process_id, 'rollback', '0.00')
         post = {
-          token: token,
-          shop_process_id: shop_process_id
+          token:,
+          shop_process_id:
         }
         commit(:pci_buy_rollback, post)
       end
@@ -118,7 +128,7 @@ module ActiveMerchant #:nodoc:
       # Required to encrypt PAN data.
       def one_time_public_key
         token = generate_token('get_encription_public_key', @public_key)
-        response = commit(:pci_encryption_key, token: token)
+        response = commit(:pci_encryption_key, token:)
         response.params['encryption_key']
       end
 
@@ -137,7 +147,7 @@ module ActiveMerchant #:nodoc:
         card_number = payment.number
         cvv = payment.verification_value
 
-        payload = { card_number: card_number, 'cvv': cvv }.to_json
+        payload = { card_number:, cvv: }.to_json
 
         encryption_key = @encryption_key || OpenSSL::PKey::RSA.new(one_time_public_key)
 
@@ -158,14 +168,14 @@ module ActiveMerchant #:nodoc:
         url = build_request_url(action)
         begin
           response = parse(ssl_post(url, post_data(parameters)))
-        rescue ResponseError => response
+        rescue ResponseError => e
           # Errors are returned with helpful data,
           # but get filtered out by `ssl_post` because of their HTTP status.
-          response = parse(response.response.body)
+          response = parse(e.response.body)
         end
 
         Response.new(
-          success_from(response),
+          success_from(response, action),
           message_from(response),
           response,
           authorization: authorization_from(response),
@@ -176,8 +186,10 @@ module ActiveMerchant #:nodoc:
         )
       end
 
-      def success_from(response)
-        if code = response.dig('confirmation', 'response_code')
+      def success_from(response, action = nil)
+        if action == :refund && (code = response.dig('refund', 'response_code'))
+          code == '00'
+        elsif code = response.dig('confirmation', 'response_code')
           code == '00'
         else
           response['status'] == 'success'

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

@@ -1,7 +1,7 @@
 require 'json'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class WebpayGateway < StripeGateway
       self.live_url = 'https://api.webpay.jp/v1/'
 
@@ -84,7 +84,7 @@ module ActiveMerchant #:nodoc:
         }
       end
 
-      def headers(options = {})
+      def headers(method = :post, options = {})
         {
           'Authorization' => 'Basic ' + Base64.encode64(@api_key.to_s + ':').strip,
           'User-Agent' => "Webpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",

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

@@ -1,8 +1,10 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class WepayGateway < Gateway
-      self.test_url = 'https://stage.wepayapi.com/v2'
-      self.live_url = 'https://wepayapi.com/v2'
+      version 'v2'
+
+      self.test_url = "https://stage.wepayapi.com/#{fetch_version}"
+      self.live_url = "https://wepayapi.com/#{fetch_version}"
 
       self.supported_countries = %w[US CA]
       self.supported_cardtypes = %i[visa master american_express discover]

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

@@ -1,7 +1,7 @@
 require 'base64'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class WirecardGateway < Gateway
       self.test_url = 'https://c3-test.wirecard.com/secure/ssl-gateway'
       self.live_url = 'https://c3.wirecard.com/secure/ssl-gateway'
@@ -179,11 +179,15 @@ module ActiveMerchant #:nodoc:
         message = response[:Message]
         authorization = response[:GuWID]
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test?,
-          authorization: authorization,
+          authorization:,
           avs_result: { code: avs_code(response, options) },
-          cvv_result: response[:CVCResponseCode])
+          cvv_result: response[:CVCResponseCode]
+        )
       rescue ResponseError => e
         if e.response.code == '401'
           return Response.new(false, 'Invalid Login')
@@ -405,7 +409,7 @@ module ActiveMerchant #:nodoc:
         'N' => 'I', # CSC Match
         'U' => 'U', # Data Not Checked
         'Y' => 'D', # All Data Matched
-        'Z' => 'P', # CSC and Postcode Matched
+        'Z' => 'P' # CSC and Postcode Matched
       }
 
       # Amex have different AVS response codes to visa etc

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

@@ -1,8 +1,10 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class WompiGateway < Gateway
-      self.test_url = 'https://sync.sandbox.wompi.co/v1'
-      self.live_url = 'https://sync.production.wompi.co/v1'
+      version 'v1'
+
+      self.test_url = "https://sync.sandbox.wompi.co/#{fetch_version}"
+      self.live_url = "https://sync.production.wompi.co/#{fetch_version}"
 
       self.supported_countries = ['CO']
       self.default_currency = 'COP'
@@ -31,9 +33,10 @@ module ActiveMerchant #:nodoc:
       def purchase(money, payment, options = {})
         post = {
           reference: options[:reference] || generate_reference,
-          public_key: public_key
+          public_key:
         }
         add_invoice(post, money, options)
+        add_tip_in_cents(post, options)
         add_card(post, payment, options)
 
         commit('sale', post, '/transactions_sync')
@@ -41,7 +44,7 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, payment, options = {})
         post = {
-          public_key: public_key,
+          public_key:,
           type: 'CARD',
           financial_operation: 'PREAUTHORIZATION'
         }
@@ -53,7 +56,7 @@ module ActiveMerchant #:nodoc:
       def capture(money, authorization, options = {})
         post = {
           reference: options[:reference] || generate_reference,
-          public_key: public_key,
+          public_key:,
           payment_source_id: authorization.to_i
         }
         add_invoice(post, money, options)
@@ -141,6 +144,10 @@ module ActiveMerchant #:nodoc:
         post[:cvc] = cvc if cvc && !cvc.empty?
       end
 
+      def add_tip_in_cents(post, options)
+        post[:tip_in_cents] = options[:tip_in_cents].to_i if options[:tip_in_cents]
+      end
+
       def parse(body)
         JSON.parse(body)
       end

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # See https://helpdesk.worldnettps.com/support/solutions/articles/1000167298-integrator-guide
     class WorldNetGateway < Gateway
       self.test_url = 'https://testpayments.worldnettps.com/merchant/xmlpayment'