connect-sdk-ruby 1.36.0 → 2.0.0

data/lib/ingenico/connect/sdk/communicator_configuration.rb

@@ -1,44 +1,33 @@
 module Ingenico::Connect::SDK
 
-  # A CommunicatorConfiguration stores all data used to initialize an {Ingenico::Connect::SDK::Communicator}. It stores the following:
+  # A CommunicatorConfiguration stores all data used to initialize an {Ingenico::Connect::SDK::Communicator}.
   #
-  # api_endpoint::            The base url to the Ingenico ePayments platform.
-  # api_key_id::              The identifier of the _secret_api_key_ used to authenticate requests.
-  # secret_api_key::          The key used to authenticate requests sent to the Ingenico ePayments platform.
-  # authorization_type::      String describing the authorization protocol to follow.
-  # connect_timeout::         The number of seconds before a connection attempt with the Ingenico ePayments platform times out.
-  # socket_timeout::          The number of seconds before a timeout occurs
-  #                           when transmitting data to or from the Ingenico ePayments platform.
-  # max_connections::         The number of connections with the Ingenico ePayments platform
-  #                           that are kept alive in the connection pool. These connections will be reused when possible.
-  # proxy_configuration::     {Ingenico::Connect::SDK::ProxyConfiguration} instance that stores the url to a proxy to be used in all communication,
-  #                           or nil if no proxy should be used.
-  # integrator::              String
-  # shopping_cart_extension:: {Ingenico::Connect::SDK::Domain::Metadata::ShoppingCartExtension} that stores shopping cart-related metadata.
+  # @attr [String] api_endpoint       Base URL to the Ingenico ePayments platform
+  # @attr [String] api_key_id         Identifier of the _secret_api_key_ used in authentication.
+  # @attr [String] secret_api_key     Secret key used in authentication
+  # @attr [String] authorization_type String representing the authentication algorithm used
   class CommunicatorConfiguration < EndpointConfiguration
 
