acquiring-sdk-ruby 0.1.0

data/lib/worldline/acquiring/sdk/logging/log_message_builder.rb

@@ -0,0 +1,91 @@
+require 'worldline/acquiring/sdk/logging/obfuscation/body_obfuscator'
+require 'worldline/acquiring/sdk/logging/obfuscation/header_obfuscator'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        # Abstract class used to construct a message describing a request or response.
+        #
+        # @attr_reader [String] request_id   An identifier assigned to the request and response
+        # @attr_reader [String] headers      Request or response headers in string form
+        # @attr_reader [String] body         Request or response body as a string
+        # @attr_reader [String] content_type Content type of the body, generally 'application/json' or 'text/html'
+        # @attr_reader [Worldline::Acquiring::SDK::Logging::Obfuscation::BodyObfuscator] body_obfuscator
+        # @attr_reader [Worldline::Acquiring::SDK::Logging::Obfuscation::HeaderObfuscator] header_obfuscator
+        class LogMessageBuilder
+
+          attr_reader :request_id
+          attr_reader :headers
+          attr_reader :body
+          attr_reader :content_type
+          attr_reader :body_obfuscator
+          attr_reader :header_obfuscator
+
+          # Create a new LogMessageBuilder
+          def initialize(request_id,
+                         body_obfuscator = Obfuscation::BodyObfuscator.default_obfuscator,
+                         header_obfuscator = Obfuscation::HeaderObfuscator.default_obfuscator)
+            raise ArgumentError if request_id.nil? or request_id.empty?
+            raise ArgumentError if body_obfuscator.nil?
+            raise ArgumentError if header_obfuscator.nil?
+            @request_id = request_id
+            @headers = ''
+            @body_obfuscator = body_obfuscator
+            @header_obfuscator = header_obfuscator
+          end
+
+          # Adds a single header to the #headers string
+          def add_headers(name, value)
+            @headers += ', ' if @headers.length > 0
+            @headers += name + '="'
+            @headers += @header_obfuscator.obfuscate_header(name, value) unless value.nil?
+            @headers += '"'
+          end
+
+          # Sets the body of this message to the parameter body.
+
+          # @param body         [String] the message body
+          # @param content_type [String] the content type of the body
+          def set_body(body, content_type)
+            if is_binary(content_type)
+              @body = "<binary content>"
+            else
+              @body = @body_obfuscator.obfuscate_body(body)
+            end
+            @content_type = content_type
+          end
+
+          # Constructs and returns the log message as a string.
+          # @return [String]
+          def get_message
+            raise NotImplementedError.new("#{self.class.name}#get_message() is not implemented.")
+          end
+
+          def to_s
+            if self.class == LogMessageBuilder
+              super.to_s
+            else
+              get_message
+            end
+          end
+
+          # Returns an empty string if the parameter is nil, and returns the parameter itself otherwise
+          protected def empty_if_null(value)
+            value.nil? ? '' : value
+          end
+
+          # Returns whether or not the content type is binary
+          def is_binary(content_type)
+            if content_type.nil?
+              false
+            else
+              content_type = content_type.downcase
+              !(content_type.start_with?("text/") || content_type.include?("json") || content_type.include?("xml"))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/logging_capable.rb

@@ -0,0 +1,19 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        # Abstract mixin module that allows loggers to be registered to an object.
+        module LoggingCapable
+
+          def enable_logging(communicator_logger)
+            raise NotImplementedError
+          end
+
+          def disable_logging
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/obfuscation/body_obfuscator.rb

