activemerchant 1.133.0 → 1.138.0

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class WorldpayOnlinePaymentsGateway < Gateway
       self.live_url = 'https://api.worldpay.com/v1/'
 
@@ -34,14 +34,16 @@ module ActiveMerchant #:nodoc:
         if authorization
           commit(:post, "orders/#{CGI.escape(authorization)}/capture", { 'captureAmount' => money }, options, 'capture')
         else
-          Response.new(false,
+          Response.new(
+            false,
             'FAILED',
             'FAILED',
             test: test?,
             authorization: false,
             avs_result: {},
             cvv_result: {},
-            error_code: false)
+            error_code: false
+          )
         end
       end
 
@@ -84,8 +86,7 @@ module ActiveMerchant #:nodoc:
           },
           'clientKey' => @client_key
         }
-        token_response = commit(:post, 'tokens', obj, { 'Authorization' => @service_key }, 'token')
-        token_response
+        commit(:post, 'tokens', obj, { 'Authorization' => @service_key }, 'token')
       end
 
       def create_post_for_auth_or_purchase(token, money, options)
@@ -134,7 +135,10 @@ module ActiveMerchant #:nodoc:
 
           raw_response = ssl_request(method, self.live_url + url, json, headers(options))
 
-          if raw_response != ''
+          if raw_response == ''
+            success = true
+            response = {}
+          else
             response = parse(raw_response)
             if type == 'token'
               success = response.key?('token')
@@ -151,9 +155,6 @@ module ActiveMerchant #:nodoc:
                 end
               end
             end
-          else
-            success = true
-            response = {}
           end
         rescue ResponseError => e
           raw_response = e.response.body
@@ -170,14 +171,16 @@ module ActiveMerchant #:nodoc:
           authorization = response['message']
         end
 
-        Response.new(success,
+        Response.new(
+          success,
           success ? 'SUCCESS' : response['message'],
           response,
           test: test?,
-          authorization: authorization,
+          authorization:,
           avs_result: {},
           cvv_result: {},
-          error_code: success ? nil : response['customCode'])
+          error_code: success ? nil : response['customCode']
+        )
       end
 
       def test?

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class WorldpayUsGateway < Gateway
       class_attribute :backup_url
 

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