-    # Creates a new CommunicatorConfiguration instance, it accepts the following arguments:
-    #
-    # properties::              A hash that may contain any of the other parameters.
-    #                           If a parameter is given in both the _properties_ and separately,
-    #                           the separate value takes precedence.
-    # api_endpoint::            The base url to the Ingenico ePayments platform.
-    # api_key_id::              The identifier of the _secret_api_key_ used to authenticate requests.
-    # secret_api_key::          The key used to authenticate requests sent to the Ingenico ePayments platform.
-    # authorization_type::      String describing the authorization protocol to follow.
-    # connect_timeout::         The number of seconds before a connection attempt with the Ingenico ePayments platform times out.
-    # socket_timeout::          The number of seconds before a timeout occurs
-    #                           when transmitting data to or from the Ingenico ePayments platform.
-    # max_connections::         The number of connections with the Ingenico ePayments platform
-    #                           that are kept alive in the connection pool. These connections will be reused when possible.
-    # proxy_configuration::     {Ingenico::Connect::SDK::ProxyConfiguration} instance that stores the url to a proxy to be used in all communication,
-    #                           or nil if no proxy should be used.
-    # integrator::              String
-    # shopping_cart_extension:: {Ingenico::Connect::SDK::Domain::Metadata::ShoppingCartExtension} that stores shopping cart-related metadata.
+    # 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] hash that may contain any of the other parameters.
+    # @param api_endpoint            [String] the base URL to the Ingenico ePayments platform.
+    # @param api_key_id              [String] the identifier of the _secret_api_key_ used to authenticate requests.
+    # @param secret_api_key          [String] the key used to authenticate requests sent to the Ingenico ePayments platform.
+    # @param authorization_type      [String] string describing the authorization protocol to follow.
+    # @param connect_timeout         [Integer] the number of seconds before a connection attempt with the Ingenico ePayments platform times out.
+    # @param socket_timeout          [Integer] the number of seconds before a timeout occurs when transmitting data to or from the Ingenico ePayments platform.
+    # @param max_connections         [Integer] the number of connections with the Ingenico ePayments platform that are kept alive in the connection pool.
+    #                                These connections will be reused when possible.
+    # @param proxy_configuration     [Ingenico::Connect::SDK::ProxyConfiguration] stores the URL to a proxy to be used in all communication,
+    #                                or nil if no proxy should be used.
+    # @param integrator              [String] name of the integrator
+    # @param shopping_cart_extension [Ingenico::Connect::SDK::Domain::Metadata::ShoppingCartExtension] stores shopping cart-related metadata.
+    # @see EndpointConfiguration#initialize
     def initialize(properties: nil, api_endpoint: nil, api_key_id: nil,
                    secret_api_key: nil, authorization_type: nil,
                    connect_timeout: nil, socket_timeout: nil,
@@ -83,16 +72,9 @@ module Ingenico::Connect::SDK
       end
     end
 
-    # Base URL to the Ingenico ePayments platform
     attr_accessor :api_endpoint
-
-    # Identifier of the _secret_api_key_ used in authentication.
     attr_accessor :api_key_id
-
-    # Secret key used in authentication
     attr_accessor :secret_api_key
-
-    # String representing the authentication algorithm used
     attr_accessor :authorization_type
   end
 end

data/lib/ingenico/connect/sdk/connection.rb

@@ -6,24 +6,34 @@ module Ingenico::Connect::SDK
   class Connection
     include Ingenico::Connect::SDK::Logging::LoggingCapable
 
-    # Performs a GET request to _uri_ using _request_headers_ and returns the response as a {Ingenico::Connect::SDK::Response} object
+    # Performs a GET request to _uri_ using _request_headers_,
+    # and yields the response as the status code, headers and body.
+    #
+    # @yield (Integer, Array<Ingenico::Connect::SDK::ResponseHeader>, IO) The status code, headers and body of the response.
     def get(uri, request_headers)
       raise NotImplementedError
     end
 
-    # Performs a DELETE request to _uri_ using _request_headers_ and returns the response as a {Ingenico::Connect::SDK::Response} object
+    # Performs a DELETE request to _uri_ using _request_headers_,
+    # and yields the response as the status code, headers and body.
+    #
+    # @yield (Integer, Array<Ingenico::Connect::SDK::ResponseHeader>, IO) The status code, headers and body of the response.
     def delete(uri, request_headers)
       raise NotImplementedError
     end
 
-    # Performs a POST request to _uri_ using _request_headers_ and _body_.
-    # Returns the response as a {Ingenico::Connect::SDK::Response} object
+    # Performs a POST request to _uri_ using _request_headers_ and _body_,
+    # and yields the response as the status code, headers and body.
+    #
+    # @yield (Integer, Array<Ingenico::Connect::SDK::ResponseHeader>, IO) The status code, headers and body of the response.
     def post(uri, request_headers, body)
       raise NotImplementedError
     end
 
-    # Performs a PUT request to _uri_ using _request_headers_ and _body_.
-    # Returns the response as a {Ingenico::Connect::SDK::Response} object
+    # Performs a PUT request to _uri_ using _request_headers_ and _body_,
+    # and yields the response as the status code, headers and body.
+    #
+    # @yield (Integer, Array<Ingenico::Connect::SDK::ResponseHeader>, IO) The status code, headers and body of the response.
     def put(uri, request_headers, body)
       raise NotImplementedError
     end

data/lib/ingenico/connect/sdk/data_object.rb

@@ -8,6 +8,8 @@ module Ingenico::Connect::SDK
     # 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
@@ -26,18 +28,5 @@ module Ingenico::Connect::SDK
     # Note that the hash contains Strings as keys instead of more commonly used tokens.
     def from_hash(hash)
     end
-
-    private
-
-    # Adds a serializable hash or array representation of _value_ to _hash_ keyed under _key_
-    def add_to_hash(hash, key, value)
-      if value.is_a?(Array)  # For arrays, convert the elements to hash representations
-        hash[key] = value.collect{|val| if val.is_a?(DataObject); val.to_h else val end}
-      elsif value.is_a?(DataObject)
-        hash[key] = value.to_h
-      elsif !value.nil?
-        hash[key] = value
-      end
-    end
   end
 end

data/lib/ingenico/connect/sdk/declined_payment_exception.rb

@@ -16,7 +16,7 @@ module Ingenico::Connect::SDK
     end
 
     # The declined payment result returned by the Ingenico ePayments platform.
-    # Given as a {Ingenico::Connect::SDK::Domain::Payment::CreatePaymentResult} object.
+    # @return [Ingenico::Connect::SDK::Domain::Payment::CreatePaymentResult]
     def payment_result
       if @errors.nil?
         nil

data/lib/ingenico/connect/sdk/declined_payout_exception.rb

@@ -16,7 +16,7 @@ module Ingenico::Connect::SDK
     end
 
     # The declined payout result as returned by the Ingenico ePayments platform.
-    # Given as a {Ingenico::Connect::SDK::Domain::Payout::PayoutResult} object.
+    # @return [Ingenico::Connect::SDK::Domain::Payout::PayoutResult]
     def payout_result
       if @errors.nil?
         nil

data/lib/ingenico/connect/sdk/declined_refund_exception.rb

@@ -18,7 +18,7 @@ module Ingenico::Connect::SDK
     end
 
     # The declined refund result as returned by the Ingenico ePayments platform.
-    # Given as a {Ingenico::Connect::SDK::Domain::Refund::RefundResult} object.
+    # @return [Ingenico::Connect::SDK::Domain::Refund::RefundResult]
     def refund_result
       if @errors.nil?
         nil

data/lib/ingenico/connect/sdk/defaultimpl/authorization_type.rb

@@ -5,11 +5,12 @@ module Ingenico::Connect::SDK
     class AuthorizationType
       V1HMAC = 'v1HMAC'
 
-      # Returns the authorization string that belongs to the parameter _authorization_, or _nil_ if not found.
+      # @return [String] the authorization string that belongs to the parameter _authorization_, or _nil_ if not found.
       def self.get_authorization(authorization)
         authorization if authorization == 'v1HMAC'
       end
 
+      # @return [String]
       def self.get_signature_string
         V1HMAC
       end

data/lib/ingenico/connect/sdk/defaultimpl/default_authenticator.rb

@@ -15,9 +15,10 @@ module Ingenico::Connect::SDK
 
       # Construct a new DefaultAuthenticator instance that can sign requests
       # with the provided _api_key_id_ and _secret_api_key_.
-      # authorization_type::  The authorization protocol to use for authentication.
-      # api_key_id::          Identifier for the secret key used in authentication.
-      # secret_api_key::      The secret key that is used to generate the authentication signature.
+      #
+      # @param authorization_type [String] the authorization protocol to use for authentication.
+      # @param api_key_id         [String] identifier for the secret key used in authentication.
+      # @param secret_api_key     [String] the secret key that is used to generate the authentication signature.
       def initialize(authorization_type, api_key_id, secret_api_key)
         raise ArgumentError unless authorization_type
         raise ArgumentError unless api_key_id and not api_key_id.strip.empty?
@@ -29,10 +30,11 @@ module Ingenico::Connect::SDK
       end
 
       # Creates a signature to authenticate a request.
-      # Uses the following parameters:
-      # http_method::     'GET', 'PUT', 'POST' or 'DELETE' indicating which HTTP method will be used with the request
-      # resource_uri::    URI object that includes #path and #query of the url that will be used, #query may be *nil*
-      # request_headers:: {Ingenico::Connect::SDK::RequestHeader} list that contains all headers used by the request
+      #
+      # @param http_method  [String] 'GET', 'PUT', 'POST' or 'DELETE' indicating which HTTP method will be used with the request
+      # @param resource_uri [URI::HTTP] URI object that includes #path and #query of the URL that will be used, #query may be *nil*
+      # @param http_headers [Array<Ingenico::Connect::SDK::RequestHeader>] list that contains all headers used by the request
+      # @return [String] the created signature
       def create_simple_authentication_signature(http_method, resource_uri, http_headers)
         raise ArgumentError unless http_method and not http_method.strip.empty?
         raise ArgumentError unless resource_uri

data/lib/ingenico/connect/sdk/defaultimpl/default_connection.rb

@@ -16,22 +16,22 @@ end
 module Ingenico::Connect::SDK
   module DefaultImpl
     class DefaultConnection < PooledConnection
-
       using RefineHTTPClient
 
       CONTENT_TYPE = 'Content-Type'.freeze
       JSON_CONTENT_TYPE = 'application/json'.freeze
 
-      # Initialized using a hash containing the following parameters:
-      # connect_timeout::     Connection timeout in seconds.
-      # socket_timeout::      Socket timeout in seconds.
-      # max_connections::     Number of connections kept alive in the thread pool.
-      #                       Uses {Ingenico::Connect::SDK::CommunicatorConfiguration.DEFAULT_MAX_CONNECTIONS} if not given.
-      # proxy_configuration:: {Ingenico::Connect::SDK::ProxyConfiguration} object that stores the proxy to use.
-      #                       If not given the system default proxy is used;
-      #                       if there is no system default proxy set either, no proxy is used.
+      # @param args [Hash] the parameters to initialize the connection with
+      # @option args [Integer] :connect_timeout connection timeout in seconds.
+      # @option args [Integer] :socket_timeout socket timeout in seconds.
+      # @option args [Integer] :max_connections number of connections kept alive in the thread pool.
+      #              Uses {Ingenico::Connect::SDK::CommunicatorConfiguration.DEFAULT_MAX_CONNECTIONS} if not given.
+      # @option args [Ingenico::Connect::SDK::ProxyConfiguration] :proxy_configuration object that stores the proxy to use.
+      #              If not given the system default proxy is used;
+      #              if there is no system default proxy set either, no proxy is used.
       def initialize(args)
         raise ArgumentError unless args.is_a? Hash
+
         # Set timeouts to nil if they are negative
         @connect_timeout = args[:connect_timeout]
         @connect_timeout = nil unless @connect_timeout.nil? || @connect_timeout > 0
@@ -59,15 +59,17 @@ module Ingenico::Connect::SDK
         if @proxy_configuration
           httpclient = HTTPClient.new(@proxy_configuration.proxy_uri)
           httpclient.set_proxy_auth(@proxy_configuration.username, @proxy_configuration.password)
+          httpclient.force_basic_auth = true unless @proxy_configuration.username.nil? || @proxy_configuration.password.nil?
           httpclient
         else # use system settings
           proxy_string = ENV['https_proxy'] || ENV['http_proxy']
           # proxy string format = 'http://username:password@hostname:port'
-          proxy_string =~ %r(https?//(?<username>[^:]):(?<password>[^@])@.*)
-          username = $1
-          password = $2
+          proxy_string =~ %r{https?//(?<username>[^:]):(?<password>[^@])@.*}
+          username = Regexp.last_match(1)
+          password = Regexp.last_match(2)
           httpclient = HTTPClient.new(proxy_string)
           httpclient.set_proxy_auth(username, password) unless username.nil? || password.nil?
+          httpclient.force_basic_auth = true unless username.nil? || password.nil?
           httpclient
         end
       end
@@ -102,65 +104,100 @@ module Ingenico::Connect::SDK
       # Performs a GET request to the Ingenico ePayments platform
       # @see request
       def get(uri, request_headers)
-        request('get', uri, request_headers)
+        request('get', uri, request_headers) do |response_status_code, response_headers, response_body|
+          yield response_status_code, response_headers, response_body
+        end
       end
 
       # Performs a DELETE request to the Ingenico ePayments platform
       # @see request
       def delete(uri, request_headers)
-        request('delete', uri, request_headers)
+        request('delete', uri, request_headers) do |response_status_code, response_headers, response_body|
+          yield response_status_code, response_headers, response_body
+        end
       end
 
       # Performs a POST request to the Ingenico ePayments platform
       # @see request
       def post(uri, request_headers, body)
-        request('post', uri, request_headers, body)
+        request('post', uri, request_headers, body) do |response_status_code, response_headers, response_body|
+          yield response_status_code, response_headers, response_body
+        end
       end
 
       # Performs a PUT request to the Ingenico ePayments platform
       # @see request
       def put(uri, request_headers, body)
-        request('put', uri, request_headers, body)
+        request('put', uri, request_headers, body) do |response_status_code, response_headers, response_body|
+          yield response_status_code, response_headers, response_body
+        end
       end
 
-      # performs a HTTP request and returns the response as an {Ingenico::Connect::SDK::Response} object.
+      # Performs a HTTP request and yields the response as the status code, headers and body.
       # Also ensures the request is logged when sent and its response is logged when received.
-      # Raises {Ingenico::Connect::SDK::CommunicationException} when communication with the Ingenico ePayments platform was not successful.
-      # method::          'GET', 'DELETE', 'POST' or 'PUT' depending on the HTTP method being used.
-      # uri::             Full URI of the location the request is targeted at, including query parameters.
-      # request_headers:: {Ingenico::Connect::SDK::RequestHeader} list of headers that should be used as HTTP headers in the request.
-      # body::            Request body as a String.
-      def request(method, uri, request_headers, body=nil)
+      #
+      # @param method          [String] 'GET', 'DELETE', 'POST' or 'PUT' depending on the HTTP method being used.
+      # @param uri             [URI::HTTP] full URI of the location the request is targeted at, including query parameters.
+      # @param request_headers [Array<Ingenico::Connect::SDK::RequestHeader>] list of headers that should be used as HTTP headers in the request.
+      # @param body            [String, Ingenico::Connect::SDK::MultipartFormDataObject] request body.
+      # @yield (Integer, Array<Ingenico::Connect::SDK::ResponseHeader>, IO) The status code, headers and body of the response.
+      # @raise [Ingenico::Connect::SDK::CommunicationException] when communication with the Ingenico ePayments platform was not successful.
+      def request(method, uri, request_headers, body = nil)
         request_headers = convert_from_sdk_headers(request_headers)
         request_id = SecureRandom.uuid
-        request_headers[CONTENT_TYPE] = JSON_CONTENT_TYPE if body
         content_type = request_headers[CONTENT_TYPE]
+
         info = { headers: request_headers, content_type: content_type }
         info[:body] = body unless body.nil?
+
         log_request(request_id, method.upcase, uri, info)
 
         start_time = Time.now
         begin
-          response = if body
-                       @http_client.send(method, uri, header: request_headers, body: body)
-                     else
-                       @http_client.send(method, uri, header: request_headers)
-                     end
+          response_headers = nil
+          response_status_code = nil
+          response_content_type = nil
+          response_body = ''
+
+          if body.is_a? Ingenico::Connect::SDK::MultipartFormDataObject
+            multipart_request(method, uri, request_headers, body) do |status_code, headers, r_content_type, r_body|
+              response_headers = headers
+              response_status_code = status_code
+              response_content_type = r_content_type
+              unless binary_content_type? response_content_type
+                response_body = r_body.read.force_encoding('UTF-8')
+                r_body = StringIO.new(response_body)
+              end
+
+              yield status_code, headers, r_body
+            end
+          else
+            raw_request(method, uri, request_headers, body) do |status_code, headers, r_content_type, r_body|
+              response_headers = headers
+              response_status_code = status_code
+              response_content_type = r_content_type
+              unless binary_content_type? response_content_type
+                response_body = r_body.read.force_encoding('UTF-8')
+                r_body = StringIO.new(response_body)
+              end
+
+              yield status_code, headers, r_body
+            end
+          end
+
+          log_response(request_id, response_status_code, start_time,
+                       headers: response_headers, body: response_body,
+                       content_type: response_content_type)
         rescue HTTPClient::TimeoutError => e
           log_error(request_id, start_time, e)
-          raise Ingenico::Connect::SDK::CommunicationException.new(e)
-        rescue HTTPClient::KeepAliveDisconnected, HTTPClient::RetryableResponse => e  # retry these?
+          raise Ingenico::Connect::SDK::CommunicationException, e
+        rescue HTTPClient::KeepAliveDisconnected, HTTPClient::RetryableResponse => e # retry these?
           log_error(request_id, start_time, e)
-          raise Ingenico::Connect::SDK::CommunicationException.new(e)
-        rescue => e
+          raise Ingenico::Connect::SDK::CommunicationException, e
+        rescue StandardError => e
           log_error(request_id, start_time, e)
-          raise Ingenico::Connect::SDK::CommunicationException.new(e)
+          raise Ingenico::Connect::SDK::CommunicationException, e
         end
-
-        log_response(request_id, response.status, start_time,
-                     headers: response.headers, body: response.body,
-                     content_type: response.content_type)
-        convert_to_sdk_response(response)
       end
 
       # logging code
@@ -169,10 +206,10 @@ module Ingenico::Connect::SDK
       # Note that only one logger can be registered at a time and calling _enable_logging_
       # a second time will override the old logger instance with the new one.
       #
-      # communicator_logger:: The {Ingenico::Connect::SDK::Logging::CommunicatorLogger} the requests and responses are logged to
-      #
+      # @param communicator_logger [Ingenico::Connect::SDK::Logging::CommunicatorLogger] the communicator logger the requests and responses are logged to
       def enable_logging(communicator_logger)
-        raise ArgumentError.new('communicatorLogger is required') unless communicator_logger
+        raise ArgumentError, 'communicatorLogger is required' unless communicator_logger
+
         @communicator_logger = communicator_logger
       end
 
@@ -185,56 +222,163 @@ module Ingenico::Connect::SDK
 
       # Converts a {Ingenico::Connect::SDK::RequestHeader} list headers to a hash
       def convert_from_sdk_headers(headers)
-        headers.inject({}) { |hash, h| hash[h.name] =  h.value ; hash}
+        headers.each_with_object({}) { |h, hash| hash[h.name] = h.value }
       end
 
       # Converts a hash to a {Ingenico::Connect::SDK::ResponseHeader} list
-      def convert_to_sdk_headers(headers)
-        headers.inject([]) { |arr, (k, v)| arr << Ingenico::Connect::SDK::ResponseHeader.new(k, v) }
+      def convert_to_sdk_response_headers(headers)
+        arr ||= []
+        headers.each { |k, v| arr << Ingenico::Connect::SDK::ResponseHeader.new(k, v) }
+        arr
       end
 
-      # converts a HTTPClient response to a {Ingenico::Connect::SDK::Response}
-      def convert_to_sdk_response(response)
-        Ingenico::Connect::SDK::Response.new(response.status,
-                         response.body,
-                         convert_to_sdk_headers(response.headers))
-      end
-
-      def log_request(requestId, method, uri, args={})
+      def log_request(request_id, method, uri, args = {})
         return unless @communicator_logger
 
-        headers, body, content_type = args[:headers], args[:body], args[:content_type]
-        log_msg_builder = Ingenico::Connect::SDK::Logging::RequestLogMessageBuilder.new(requestId, method, uri)
+        headers = args[:headers]
+        body = args[:body]
+        content_type = args[:content_type]
+        log_msg_builder = Ingenico::Connect::SDK::Logging::RequestLogMessageBuilder.new(request_id, method, uri)
         headers.each { |k, v| log_msg_builder.add_headers(k, v) } if headers
-        log_msg_builder.set_body(body, content_type)
+
+        if binary?(headers)
+          log_msg_builder.set_body('<binary content>', content_type)
+        else
+          log_msg_builder.set_body(body, content_type)
+        end
 
         begin
           @communicator_logger.log(log_msg_builder.get_message)
-        rescue => e
-          @communicator_logger.log("An error occurred trying to log request #{requestId}", e)
+        rescue StandardError => e
+          @communicator_logger.log("An error occurred trying to log request #{request_id}", e)
         end
       end
 
-      def log_response(requestId, status_code, start_time, args={})
+      # Creates the log_response stream
+      # both based on whether or not it is binary and on the rest of the response
+      def log_response(request_id, status_code, start_time, args = {})
         return unless @communicator_logger
 
-        duration = (Time.now - start_time) * 1000 # in millisecs
-        headers, body, content_type = args[:headers], args[:body], args[:content_type]
-        log_msg_builder = Ingenico::Connect::SDK::Logging::ResponseLogMessageBuilder.new(requestId, status_code, duration)
-        headers.each { |k, v| log_msg_builder.add_headers(k, v) } if headers
-        log_msg_builder.set_body(body, content_type)
+        duration      = (Time.now - start_time) * 1000 # in milliseconds
+        headers       = args[:headers]
+        body          = args[:body] unless args[:body].nil?
+        content_type  = args[:content_type]
+
+        log_msg_builder = Ingenico::Connect::SDK::Logging::ResponseLogMessageBuilder.new(request_id, status_code, duration)
+        unless headers.nil?
+          headers = convert_from_sdk_headers(headers)
+          headers.each do |key, value|
+            log_msg_builder.add_headers(key, value)
+          end
+        end
+
+        if binary_content_type?(content_type)
+          log_msg_builder.set_body('<binary content>', content_type)
+        else
+          log_msg_builder.set_body(body, content_type)
+        end
 
         begin
           @communicator_logger.log(log_msg_builder.get_message)
-        rescue => e
-          @communicator_logger.log("An error occurred trying to log response #{requestId}", e)
+        rescue StandardError => e
+          @communicator_logger.log("An error occurred trying to log response #{request_id}", e)
         end
       end
 
-      def log_error(requestId, start_time, thrown)
+      def log_error(request_id, start_time, thrown)
         return unless @communicator_logger
+
         duration = (Time.now - start_time) * 1000 # in millisecs
-        @communicator_logger.log("Error occurred for outgoing request (requestId='#{requestId}', #{duration} ms)", thrown)
+        @communicator_logger.log("Error occurred for outgoing request (requestId='#{request_id}', #{duration} ms)", thrown)
+      end
+
+      # @param headers [Hash]
+      def binary?(headers)
+        unless headers.nil?
+          content_type = nil
+          headers.each { |k, v| content_type = v if k.casecmp(CONTENT_TYPE).zero? }
+
+          binary_content_type?(content_type)
+        end
+      end
+
+      # @param content_type [String]
+      def binary_content_type?(content_type)
+        unless content_type.nil?
+          content_type = content_type.downcase
+          return !content_type.start_with?('text/') &&
+                 !content_type.include?('json') &&
+                 !content_type.include?('xml')
+        end
+        false
+      end
+
+      # Makes a request using the specified method
+      #
+      # Yields a status code, an array of {Ingenico::Connect::SDK::ResponseHeader},
+      # the content_type and body
+      def raw_request(method, uri, headers, body = nil)
+        connection = if body
+                       @http_client.send(method + '_async', uri, body: body, header: headers)
+                     else
+                       @http_client.send(method + '_async', uri, header: headers)
+                     end
+
+        response = connection.pop
+        pipe = response.content
+        response_headers = convert_to_sdk_response_headers(response.headers)
+
+        begin
+          yield response.status_code, response_headers, response.content_type, pipe
+        ensure
+          pipe.close
+        end
+      end
+
+      # Makes a request using the specified method
+      #
+      # Yields a status code, an array of {Ingenico::Connect::SDK::ResponseHeader},
+      # the content_type and body
+      def multipart_request(method, uri, headers, body = nil)
+        unless body.is_a? Ingenico::Connect::SDK::MultipartFormDataObject
+          raise ArgumentError, 'body should be a MultipartFormDataObject'
+        end
+
+        if method != 'post' && method != 'put'
+          raise ArgumentError, "method #{method} is not supported"
+        end
+
+        connection = @http_client.send method + '_async',
+                                       uri,
+                                       body: multipart_request_body(body),
+                                       header: headers
+
+        response = connection.pop
+        pipe = response.content
+        response_headers = convert_to_sdk_response_headers(response.headers)
+
+        begin
+          yield response.status_code, response_headers, response.content_type, pipe
+        ensure
+          pipe.close
+        end
+      end
+
+      # Creates a request body for the multipart request
+      def multipart_request_body( body )
+        request_body = []
+        body.files.each do |k, v|
+          request_body.push :content => v.content,
+                            'Content-Type' => v.content_type,
+                            'Content-Disposition' => "form-data; name=\"#{k}\"; filename=\"#{v.file_name}\"",
+                            'Content-Transfer-Encoding' => 'binary'
+        end
+
+        body.values.each do |k, v|
+          request_body << { :content => v,
+                            'Content-Disposition' => "form-data; name=\"#{k}\"" }
+        end
+        request_body
       end
     end
   end