@@ -0,0 +1,101 @@
+require 'worldline/acquiring/sdk/logging/obfuscation/obfuscation_rule'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        module Obfuscation
+          # A class that can be used to obfuscate properties in JSON bodies.
+          class BodyObfuscator
+
+            # Creates a new body obfuscator.
+            # This will contain some pre-defined obfuscation rules, as well as any provided custom rules
+            #
+            # @param additional_rules [Hash] An optional hash where the keys are property names and the values are
+            #        functions that obfuscate a single value
+            def initialize(additional_rules = nil)
+              @obfuscation_rules = {
+                "address" => Obfuscation.obfuscate_all,
+                "authenticationValue" => Obfuscation.obfuscate_all_but_first(4),
+                "bin" => Obfuscation.obfuscate_all_but_first(6),
+                "cardholderAddress" => Obfuscation.obfuscate_all,
+                "cardholderPostalCode" => Obfuscation.obfuscate_all,
+                "cardNumber" => Obfuscation.obfuscate_all_but_last(4),
+                "cardSecurityCode" => Obfuscation.obfuscate_all,
+                "city" => Obfuscation.obfuscate_all,
+                "cryptogram" => Obfuscation.obfuscate_all_but_first(4),
+                "expiryDate" => Obfuscation.obfuscate_all_but_last(4),
+                "name" => Obfuscation.obfuscate_all,
+                "paymentAccountReference" => Obfuscation.obfuscate_all_but_first(6),
+                "postalCode" => Obfuscation.obfuscate_all,
+                "stateCode" => Obfuscation.obfuscate_all,
+              }
+              if additional_rules
+                additional_rules.each do |name, rule|
+                  @obfuscation_rules[name] = rule
+                end
+              end
+
+              @property_pattern = build_property_pattern(@obfuscation_rules.keys)
+            end
+
+            private
+
+            def build_property_pattern(pn)
+              return /$^/ if pn.empty? # no possible match
+              # Regex to create:
+              # (["'])(X|Y|Z)\1\s*:\s*(?:(["'])(.*?)(?<!\\)\3|([^"'\s\[\{]\S*))
+              # Groups:
+              # 1: opening " or ' for the property name
+              # 2: property name
+              # 3: opening " or ' for the value
+              # 4: quoted value
+              # 5: non-quoted-value
+              # The negative lookbehind is to allow escaped quotes to be part of
+              # the value. What this does not allow currently is having values end
+              # with a \ (which would be escaped to \\).
+              regex = pn.inject("([\"'])(") { |r, p| "#{r}#{Regexp.quote(p)}|" }.chop <<
+                ")\\1\\s*:\\s*(?:([\"'])(.*?)(?<!\\\\)\\3|([^\"'\\s\\[\\{]((?!,)\\S)*))"
+              /#{regex}/m # dotall mode
+            end
+
+            def obfuscate_value(property_name, value)
+              obfuscation_rule = @obfuscation_rules[property_name]
+              return obfuscation_rule.call(value) if obfuscation_rule
+              value
+            end
+
+            public
+
+            # Obfuscates the given body as necessary.
+            #
+            # @return (String)
+            def obfuscate_body(body)
+              return nil if body.nil?
+              return '' if body.empty?
+
+              body.gsub(@property_pattern) do
+                m = Regexp.last_match
+                property_name = m[2]
+                value = m[4] || m[5]
+                # copy value 'cause it's part of m[0]
+                m[0].sub(value, obfuscate_value(property_name, value.dup))
+              end
+            end
+
+            private
+
+            DEFAULT_OBFUSCATOR = BodyObfuscator.new
+
+            public
+
+            # @return [BodyObfuscator]
+            def self.default_obfuscator
+              DEFAULT_OBFUSCATOR
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/obfuscation/header_obfuscator.rb

@@ -0,0 +1,54 @@
+require 'worldline/acquiring/sdk/logging/obfuscation/obfuscation_rule'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        module Obfuscation
+          # A class that can be used to obfuscate headers.
+          class HeaderObfuscator
+
+            # Creates a new header obfuscator.
+            # This will contain some pre-defined obfuscation rules, as well as any provided custom rules
+            #
+            # @param additional_rules [Hash] An optional hash where the keys are header names and the values are
+            #        functions that obfuscate a single value
+            def initialize(additional_rules = nil)
+              @obfuscation_rules = {
+                "authorization" => Obfuscation.obfuscate_with_fixed_length(8),
+                "www-authenticate" => Obfuscation.obfuscate_with_fixed_length(8),
+                "proxy-authenticate" => Obfuscation.obfuscate_with_fixed_length(8),
+                "proxy-authorization" => Obfuscation.obfuscate_with_fixed_length(8),
+              }
+              if additional_rules
+                additional_rules.each do |name, rule|
+                  @obfuscation_rules[name.downcase] = rule
+                end
+              end
+            end
+
+            # Obfuscates the value for the given header as necessary.
+            #
+            # @return (String)
+            def obfuscate_header(header_name, value)
+              obfuscation_rule = @obfuscation_rules[header_name.downcase]
+              return obfuscation_rule.call(value) if obfuscation_rule
+              value
+            end
+
+            private
+
+            DEFAULT_OBFUSCATOR = HeaderObfuscator.new
+
+            public
+
+            # @return [HeaderObfuscator]
+            def self.default_obfuscator
+              DEFAULT_OBFUSCATOR
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/obfuscation/obfuscation_capable.rb