@@ -0,0 +1,244 @@
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
+    class XpayGateway < Gateway
+      self.display_name = 'XPay Gateway'
+      self.homepage_url = 'https://developer.nexi.it/en'
+
+      version 'v1'
+
+      self.test_url = "https://xpaysandbox.nexigroup.com/api/phoenix-0.0/psp/api/#{fetch_version}/"
+      self.live_url = "https://xpay.nexigroup.com/api/phoenix-0.0/psp/api/#{fetch_version}/"
+
+      self.supported_countries = %w(AT BE CY EE FI FR DE GR IE IT LV LT LU MT PT SK SI ES BG HR DK NO PL RO RO SE CH HU)
+      self.default_currency = 'EUR'
+      self.currencies_without_fractions = %w(BGN HRK DKK NOK GBP PLN CZK RON SEK CHF HUF)
+      self.money_format = :cents
+      self.supported_cardtypes = %i[visa master maestro american_express jcb]
+
+      ENDPOINTS_MAPPING = {
+        validation: 'orders/3steps/validation',
+        purchase: 'orders/3steps/payment',
+        authorize: 'orders/3steps/payment',
+        preauth: 'orders/3steps/init',
+        capture: 'operations/%s/captures',
+        verify: 'orders/card_verification',
+        refund: 'operations/%s/refunds'
+      }
+
+      SUCCESS_MESSAGES = %w(PENDING AUTHORIZED THREEDS_VALIDATED EXECUTED).freeze
+
+      def initialize(options = {})
+        requires!(options, :api_key)
+        @api_key = options[:api_key]
+        super
+      end
+
+      def preauth(amount, credit_card, options = {})
+        order_request(:preauth, amount, {}, credit_card, options)
+      end
+
+      def purchase(amount, credit_card, options = {})
+        complete_order_request(:purchase, amount, credit_card, options)
+      end
+
+      def authorize(amount, credit_card, options = {})
+        complete_order_request(:authorize, amount, credit_card, options)
+      end
+
+      def capture(amount, authorization, options = {})
+        operation_request(:capture, amount, authorization, options)
+      end
+
+      def refund(amount, authorization, options = {})
+        operation_request(:refund, amount, authorization, options)
+      end
+
+      def verify(credit_card, options = {})
+        post = {}
+        add_invoice(post, 0, options)
+        add_customer_data(post, credit_card, options)
+        add_credit_card(post, credit_card)
+        commit(:verify, post, options)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((X-Api-Key: )(\w|-)+), '\1[FILTERED]').
+          gsub(%r(("pan\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def validation(options = {})
+        post = {}
+        add_3ds_validation_params(post, options)
+        commit(:validation, post, options)
+      end
+
+      def complete_order_request(action, amount, credit_card, options = {})
+        MultiResponse.run do |r|
+          r.process { validation(options) }
+          r.process { order_request(action, amount, { captureType: (action == :authorize ? 'EXPLICIT' : 'IMPLICIT') }, credit_card, options.merge!(validation: r.params)) }
+        end
+      end
+
+      def order_request(action, amount, post, credit_card, options = {})
+        add_invoice(post, amount, options)
+        add_credit_card(post, credit_card)
+        add_customer_data(post, credit_card, options)
+        add_address(post, options)
+        add_recurrence(post, options) unless options[:operation_id]
+        add_exemptions(post, options)
+        add_3ds_params(post, options[:validation]) if options[:validation]
+
+        commit(action, post, options)
+      end
+
+      def operation_request(action, amount, authorization, options)
+        options[:correlation_id], options[:reference] = authorization.split('#')
+        commit(action, { amount:, currency: options[:currency] }, options)
+      end
+
+      def add_invoice(post, amount, options)
+        currency = options[:currency] || currency(amount)
+        post[:order] = {
+          orderId: options[:order_id],
+          amount: localized_amount(amount, currency),
+          currency:
+        }.compact
+      end
+
+      def add_credit_card(post, credit_card)
+        post[:card] = {
+          pan: credit_card.number,
+          expiryDate: expdate(credit_card),
+          cvv: credit_card.verification_value
+        }
+      end
+
+      def add_customer_data(post, credit_card, options)
+        post[:order][:customerInfo] = {
+          cardHolderName: credit_card.name,
+          cardHolderEmail: options[:email]
+        }.compact
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post[:order][:customerInfo][:billingAddress] = {
+            name: address[:name],
+            street: address[:address1],
+            additionalInfo: address[:address2],
+            city: address[:city],
+            postCode: address[:zip],
+            country: address[:country]
+          }.compact
+        end
+
+        if address = options[:shipping_address]
+          post[:order][:customerInfo][:shippingAddress] = {
+            name: address[:name],
+            street: address[:address1],
+            additionalInfo: address[:address2],
+            city: address[:city],
+            postCode: address[:zip],
+            country: address[:country]
+          }.compact
+        end
+      end
+
+      def add_recurrence(post, options)
+        post[:recurrence] = { action: options[:recurrence] || 'NO_RECURRING' }
+      end
+
+      def add_exemptions(post, options)
+        post[:exemptions] = options[:exemptions] || 'NO_PREFERENCE'
+      end
+
+      def add_3ds_params(post, validation)
+        post[:threeDSAuthData] = {
+          authenticationValue: validation['threeDSAuthResult']['authenticationValue'],
+          eci: validation['threeDSAuthResult']['eci'],
+          xid: validation['threeDSAuthResult']['xid']
+        }
+        post[:operationId] = validation['operation']['operationId']
+      end
+
+      def add_3ds_validation_params(post, options)
+        post[:operationId] = options[:operation_id]
+        post[:threeDSAuthResponse] = options[:three_ds_auth_response]
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, params, options)
+        options[:correlation_id] ||= SecureRandom.uuid
+        transaction_id = transaction_id_from(params, options, action)
+        raw_response =
+          begin
+            url = build_request_url(action, transaction_id)
+            ssl_post(url, params.to_json, request_headers(options, action))
+          rescue ResponseError => e
+            { errors: [code: e.response.code, description: e.response.body] }.to_json
+          end
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(action, response),
+          message_from(response),
+          response,
+          authorization: authorization_from(options[:correlation_id], response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def request_headers(options, action = nil)
+        headers = { 'X-Api-Key' => @api_key, 'Content-Type' => 'application/json', 'Correlation-Id' => options[:correlation_id] }
+        headers.merge!('Idempotency-Key' => options[:idempotency_key] || SecureRandom.uuid) if %i[capture refund].include?(action)
+        headers
+      end
+
+      def transaction_id_from(params, options, action = nil)
+        case action
+        when :refund, :capture
+          return options[:reference]
+        else
+          return params[:operation_id]
+        end
+      end
+
+      def build_request_url(action, id = nil)
+        "#{test? ? test_url : live_url}#{ENDPOINTS_MAPPING[action.to_sym] % id}"
+      end
+
+      def success_from(action, response)
+        case action
+        when :capture, :refund
+          response.include?('operationId') && response.include?('operationTime')
+        else
+          SUCCESS_MESSAGES.include?(response.dig('operation', 'operationResult'))
+        end
+      end
+
+      def message_from(response)
+        response['operationId'] || response.dig('operation', 'operationResult') || response.dig('errors', 0, 'description')
+      end
+
+      def authorization_from(correlation_id, response = {})
+        [correlation_id, (response['operationId'] || response.dig('operation', 'operationId'))].join('#')
+      end
+
+      def error_code_from(response)
+        response.dig('errors', 0, 'code')
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/network_tokenization_credit_card.rb

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class NetworkTokenizationCreditCard < CreditCard
       # A +NetworkTokenizationCreditCard+ object represents a tokenized credit card
       # using the EMV Network Tokenization specification, http://www.emvco.com/specifications.aspx?id=263.
@@ -14,7 +14,7 @@ module ActiveMerchant #:nodoc:
       self.require_verification_value = false
       self.require_name = false
 
-      attr_accessor :payment_cryptogram, :eci, :transaction_id, :metadata
+      attr_accessor :payment_cryptogram, :eci, :transaction_id, :metadata, :payment_data
       attr_writer :source
 
       SOURCES = %i(apple_pay android_pay google_pay network_token)
@@ -31,6 +31,18 @@ module ActiveMerchant #:nodoc:
         true
       end
 
+      def network_token?
+        source == :network_token
+      end
+
+      def mobile_wallet?
+        %i[apple_pay android_pay google_pay].include?(source)
+      end
+
+      def encrypted_wallet?
+        payment_data.present?
+      end
+
       def type
         'network_tokenization'
       end

data/lib/active_merchant/billing/payment_token.rb

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # Base class representation of cryptographic payment data tokens that may be used for EMV-style transactions
     # like Apple Pay. Payment data may be transmitted via any data type, and may also be padded
     # with metadata specific to the cryptographer. This metadata should be parsed and interpreted in concrete

data/lib/active_merchant/billing/response.rb

@@ -1,10 +1,10 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class Error < ActiveMerchantError #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
+    class Error < ActiveMerchantError # :nodoc:
     end
 
     class Response
-      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result, :error_code, :emv_authorization, :network_transaction_id
+      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result, :error_code, :emv_authorization, :network_transaction_id, :pending
 
       def success?
         @success
@@ -30,6 +30,7 @@ module ActiveMerchant #:nodoc:
         @error_code = options[:error_code]
         @emv_authorization = options[:emv_authorization]
         @network_transaction_id = options[:network_transaction_id]
+        @pending = options[:pending] || false
 
         @avs_result = if options[:avs_result].kind_of?(AVSResult)
                         options[:avs_result].to_hash
@@ -100,11 +101,11 @@ module ActiveMerchant #:nodoc:
       end
 
       %w(params message test authorization error_code emv_authorization test? fraud_review?).each do |m|
-        class_eval %(
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
           def #{m}
             (@responses.empty? ? nil : primary_response.#{m})
           end
-        )
+        RUBY
       end
     end
   end

data/lib/active_merchant/billing.rb

@@ -1,4 +1,5 @@
 require 'active_merchant/errors'
+require 'active_merchant/versionable'
 
 require 'active_merchant/billing/avs_result'
 require 'active_merchant/billing/cvv_result'

data/lib/active_merchant/connection.rb

@@ -18,27 +18,13 @@ module ActiveMerchant
     RETRY_SAFE = false
     RUBY_184_POST_HEADERS = { 'Content-Type' => 'application/x-www-form-urlencoded' }
 
-    attr_accessor :endpoint
-    attr_accessor :open_timeout
-    attr_accessor :read_timeout
-    attr_accessor :verify_peer
-    attr_accessor :ssl_version
+    attr_accessor :endpoint, :open_timeout, :read_timeout, :verify_peer, :ssl_version, :ca_file, :ca_path, :pem, :pem_password, :logger, :tag, :ignore_http_status, :max_retries, :proxy_address, :proxy_port, :proxy_user, :proxy_password
+
     if Net::HTTP.instance_methods.include?(:min_version=)
       attr_accessor :min_version
       attr_accessor :max_version
     end
-    attr_reader :ssl_connection
-    attr_accessor :ca_file
-    attr_accessor :ca_path
-    attr_accessor :pem
-    attr_accessor :pem_password
-    attr_reader :wiredump_device
-    attr_accessor :logger
-    attr_accessor :tag
-    attr_accessor :ignore_http_status
-    attr_accessor :max_retries
-    attr_accessor :proxy_address
-    attr_accessor :proxy_port
+    attr_reader :ssl_connection, :wiredump_device
 
     def initialize(endpoint)
       @endpoint     = endpoint.is_a?(URI) ? endpoint : URI.parse(endpoint)
@@ -58,6 +44,8 @@ module ActiveMerchant
       @ssl_connection = {}
       @proxy_address = :ENV
       @proxy_port = nil
+      @proxy_user = nil
+      @proxy_password = nil
     end
 
     def wiredump_device=(device)
@@ -72,7 +60,7 @@ module ActiveMerchant
       headers = headers.dup
       headers['connection'] ||= 'close'
 
-      retry_exceptions(max_retries: max_retries, logger: logger, tag: tag) do
+      retry_exceptions(max_retries:, logger:, tag:) do
         info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
 
         result = nil
@@ -88,7 +76,7 @@ module ActiveMerchant
               http.get(endpoint.request_uri, headers)
             when :post
               debug body
-              http.post(endpoint.request_uri, body, RUBY_184_POST_HEADERS.merge(headers))
+              http.post(endpoint.request_uri, body, headers.reverse_merge!(RUBY_184_POST_HEADERS))
             when :put
               debug body
               http.put(endpoint.request_uri, body, headers)
@@ -125,7 +113,7 @@ module ActiveMerchant
 
     def http
       @http ||= begin
-        http = Net::HTTP.new(endpoint.host, endpoint.port, proxy_address, proxy_port)
+        http = Net::HTTP.new(endpoint.host, endpoint.port, proxy_address, proxy_port, proxy_user, proxy_password)
         configure_debugging(http)
         configure_timeouts(http)
         configure_ssl(http)

data/lib/active_merchant/country.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-module ActiveMerchant #:nodoc:
+module ActiveMerchant # :nodoc:
   class InvalidCountryCodeError < StandardError
   end
 
@@ -9,6 +9,7 @@ module ActiveMerchant #:nodoc:
 
   class CountryCode
     attr_reader :value, :format
+
     def initialize(value)
       @value = value.to_s.upcase
       detect_format
@@ -309,6 +310,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'VU', name: 'Vanuatu', alpha3: 'VUT', numeric: '548' },
       { alpha2: 'VE', name: 'Venezuela', alpha3: 'VEN', numeric: '862' },
       { alpha2: 'VN', name: 'Viet Nam', alpha3: 'VNM', numeric: '704' },
+      { alpha2: 'VN', name: 'Vietnam', alpha3: 'VNM', numeric: '704' },
       { alpha2: 'VG', name: 'Virgin Islands, British', alpha3: 'VGB', numeric: '092' },
       { alpha2: 'VI', name: 'Virgin Islands, U.S.', alpha3: 'VIR', numeric: '850' },
       { alpha2: 'WF', name: 'Wallis and Futuna', alpha3: 'WLF', numeric: '876' },

data/lib/active_merchant/errors.rb

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  class ActiveMerchantError < StandardError #:nodoc:
+module ActiveMerchant # :nodoc:
+  class ActiveMerchantError < StandardError # :nodoc:
   end
 
   class ConnectionError < ActiveMerchantError # :nodoc:
@@ -23,6 +23,16 @@ module ActiveMerchant #:nodoc:
     end
 
     def to_s
+      if response.kind_of?(String)
+        if response.start_with?('Failed')
+          return response
+        else
+          return "Failed with #{response}"
+        end
+      end
+
+      return response.message if response.respond_to?(:message) && response.message.start_with?('Failed')
+
       "Failed with #{response.code if response.respond_to?(:code)} #{response.message if response.respond_to?(:message)}"
     end
   end

data/lib/active_merchant/net_http_ssl_connection.rb

@@ -1,11 +1,46 @@
 require 'net/http'
 
 module NetHttpSslConnection
+  module InnocuousCapitalize
+    def capitalize(name) = name
+    private :capitalize
+  end
+
+  class CaseSensitivePost < Net::HTTP::Post; prepend InnocuousCapitalize; end
+
+  class CaseSensitivePatch < Net::HTTP::Patch; prepend InnocuousCapitalize; end
+
+  class CaseSensitivePut < Net::HTTP::Put; prepend InnocuousCapitalize; end
+
+  class CaseSensitiveDelete < Net::HTTP::Delete; prepend InnocuousCapitalize; end
+
   refine Net::HTTP do
     def ssl_connection
       return {} unless use_ssl? && @socket.present?
 
       { version: @socket.io.ssl_version, cipher: @socket.io.cipher[0] }
     end
+
+    unless ENV['RUNNING_UNIT_TESTS']
+      def post(path, data, initheader = nil, dest = nil, &block)
+        send_entity(path, data, initheader, dest, request_type(CaseSensitivePost, Net::HTTP::Post, initheader), &block)
+      end
+
+      def patch(path, data, initheader = nil, dest = nil, &block)
+        send_entity(path, data, initheader, dest, request_type(CaseSensitivePatch, Net::HTTP::Patch, initheader), &block)
+      end
+
+      def put(path, data, initheader = nil)
+        request(request_type(CaseSensitivePut, Net::HTTP::Put, initheader).new(path, initheader), data)
+      end
+
+      def delete(path, initheader = { 'Depth' => 'Infinity' })
+        request(request_type(CaseSensitiveDelete, Net::HTTP::Delete, initheader).new(path, initheader))
+      end
+
+      def request_type(replace, default, initheader)
+        initheader.is_a?(ActiveMerchant::PostsData::CaseSensitiveHeaders) ? replace : default
+      end
+    end
   end
 end

data/lib/active_merchant/posts_data.rb

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module PostsData #:nodoc:
+module ActiveMerchant # :nodoc:
+  module PostsData # :nodoc:
     def self.included(base)
       base.class_attribute :ssl_strict
       base.ssl_strict = true
@@ -30,6 +30,8 @@ module ActiveMerchant #:nodoc:
 
       base.class_attribute :proxy_address
       base.class_attribute :proxy_port
+      base.class_attribute :proxy_user
+      base.class_attribute :proxy_password
     end
 
     def ssl_get(endpoint, headers = {})
@@ -68,8 +70,10 @@ module ActiveMerchant #:nodoc:
 
       connection.ignore_http_status = @options[:ignore_http_status] if @options
 
-      connection.proxy_address = proxy_address
-      connection.proxy_port    = proxy_port
+      connection.proxy_address  = proxy_address
+      connection.proxy_port     = proxy_port
+      connection.proxy_user     = proxy_user
+      connection.proxy_password = proxy_password
 
       connection.request(method, data, headers)
     end
@@ -88,5 +92,16 @@ module ActiveMerchant #:nodoc:
         raise ResponseError.new(response)
       end
     end
+
+    # This class is needed to play along with the Refinement done for Net::HTTP
+    # class so it can have a way to detect if the hash that represent the headers
+    # should use the case sensitive version of the headers or not.
+    class CaseSensitiveHeaders < Hash
+      def dup
+        case_sensitive_dup = self.class.new
+        each { |key, value| case_sensitive_dup[key] = value }
+        case_sensitive_dup
+      end
+    end
   end
 end

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.133.0'
+  VERSION = '1.138.0'
 end

data/lib/active_merchant/versionable.rb

@@ -0,0 +1,29 @@
+module ActiveMerchant
+  module Versionable
+    def self.included(base)
+      if base.respond_to?(:class_attribute)
+        base.class_attribute :versions, default: {}
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        super
+        subclass.versions = {}
+      end
+
+      def version(version, feature = :default_api)
+        versions[feature] = version
+      end
+
+      def fetch_version(feature = :default_api)
+        versions[feature]
+      end
+    end
+
+    def fetch_version(feature = :default_api)
+      versions[feature]
+    end
+  end
+end