acquiring-sdk-ruby 0.1.0

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

@@ -0,0 +1,197 @@
+require 'worldline/acquiring/sdk/authentication/authorization_type'
+
+module Worldline
+  module Acquiring
+    module SDK
+      # A CommunicatorConfiguration stores all data used to initialize an {Worldline::Acquiring::SDK::Communicator}.
+      #
+      # @attr [String] api_endpoint         Base URL to the Worldline Acquiring platform
+      # @attr [String] authorization_id     An id used for authorization. The meaning of this id is different for each authorization type.
+      #                                     For instance, for OAuth2 this is the client id
+      # @attr [String] authorization_secret A secret used for authorization. The meaning of this secret is different for each authorization type.
+      #                                     For instance, for OAuth2 this is the client secret
+      # @attr [String] oauth2_token_uri     The OAuth2 token URI
+      # @attr [String] authorization_type   String representing the authentication algorithm used
+      # @attr [Integer] connect_timeout     The number of seconds before a connection attempt with the Worldline Acquiring platform times out.
+      # @attr [Integer] socket_timeout      The number of seconds before a timeout occurs when transmitting data to or from the Worldline Acquiring platform.
+      # @attr [Integer] max_connections     The number of connections with the Worldline Acquiring platform that are kept alive in the connection pool.
+      #       These connections will be reused when possible.
+      # @attr [Worldline::Acquiring::SDK::ProxyConfiguration] proxy_configuration Proxy settings.
+      # @attr [String] integrator           Name of the integrator
+      # @attr [Worldline::Acquiring::SDK::Domain::ShoppingCartExtension] shopping_cart_extension Shopping cart-related metadata.
+      class CommunicatorConfiguration
+        private
+
+        DEFAULT_MAX_CONNECTIONS = 10
+
+        public
+
+        # The default number of connections that are kept alive in the connection pool.
+        # Used if _maxConnections_ is not present in the properties.
+        # @return [Integer]
+        def self.default_max_connections
+          DEFAULT_MAX_CONNECTIONS
+        end
+
+        # Creates a new CommunicatorConfiguration instance.
+        #
+        # If a _properties_ object is given, it will be parsed like a hash in order to read these attributes.
+        # If a value is given in both the _properties_ hash and as a separate parameter,
+        # the separate parameter will take precedence over the value in the properties.
+        #
+        # @param properties              [Hash, nil] hash that may contain any of the other parameters.
+        # @param api_endpoint            [String, nil] the base URL to the Worldline Acquiring platform.
+        # @param authorization_id        [String, nil] An id used for authorization. The meaning of this id is different for each authorization type.
+        #                                For instance, for OAuth2 this is the client id.
+        # @param authorization_secret    [String, nil] A secret used for authorization. The meaning of this secret is different for each authorization type.
+        #                                For instance, for OAuth2 this is the client secret.
+        # @param oauth2_client_id        [String, nil] The OAuth2 client id.
+        #                                This is an alias for _authorization_id_.
+        # @param oauth2_client_secret    [String, nil] The OAuth2 client secret.
+        #                                This is an alias for _authorization_secret_.
+        # @param oauth2_token_uri        [String, nil] The OAuth2 token URI.
+        # @param authorization_type      [String, nil] string describing the authorization protocol to follow.
+        # @param connect_timeout         [Integer, nil] the number of seconds before a connection attempt with the Worldline Acquiring platform times out.
+        # @param socket_timeout          [Integer, nil] the number of seconds before a timeout occurs when transmitting data to or from the Worldline Acquiring platform.
+        # @param max_connections         [Integer, nil] the number of connections with the Worldline Acquiring platform that are kept alive in the connection pool.
+        #                                These connections will be reused when possible.
+        # @param proxy_configuration     [Worldline::Acquiring::SDK::ProxyConfiguration, nil] stores the URL to a proxy to be used in all communication,
+        #                                or _nil_ if no proxy should be used.
+        # @param integrator              [String, nil] name of the integrator
+        # @param shopping_cart_extension [Worldline::Acquiring::SDK::Domain::ShoppingCartExtension, nil] stores shopping cart-related metadata.
+        def initialize(properties: nil, api_endpoint: nil,
+                       authorization_id: nil, authorization_secret: nil,
+                       oauth2_client_id: nil, oauth2_client_secret: nil, oauth2_token_uri: nil,
+                       authorization_type: nil,
+                       connect_timeout: nil, socket_timeout: nil,
+                       max_connections: nil, proxy_configuration: nil,
+                       integrator: nil, shopping_cart_extension: nil)
+          unless properties.nil?
+            @api_endpoint = get_endpoint(properties)
+            @authorization_type = Authentication::AuthorizationType.get_authorization(properties['acquiring.api.authorizationType'])
+            @oauth2_token_uri = properties['acquiring.api.oauth2.tokenUri']
+            @connect_timeout = properties['acquiring.api.connectTimeout']
+            @socket_timeout = properties['acquiring.api.socketTimeout']
+            @max_connections = get_property(properties, 'acquiring.api.maxConnections', DEFAULT_MAX_CONNECTIONS)
+
+            proxy_uri = properties['acquiring.api.proxy.uri']
+            proxy_user = properties['acquiring.api.proxy.username']
+            proxy_pass = properties['acquiring.api.proxy.password']
+            unless proxy_uri.nil?
+              @proxy_configuration = ProxyConfiguration.new(address: URI(proxy_uri),
+                                                            username: proxy_user,
+                                                            password: proxy_pass)
+            end
+            @integrator = properties['acquiring.api.integrator']
+            @shopping_cart_extension = get_shopping_cart_extension(properties)
+          end
+
+          if api_endpoint
+            @api_endpoint = api_endpoint
+          end
+          if authorization_id
+            @authorization_id = authorization_id
+          end
+          if authorization_secret
+            @authorization_secret = authorization_secret
+          end
+          if oauth2_client_id
+            @authorization_id = oauth2_client_id
+          end
+          if oauth2_client_secret
+            @authorization_secret = oauth2_client_secret
+          end
+          if oauth2_token_uri
+            @oauth2_token_uri = oauth2_token_uri
+          end
+          if authorization_type
+            @authorization_type = authorization_type
+          end
+          if connect_timeout
+            @connect_timeout = connect_timeout
+          end
+          if socket_timeout
+            @socket_timeout = socket_timeout
+          end
+          if max_connections
+            @max_connections = max_connections
+          end
+          if proxy_configuration
+            @proxy_configuration = proxy_configuration
+          end
+          if integrator
+            @integrator = integrator
+          end
+          if shopping_cart_extension
+            @shopping_cart_extension = shopping_cart_extension
+          end
+        end
+
+        attr_accessor :api_endpoint
+
+        attr_accessor :authorization_id
+        attr_accessor :authorization_secret
+        attr_accessor :oauth2_token_uri
+        attr_accessor :authorization_type
+
+        attr_accessor :connect_timeout
+        attr_accessor :socket_timeout
+        attr_accessor :max_connections
+
+        attr_accessor :proxy_configuration
+
+        attr_accessor :integrator
+        attr_accessor :shopping_cart_extension
+
+        alias :oauth2_client_id      :authorization_id
+        alias :oauth2_client_id=     :authorization_id=
+        alias :oauth2_client_secret  :authorization_secret
+        alias :oauth2_client_secret= :authorization_secret=
+
+        private
+
+        def get_property(properties, key, default_value)
+          property_value = properties[key]
+          if property_value.nil?
+            default_value
+          else
+            property_value
+          end
+        end
+
+        def get_endpoint(properties)
+          host = properties['acquiring.api.endpoint.host']
+          scheme = properties['acquiring.api.endpoint.scheme']
+          port = properties['acquiring.api.endpoint.port']
+          if scheme.nil?
+            scheme = 'https'
+          end
+          if port.nil?
+            port = -1
+          end
+          create_uri(scheme, host, port)
+        end
+
+        def create_uri(scheme, host, port)
+          if port == -1
+            "#{scheme}://#{host}"
+          else
+            "#{scheme}://#{host}:#{port.to_s}"
+          end
+        end
+
+        def get_shopping_cart_extension(properties)
+          creator = properties['acquiring.api.shoppingCartExtension.creator']
+          name = properties['acquiring.api.shoppingCartExtension.name']
+          version = properties['acquiring.api.shoppingCartExtension.version']
+          extension_id = properties['acquiring.api.shoppingCartExtension.extensionId']
+          if creator.nil? && name.nil? && version.nil? && extension_id.nil?
+            nil
+          else
+            Domain::ShoppingCartExtension.new(creator, name, version, extension_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/domain/data_object.rb

@@ -0,0 +1,34 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Domain
+        # Base class for all SDK data objects, supports marshalling and unmarshalling the data object to and from JSON.
+        class DataObject
+
+          # Returns a hash representation of the DataObject.
+          # The hash contains camelCase representations of the variables, and their values.
+          # Should be overridden to add all instance variables of the object.
+          #
+          # @return [Hash]
+          def to_h
+            {}
+          end
+
+          # Create a new instance of this object (DataObject or descendant)
+          # from a hash containing attribute values in camelCase.
+          # Note that the hash contains Strings as keys instead of more commonly used tokens.
+          def self.new_from_hash(hash)
+            obj = self.new
+            obj.from_hash(hash)
+            obj
+          end
+
+          # Set attributes from values in parameter hash.
+          # Should be overridden by descendants in order to properly restore their attributes from the hash.
+          # Note that the hash contains Strings as keys instead of more commonly used tokens.
+          def from_hash(hash) end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/domain/shopping_cart_extension.rb

@@ -0,0 +1,62 @@
+require 'worldline/acquiring/sdk/domain/data_object'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module Domain
+        # Represents metadata part of shopping carts.
+        #
+        # @attr_reader [String] creator
+        # @attr_reader [String] name
+        # @attr_reader [String] version
+        # @attr_reader [String] extension_id
+        class ShoppingCartExtension < DataObject
+          def initialize(creator, name, version, extension_id=nil)
+            raise ArgumentError.new if creator.nil? or creator.strip.empty?
+            raise ArgumentError.new if name.nil? or name.strip.empty?
+            raise ArgumentError.new if version.nil? or version.to_s.strip.empty?
+
+            @creator = creator
+            @name = name
+            @version = version.to_s
+            @extension_id = extension_id
+          end
+
+          # Constructs a new ShoppingCartExtension from parameter hash
+          # the hash should contain a _creator_, _name_, _version_ and _extensionId_
+          #--
+          # Overridden so ShoppingCartExtension can retain mandatory default arguments
+          #++
+          def self.new_from_hash(hash)
+            creator = hash['creator'] if hash.has_key?('creator')
+            name = hash['name'] if hash.has_key?('name')
+            version = hash['version'] if hash.has_key?('version')
+            extension_id = hash['extensionId'] if hash.has_key?('extensionId')
+            self.new(creator, name, version, extension_id)
+          end
+
+          # Converts the shopping cart metadata to a hash
+          def to_h
+            hash = super
+            hash['creator'] = @creator unless @creator.nil?
+            hash['name'] = @name unless @name.nil?
+            hash['version'] = @version unless @version.nil?
+            hash['extensionId'] = @extension_id unless @extension_id.nil?
+            hash
+          end
+
+          # loads shopping cart metadata from a parameter hash
+          def from_hash(hash)
+            super
+            @creator = hash['creator'] if hash.has_key? 'creator'
+            @name = hash['name'] if hash.has_key? 'name'
+            @version = hash['version'] if hash.has_key? 'version'
+            @extension_id = hash['extensionId'] if hash.has_key? 'extensionId'
+          end
+
+          attr_reader :creator, :name, :version, :extension_id
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/domain/uploadable_file.rb

@@ -0,0 +1,35 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Domain
+        # A file that can be uploaded
+        #
+        # The allowed forms of content are defined by the Connection implementation
+        # The default implementation supports file paths and IO objects.
+        #
+        # @attr_reader [String] file_name       The name of the file.
+        # @attr_reader [String, IO] content     The file's content.
+        # @attr_reader [String] content_type    The file's content type.
+        # @attr_reader [Integer] content_length The file's content length, or -1 if not known.
+        class UploadableFile
+
+          def initialize(file_name, content, content_type, content_length = -1)
+            raise ArgumentError.new("file_name is required") if file_name.nil? or !file_name.strip
+            raise ArgumentError.new("content is required") if content.nil?
+            raise ArgumentError.new("content_type is required") if content_type.nil? or !content_type.strip
+
+            @file_name = file_name
+            @content = content
+            @content_type = content_type
+            @content_length = [content_length, -1].max
+          end
+
+          attr_reader :file_name
+          attr_reader :content
+          attr_reader :content_type
+          attr_reader :content_length
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,183 @@
+require 'yaml'
+require 'worldline/acquiring/sdk/client'
+require 'worldline/acquiring/sdk/communicator'
+require 'worldline/acquiring/sdk/communicator_configuration'
+require 'worldline/acquiring/sdk/authentication/authorization_type'
+require 'worldline/acquiring/sdk/authentication/oauth2_authenticator'
+require 'worldline/acquiring/sdk/communication/default_connection'
+require 'worldline/acquiring/sdk/communication/metadata_provider'
+require 'worldline/acquiring/sdk/json/default_marshaller'
+
+module Worldline
+  module Acquiring
+    module SDK
+      # Convenience class that constructs instances of several other classes in the SDK.
+      # Provides methods to construct
+      # {Worldline::Acquiring::SDK::CommunicatorConfiguration}, {Worldline::Acquiring::SDK::Communicator} and {Worldline::Acquiring::SDK::Client} instances.
+      class Factory
+
+        # Creates and returns a {Worldline::Acquiring::SDK::CommunicatorConfiguration} based on the configuration in the file
+        # located at _configuration_file_name_.
+        #
+        # @param configuration_file_name [String] Path to the configuration file to use, should be in YAML format.
+        # @param authorization_id        [String] Authorization id, e.g. the key id for the Worldline Acquiring platform.
+        # @param authorization_secret    [String] Authorization secret, e.g. the secret key used for authentication to the Worldline Acquiring platform.
+        # @return [Worldline::Acquiring::SDK::CommunicatorConfiguration] The created communicator configuration
+        def self.create_configuration(configuration_file_name, authorization_id, authorization_secret)
+          properties = YAML::load_file(configuration_file_name)
+          CommunicatorConfiguration.new(properties: properties,
+                                        authorization_id: authorization_id,
+                                        authorization_secret: authorization_secret)
+        end
+
+        # Creates and returns a {Worldline::Acquiring::SDK::Communicator} from a {Worldline::Acquiring::SDK::CommunicatorConfiguration},
+        # a {Worldline::Acquiring::SDK::Communication::MetadataProvider}, a {Worldline::Acquiring::SDK::Communication::Connection},
+        # an {Worldline::Acquiring::SDK::Authentication::Authenticator} and a {Worldline::Acquiring::SDK::JSON::Marshaller}.
+        #
+        # @param configuration     [Worldline::Acquiring::SDK::CommunicatorConfiguration] configuration settings to be used by the client.
+        # @param metadata_provider [Worldline::Acquiring::SDK::Communication::MetadataProvider] stores the metadata for the communicating client.
+        # @param connection        [Worldline::Acquiring::SDK::Communication::Connection] connection that can be used to communicate with the Worldline Acquiring platform.
+        # @param authenticator     [Worldline::Acquiring::SDK::Authentication::Authenticator] authenticator that can authenticate messages sent to the Worldline Acquiring platform.
+        # @param marshaller        [Worldline::Acquiring::SDK::JSON::Marshaller] marshaller that can marshal and unmarshal objects to and from JSON.
+        # @return [Worldline::Acquiring::SDK::Communicator] The created communicator
+        def self.create_communicator_from_configuration(configuration, metadata_provider: nil,
+                                                        connection: nil, authenticator: nil, marshaller: nil)
+          unless metadata_provider
+            metadata_provider = MetadataProvider.new(configuration.integrator,
+                                                      shopping_cart_extension: configuration.shopping_cart_extension)
+          end
+          unless connection
+            connection = Communication::DefaultConnection.new({ connect_timeout: configuration.connect_timeout,
+                                                                socket_timeout: configuration.socket_timeout,
+                                                                max_connections: configuration.max_connections,
+                                                                proxy_configuration: configuration.proxy_configuration })
+          end
+          unless authenticator
+            authenticator = get_authenticator(configuration)
+          end
+          unless marshaller
+            marshaller = DefaultMarshaller.instance
+          end
+          Communicator.new(configuration.api_endpoint, connection, authenticator, metadata_provider, marshaller)
+        end
+
+        # Creates and returns a {Worldline::Acquiring::SDK::Communicator} from a file containing the communicator configuration, authorization_id, authorization_secret,
+        # a {Worldline::Acquiring::SDK::Communication::MetadataProvider}, a {Worldline::Acquiring::SDK::Communication::Connection}.
+        # an {Worldline::Acquiring::SDK::Authentication::Authenticator} and a {Worldline::Acquiring::SDK::JSON::Marshaller}.
+        #
+        # @param configuration_file_name [String] Path to the configuration file to use, should be in YAML format.
+        # @param authorization_id        [String] Authorization id, e.g. the key id for the Worldline Acquiring platform.
+        # @param authorization_secret    [String] Authorization secret, e.g. the secret key used for authentication to the Worldline Acquiring platform.
+        # @param metadata_provider       [Worldline::Acquiring::SDK::Communication::MetadataProvider] stores the metadata for the communicating client.
+        # @param connection              [Worldline::Acquiring::SDK::Communication::Connection] connection that can be used to communicate with the Worldline Acquiring platform.
+        # @param authenticator           [Worldline::Acquiring::SDK::Authentication::Authenticator] authenticator that can authenticate messages sent to the Worldline Acquiring platform.
+        # @param marshaller              [Worldline::Acquiring::SDK::JSON::Marshaller] marshaller that can marshal and unmarshal objects to and from JSON.
+        # @return [Worldline::Acquiring::SDK::Communicator] The created communicator
+        def self.create_communicator_from_file(configuration_file_name, authorization_id, authorization_secret,
+                                               metadata_provider: nil, connection: nil, authenticator: nil, marshaller: nil)
+          configuration = create_configuration(configuration_file_name, authorization_id, authorization_secret)
+          create_communicator_from_configuration(configuration, metadata_provider: metadata_provider, connection: connection,
+                                                 authenticator: authenticator, marshaller: marshaller)
+        end
+
+        # Creates and returns an {Worldline::Acquiring::SDK::Client} that provides the a high-level interface with the Worldline Acquiring platform.
+        # If a code block is given, the created client is returned to the code block and closed afterwards.
+        #
+        # @example Providing a code block
+        #           Factory.create_client_from_configuration(configuration) do |client|
+        #             # use client as needed
+        #           end
+        #           # client is closed here
+        #
+        # @param configuration     [Worldline::Acquiring::SDK::CommunicatorConfiguration] contains configuration settings to be used by the client.
+        # @param metadata_provider [Worldline::Acquiring::SDK::Communication::MetadataProvider] stores the metadata for the communicating client.
+        # @param connection        [Worldline::Acquiring::SDK::Communication::Connection] connection that can be used to communicate with the Worldline Acquiring platform.
+        # @param authenticator     [Worldline::Acquiring::SDK::Authentication::Authenticator] authenticator that can authenticate messages sent to the Worldline Acquiring platform.
+        # @param marshaller        [Worldline::Acquiring::SDK::JSON::Marshaller] marshaller that can marshal and unmarshal objects to and from JSON.
+        # @return [Worldline::Acquiring::SDK::Client] The created client
+        def self.create_client_from_configuration(configuration, metadata_provider: nil, connection: nil, authenticator: nil, marshaller: nil)
+          communicator = create_communicator_from_configuration(configuration, metadata_provider: metadata_provider, connection: connection,
+                                                                authenticator: authenticator, marshaller: marshaller)
+          client = Client.new(communicator)
+          if block_given?
+            begin
+              yield client
+            ensure
+              client.close
+            end
+          else
+            return client
+          end
+        end
+
+        # Creates and returns an {Worldline::Acquiring::SDK::Client} that provides the a high-level interface with the Worldline Acquiring platform.
+        # If a code block is given, the created client is returned to the code block and closed afterwards.
+        #
+        # @example Providing a code block
+        #           Factory.create_client_from_communicator(communicator) do |client|
+        #             # use client as needed
+        #           end
+        #           # client is closed here
+        #
+        # @param communicator [Worldline::Acquiring::SDK::Communicator] provides network communication service for the Client
+        # @return [Worldline::Acquiring::SDK::Client] The created client
+        def self.create_client_from_communicator(communicator)
+          client = Client.new(communicator)
+          if block_given?
+            begin
+              yield client
+            ensure
+              client.close
+            end
+          else
+            return client
+          end
+        end
+
+        # Creates and returns an {Worldline::Acquiring::SDK::Client} that provides the a high-level interface with the Worldline Acquiring platform.
+        # If a code block is given, the created client is returned to the code block and closed afterwards.
+        #
+        # @example Providing a code block
+        #           Factory.create_client_from_file(configuration_file_name, authorization_id, authorization_secret) do |client|
+        #             # use client as needed
+        #           end
+        #           # client is closed here
+        #
+        # @param configuration_file_name [String] Path to the configuration file to use, should be in YAML format.
+        # @param authorization_id        [String] Authorization id, e.g. the key id for the Worldline Acquiring platform.
+        # @param authorization_secret    [String] Authorization secret, e.g. the secret key used for authentication to the Worldline Acquiring platform.
+        # @param metadata_provider       [Worldline::Acquiring::SDK::Communication::MetadataProvider] stores the metadata for the communicating client.
+        # @param connection              [Worldline::Acquiring::SDK::Communication::Connection] connection that can be used to communicate with the Worldline Acquiring platform.
+        # @param authenticator           [Worldline::Acquiring::SDK::Authentication::Authenticator] authenticator that can authenticate messages sent to the Worldline Acquiring platform.
+        # @param marshaller              [Worldline::Acquiring::SDK::JSON::Marshaller] marshaller that can marshal and unmarshal objects to and from JSON.
+        # @return [Worldline::Acquiring::SDK::Client] The created client
+        def self.create_client_from_file(configuration_file_name, authorization_id, authorization_secret,
+                                         metadata_provider: nil, connection: nil, authenticator: nil, marshaller: nil)
+          communicator = create_communicator_from_file(configuration_file_name, authorization_id, authorization_secret,
+                                                       metadata_provider: metadata_provider, connection: connection,
+                                                       authenticator: authenticator, marshaller: marshaller)
+          client = Client.new(communicator)
+          if block_given?
+            begin
+              yield client
+            ensure
+              client.close
+            end
+          else
+            return client
+          end
+        end
+
+        private
+
+        # @param configuration [Worldline::Acquiring::SDK::CommunicatorConfiguration]
+        def self.get_authenticator(configuration)
+          if configuration.authorization_type == Authentication::AuthorizationType::OAUTH2
+            return Authentication::OAuth2Authenticator.new(configuration)
+          end
+          raise RuntimeError.new("Unknown authorizationType #{configuration.authorization_type}")
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/json/default_marshaller.rb

@@ -0,0 +1,36 @@
+require 'json'
+require 'singleton'
+require 'worldline/acquiring/sdk/json/marshaller'
+
+module Worldline
+  module Acquiring
+    module SDK
+      module JSON
+        # Marshals objects to and from JSON format.
+        # Currently supports marshalling and unmarshalling of classes that support class.new_from_hash and class#to_h
+        class DefaultMarshaller < Marshaller
+          include Singleton
+
+          # Marshals the _request_object_ to a JSON string using request_object#to_h
+          def marshal(request_object)
+            ::JSON.pretty_generate(request_object.to_h)
+          end
+
+          # Unmarshals a JSON string into an object of type _klass_ using klass.new_from_hash
+          def unmarshal(json_string, klass)
+            if json_string.nil?
+              return nil
+            elsif json_string.length == 0
+              return ''
+            end
+            if klass.respond_to?(:new_from_hash)
+              klass.new_from_hash(::JSON.load(json_string))
+            else
+              raise NotImplementedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/json/marshaller.rb

@@ -0,0 +1,29 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module JSON
+        # Class responsible for marshalling and unmarshalling objects to and from JSON
+        class Marshaller
+
+          # Marshals _request_object_ to JSON format by calling #to_h on it.
+          #
+          # @param request_object [Worldline::Acquiring::SDK::Domain::DataObject] the object to format
+          # @return [String] _request_object_ converted to JSON
+          def marshal(request_object)
+            raise NotImplementedError
+          end
+
+          # Unmarshals a JSON string into an object of type _type_.
+          # The new object is initialized by calling .new_from_hash with contents of the JSON as a Hash object.
+          #
+          # @param response_json [String] The JSON to unmarshal
+          # @param type          [Type] The class of the object that will be instantiated using _type.new_from_hash_
+          # @return The JSON unmarshalled to the given type
+          def unmarshal(response_json, type)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worldline/acquiring/sdk/json/marshaller_syntax_exception.rb

@@ -0,0 +1,11 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module JSON
+        # Raised when an error occurred while marshalling/unmarshalling data to/from JSON
+        class MarshallerSyntaxException < RuntimeError
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,26 @@
+module Worldline
+  module Acquiring
+    module SDK
+      module Logging
+        # Base logger class used in this SDK. This class is an interface and cannot be instantiated.
+        class CommunicatorLogger
+
+          # Interface, no instantiation
+          # @see Worldline::Acquiring::SDK::Logging::StdoutCommunicatorLogger
+          # @see Worldline::Acquiring::SDK::Logging::RubyCommunicatorLogger
+          def initialize
+            raise NotImplementedError.new("#{self.class.name} is not implemented.")
+          end
+
+          # Logs a message with or without exception
+          #
+          # @param message [String] the message to log
+          # @param thrown  [Exception, nil] the exception to log, or nil to log no exception
+          def log(message, thrown = nil)
+            raise NotImplementedError.new("#{self.class.name}#log() is not implemented.")
+          end
+        end
+      end
+    end
+  end
+end