@@ -0,0 +1,23 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        module Obfuscation
+          # Abstract mixin module that allows specifying body and header obfuscators for an object.
+          module ObfuscationCapable
+
+            # Sets the current body obfuscator to use.
+            def set_body_obfuscator(body_obfuscator)
+              raise NotImplementedError
+            end
+
+            # Sets the current header obfuscator to use.
+            def set_header_obfuscator(header_obfuscator)
+              raise NotImplementedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/obfuscation/obfuscation_rule.rb

@@ -0,0 +1,49 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        module Obfuscation
+
+          # Returns an obfuscation rule (callable) that will replace all characters with *
+          def self.obfuscate_all
+            ->(value) do
+              return value if value.nil? or value.empty?
+              '*' * (value || '').length
+            end
+          end
+
+          # Returns an obfuscation rule (function) that will replace values with a fixed length string containing only *
+          def self.obfuscate_with_fixed_length(fixed_length)
+            ->(value) { '*' * fixed_length }
+          end
+
+          # Returns an obfuscation rule (function) that will keep a fixed number of characters at the start,
+          # then replaces all other characters with *
+          def self.obfuscate_all_but_first(count)
+            ->(value) do
+              return value if value.nil? or value.empty?
+              return value if value.length < count
+              # range describes the range of characters to replace with asterisks
+              range = count...value.length
+              value[range] = '*' * range.size
+              value
+            end
+          end
+
+          # Returns an obfuscation rule that will keep a fixed number of characters at the end,
+          # then replaces all other characters with *
+          def self.obfuscate_all_but_last(count)
+            ->(value) do
+              return value if value.nil? or value.empty?
+              return value if value.length < count
+              # range describes the range of characters to replace with asterisks
+              range = 0...(value.length - count)
+              value[range] = '*' * range.size
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/obfuscation.rb

@@ -0,0 +1 @@
+Dir[File.join(__dir__, 'obfuscation', '*.rb')].each { |f| require f }

data/lib/worldline/acquiring/sdk/logging/request_log_message_builder.rb

@@ -0,0 +1,52 @@
+require 'worldline/acquiring/sdk/logging/obfuscation/body_obfuscator'
+require 'worldline/acquiring/sdk/logging/obfuscation/header_obfuscator'
+require 'worldline/acquiring/sdk/logging/log_message_builder'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        # Class that converts data about a request into a properly formatted log message.
+        # Formats request id, http method, uri, headers and body into a helpful message.
+        class RequestLogMessageBuilder < LogMessageBuilder
+
+          def initialize(request_id, method, uri,
+                         body_obfuscator = Obfuscation::BodyObfuscator.default_obfuscator,
+                         header_obfuscator = Obfuscation::HeaderObfuscator.default_obfuscator)
+            super(request_id, body_obfuscator, header_obfuscator)
+            @method = method
+            @uri = uri
+          end
+
+          # Constructs and returns a log message based on the request data. The log message is a string.
+          def get_message
+            msg_template_without_body = "Outgoing request (requestId='%s'):\n" +
+              "  method:       '%s'\n" +
+              "  uri:          '%s'\n" +
+              "  headers:      '%s'"
+            msg_template_with_body = msg_template_without_body + "\n" +
+              "  content-type: '%s'\n" +
+              "  body:         '%s'"
+
+            return sprintf(msg_template_without_body, @request_id, empty_if_null(@method),
+                           format_uri, @headers) if @body.nil?
+            sprintf(msg_template_with_body, @request_id, empty_if_null(@method),
+                    format_uri, @headers, empty_if_null(@content_type), @body)
+          end
+
+          private
+
+          def format_uri
+            '' unless @uri && @uri.path
+            if @uri.query.nil?
+              @uri.path
+            else
+              "#{@uri.path}?#{@uri.query}" unless @uri.query.nil?
+            end
+            # @uri.path + '?' + empty_if_null(@uri.query)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/response_log_message_builder.rb

@@ -0,0 +1,43 @@
+require 'worldline/acquiring/sdk/logging/obfuscation/body_obfuscator'
+require 'worldline/acquiring/sdk/logging/obfuscation/header_obfuscator'
+require 'worldline/acquiring/sdk/logging/log_message_builder'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        # Class that converts data about a response into a properly formatted log message.
+        # Formats request id, status code, headers, body and time between request and response into a helpful message.
+        class ResponseLogMessageBuilder < LogMessageBuilder
+
+          # @param request_id  [String] identifier of the request corresponding to this response.
+          # @param status_code [Integer] HTTP status code of the response.
+          # @param duration    [Float] time elapsed between request and response.
+          def initialize(request_id, status_code, duration = -1,
+                         body_obfuscator = Obfuscation::BodyObfuscator.default_obfuscator,
+                         header_obfuscator = Obfuscation::HeaderObfuscator.default_obfuscator)
+            super(request_id, body_obfuscator, header_obfuscator)
+            @status_code = status_code
+            @duration = duration
+          end
+
+          # Constructs and returns a log message based on the request data. The log message is a string.
+          def get_message
+            msg_template = "Incoming response (requestId='%s'" +
+              ((@duration < 0) ? "" : ", %.3f ms") +
+              "):\n" +
+              "  status-code:  '%s'\n" +
+              "  headers:      '%s'\n" +
+              "  content-type: '%s'\n" +
+              "  body:         '%s'"
+
+            return sprintf(msg_template, @request_id, @status_code, @headers,
+                           empty_if_null(@content_type), empty_if_null(@body)) if @duration < 0
+            sprintf(msg_template, @request_id, @duration, @status_code, @headers,
+                    empty_if_null(@content_type), empty_if_null(@body))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/ruby_communicator_logger.rb

@@ -0,0 +1,63 @@
+require 'English'
+require 'worldline/acquiring/sdk/logging/communicator_logger'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        # Logging class that Logs messages and errors to a logger.
+        # Errors can be logged at a separate level compared to regular messages.
+        class RubyCommunicatorLogger < CommunicatorLogger
+
+          # Creates a new RubyCommunicatorLogger instance.
+          #
+          # @param logger      [Logger] the logger to log messages to. Messages to log will be provided using logger#log(message level, message)
+          # @param log_level   [String] log level to use for non-error messages.
+          # @param error_level [String, nil] error logging level to use.
+          def initialize(logger, log_level, error_level = nil)
+            # implement the interface
+            error_level ||= log_level
+            raise ArgumentError unless logger
+            raise ArgumentError unless log_level
+            raise ArgumentError unless error_level
+
+            @logger = logger
+            @log_level = log_level
+            @error_level = error_level
+          end
+
+          # Logs a single error or non-error message to the logger.
+          def log(msg, thrown = nil)
+            # use Ruby Logger
+            if thrown
+              @logger.log(@error_level) { msg + $RS + thrown.to_s + $RS + thrown.backtrace.join($RS) }
+            else
+              @logger.log(@log_level, msg)
+            end
+          end
+
+          # Opens or creates a new file in write-only mode with _filename_.
+          def self.create_logfile(filename)
+            logdev = begin
+                       open(filename, (File::WRONLY | File::APPEND | File::CREAT | File::EXCL))
+                     rescue Errno::EEXIST
+                       # file is created by another process
+                       open_logfile(filename)
+                     end
+            logdev.sync = true
+            logdev
+          end
+
+          # Opens or creates a new file in write-only mode with _filename_.
+          def self.open_logfile(filename)
+            begin
+              open(filename, (File::WRONLY | File::APPEND))
+            rescue Errno::ENOENT
+              create_logfile(filename)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging/stdout_communicator_logger.rb

@@ -0,0 +1,33 @@
+require 'English'
+require 'singleton'
+require 'worldline/acquiring/sdk/logging/communicator_logger'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        # Logging class that logs the messages to $stdout.
+        class StdoutCommunicatorLogger < CommunicatorLogger
+          include Singleton
+
+          def initialize
+            # implement the interface
+          end
+
+          # Logs a single error or non-error message to $stdout.
+          def log(msg, thrown = nil)
+            $stdout.puts get_date_prefix + msg
+            $stdout.puts thrown.to_s if thrown
+            $stdout.puts thrown.backtrace.join($RS) if thrown
+          end
+
+          private
+
+          def get_date_prefix
+            Time.now.strftime("%Y-%m-%dT%H:%M:%S ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/logging.rb

@@ -0,0 +1 @@
+Dir[File.join(__dir__, 'logging', '*.rb')].each { |f| require f }

data/lib/worldline/acquiring/sdk/proxy_configuration.rb

@@ -0,0 +1,76 @@
+module Worldline
+  module Acquiring
+    module SDK
+      # Contains the URL, username and password of a proxy.
+      #
+      # @attr [String] scheme   Proxy scheme (http or https)
+      # @attr [String] host     Proxy hostname
+      # @attr [Integer] port    Proxy port
+      # @attr [String] username Proxy authentication username
+      # @attr [String] password Proxy authentication password
+      class ProxyConfiguration
+
+        # Initialize a new ProxyConfiguration from the parameter hash.
+        # In order to be complete either host, port and scheme, or an address is required.
+        #
+        # @param args [Hash] the parameters to initialize the proxy configuration with
+        # @option args [String] :host host part of the URL to the proxy.
+        # @option args [Integer] :port port the proxy will be accessed through.
+        # @option args [String] :scheme HTTP scheme used to communicate with the proxy (http or https).
+        # @option args [String] :address full URI to the proxy excluding username and password.
+        #             If given this uri takes precedence over individual host, port and scheme.
+        # @option args [String] :username username used in authentication to the proxy.
+        # @option args [String] :password password used to authenticate to the proxy.
+        def initialize(args)
+          host = args[:host]
+          port = args[:port]
+          username = args[:username]
+          password = args[:password]
+          scheme = args[:scheme] || 'http'
+
+          # Don't switch the order, a given address overrides host, port and username
+          address = args[:address]
+          host = address.host if address
+          port = address.port if address
+          scheme = address.scheme if address
+
+          raise ArgumentError.new('scheme is required') unless scheme and not scheme.strip.empty?
+          raise ArgumentError.new('host is required') unless host and not host.strip.empty?
+          raise ArgumentError.new('port is required') unless port and port > 0 and port <= 65535
+
+          @host = host
+          @port = port
+          @username = username
+          @password = password
+          @scheme = scheme
+        end
+
+        attr_accessor :scheme
+        attr_accessor :host
+        attr_accessor :port
+
+        attr_accessor :username
+        attr_accessor :password
+
+        # @return [String] a URL string representation of the proxy, excluding authentication.
+        def proxy_uri
+          "#{scheme}://#{host}:#{port}"
+        end
+
+        def to_s
+          proxy_uri
+        end
+
+        private
+
+        def self.get_port(address)
+          port = address.port
+          return port if port != -1
+          return 80 if address.scheme.casecmp('http') == 0
+          return 443 if address.scheme.casecmp('https') == 0
+          raise ArgumentError.new('unsupported scheme: ' + address.scheme)
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/v1/acquirer/acquirer_client.rb

@@ -0,0 +1,35 @@
+#
+# This file was automatically generated.
+#
+require 'worldline/acquiring/sdk/api_resource'
+require 'worldline/acquiring/sdk/v1/acquirer/merchant/merchant_client'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module V1
+        module Acquirer
+          # Acquirer client. Thread-safe.
+          class AcquirerClient < Worldline::Acquiring::SDK::ApiResource
+
+            # @param parent       [Worldline::Acquiring::SDK::ApiResource]
+            # @param path_context [Hash, nil]
+            def initialize(parent, path_context)
+              super(parent: parent, path_context: path_context)
+            end
+
+            # Resource /processing/v1/{acquirerId}/{merchantId}
+            #
+            # @param merchant_id [String]
+            # @return [Worldline::Acquiring::SDK::V1::Acquirer::Merchant::MerchantClient]
+            def merchant(merchant_id)
+              Worldline::Acquiring::SDK::V1::Acquirer::Merchant::MerchantClient.new(self, {
+                'merchantId'.freeze => merchant_id,
+              })
+            end
+          end
+        end
+      end
+    end
+  end
+end