connect-sdk-python2 3.47.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/metadata_provider.py

@@ -0,0 +1,130 @@
+import platform
+import re
+from base64 import b64encode
+
+from request_header import RequestHeader
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.domain.shopping_cart_extension import ShoppingCartExtension
+from worldline.connect.sdk.json.default_marshaller import DefaultMarshaller
+
+
+class IterProperty(object):
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, owner):
+        return self.func(owner)
+
+
+class MetadataProvider(object):
+    """
+    Provides meta info about the server.
+    """
+    __sdk_version = "4.0.1"
+    __server_meta_info_header = "X-GCS-ServerMetaInfo"
+    __prohibited_headers = tuple(sorted([__server_meta_info_header, "X-GCS-Idempotence-Key", "Date", "Content-Type", "Authorization"],
+                                        key=str.lower))
+    __metadata_headers = None
+
+    class ServerMetaInfo(DataObject):
+        platform_identifier = None
+        sdk_identifier = None
+        sdk_creator = None
+        integrator = None
+        shopping_cart_extension = None
+
+        def to_dictionary(self):
+            dictionary = super(MetadataProvider.ServerMetaInfo, self).to_dictionary()
+            if self.platform_identifier is not None:
+                dictionary['platformIdentifier'] = self.platform_identifier
+            if self.sdk_identifier is not None:
+                dictionary['sdkIdentifier'] = self.sdk_identifier
+            if self.sdk_creator is not None:
+                dictionary['sdkCreator'] = self.sdk_creator
+            if self.integrator is not None:
+                dictionary['integrator'] = self.integrator
+            if self.shopping_cart_extension is not None:
+                dictionary['shoppingCartExtension'] = self.shopping_cart_extension.to_dictionary()
+            return dictionary
+
+        def from_dictionary(self, dictionary):
+            super(MetadataProvider.ServerMetaInfo, self).from_dictionary(dictionary)
+            if 'platformIdentifier' in dictionary:
+                self.platform_identifier = dictionary['platformIdentifier']
+            if 'sdkIdentifier' in dictionary:
+                self.sdk_identifier = dictionary['sdkIdentifier']
+            if 'sdkCreator' in dictionary:
+                self.sdk_creator = dictionary['sdkCreator']
+            if 'integrator' in dictionary:
+                self.integrator = dictionary['integrator']
+            if 'shoppingCartExtension' in dictionary:
+                if not isinstance(dictionary['shoppingCartExtension'], dict):
+                    raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shoppingCartExtension']))
+                self.shopping_cart_extension = ShoppingCartExtension.create_from_dictionary(dictionary['shoppingCartExtension'])
+            return self
+
+    def __init__(self, integrator, shopping_cart_extension=None,
+                 additional_request_headers=()):
+        if integrator is None or not integrator.strip():
+            raise ValueError("integrator is required")
+
+        MetadataProvider.__validate_additional_request_headers(additional_request_headers)
+
+        def subber(name_or_value):
+            return re.sub(r'\r?\n(?:(?![\r\n])\s)*', " ", name_or_value).strip()
+        additional_request_headers = [RequestHeader(subber(header.name), subber(header.value)) for header in additional_request_headers]
+
+        server_meta_info = self.ServerMetaInfo()
+        server_meta_info.platform_identifier = self._platform_identifier
+        server_meta_info.sdk_identifier = self._sdk_identifier
+        server_meta_info.sdk_creator = "Worldline"
+        server_meta_info.integrator = integrator
+        server_meta_info.shopping_cart_extension = shopping_cart_extension
+
+        server_meta_info_string = DefaultMarshaller.instance().marshal(server_meta_info)
+        server_meta_info_header = RequestHeader(self.__server_meta_info_header, b64encode(server_meta_info_string.encode('utf-8')))
+        if not additional_request_headers:
+            self.__metadata_headers = tuple([server_meta_info_header])
+        else:
+            request_headers = [server_meta_info_header]
+            request_headers.extend(additional_request_headers)
+            self.__metadata_headers = tuple(request_headers)
+
+    @staticmethod
+    def __validate_additional_request_headers(additional_request_headers):
+        if additional_request_headers is not None:
+            for additional_request_header in additional_request_headers:
+                MetadataProvider.__validate_additional_request_header(additional_request_header)
+
+    @staticmethod
+    def __validate_additional_request_header(additional_request_header):
+        try:
+            if additional_request_header.name in MetadataProvider.__prohibited_headers:
+                raise ValueError("request header not allowed: " + str(additional_request_header))
+        except AttributeError:
+            raise AttributeError("Each request header should have an attribute 'name' and an attribute 'value'")
+
+    @IterProperty
+    def prohibited_headers(self):
+        return self.__prohibited_headers
+
+    @property
+    def metadata_headers(self):
+        """
+        :return: The server related headers containing the metadata to be
+         associated with the request (if any). This will always contain at least
+         an automatically generated header X-GCS-ServerMetaInfo.
+        """
+        return self.__metadata_headers
+
+    @property
+    def _platform_identifier(self):
+        return platform.system() + " " + platform.release() + "/" + \
+               platform.version() + " Python/" + platform.python_version() + \
+               " (" + platform.python_implementation() + "; " + \
+               str(platform.python_compiler()) + ")"
+
+    @property
+    def _sdk_identifier(self):
+        return "Python2ServerSDK/v" + self.__sdk_version

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/multipart_form_data_object.py

@@ -0,0 +1,47 @@
+import uuid
+
+
+class MultipartFormDataObject(object):
+    """
+    A representation of a multipart/form-data object.
+    """
+
+    def __init__(self):
+        self.__boundary = str(uuid.uuid4())
+        self.__content_type = "multipart/form-data; boundary=" + self.__boundary
+        self.__values = {}
+        self.__files = {}
+
+    @property
+    def boundary(self):
+        return self.__boundary
+
+    @property
+    def content_type(self):
+        return self.__content_type
+
+    @property
+    def values(self):
+        return self.__values
+
+    @property
+    def files(self):
+        return self.__files
+
+    def add_value(self, parameter_name, value):
+        if parameter_name is None or not parameter_name.strip():
+            raise ValueError("parameter_name is required")
+        if value is None:
+            raise ValueError("value is required")
+        if parameter_name in self.__values or parameter_name in self.__files:
+            raise ValueError("duplicate parameterName: " + parameter_name)
+        self.__values[parameter_name] = value
+
+    def add_file(self, parameter_name, uploadable_file):
+        if parameter_name is None or not parameter_name.strip():
+            raise ValueError("parameter_name is required")
+        if uploadable_file is None:
+            raise ValueError("uploadable_file is required")
+        if parameter_name in self.__values or parameter_name in self.__files:
+            raise ValueError("duplicate parameterName: " + parameter_name)
+        self.__files[parameter_name] = uploadable_file

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/multipart_form_data_request.py

@@ -0,0 +1,15 @@
+from abc import ABCMeta, abstractmethod
+
+
+class MultipartFormDataRequest(object):
+    """
+    A representation of a multipart/form-data request.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def to_multipart_form_data_object(self):
+        """
+        :return: :class:`worldline.connect.sdk.communication.MultipartFormDataObject`
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/not_found_exception.py

@@ -0,0 +1,10 @@
+class NotFoundException(RuntimeError):
+    """
+    Indicates an exception that occurs when the requested resource is not found.
+    In normal usage of the SDK, this exception should not occur, however it is possible.
+    For example when path parameters are set with invalid values.
+    """
+
+    def __init__(self, exception, message):
+        super(NotFoundException, self).__init__(message, exception)
+        self.cause = exception

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/param_request.py

@@ -0,0 +1,15 @@
+from abc import ABCMeta, abstractmethod
+
+
+class ParamRequest(object):
+    """
+    Represents a set of request parameters.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def to_request_parameters(self):
+        """
+        :return: list[:class:`worldline.connect.sdk.communication.RequestParam`] representing the HTTP request parameters
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/pooled_connection.py

@@ -0,0 +1,29 @@
+from abc import ABCMeta, abstractmethod
+
+from connection import Connection
+
+
+class PooledConnection(Connection):
+    """
+    Represents a pooled connection to the Worldline Global Collect platform server.
+    Instead of setting up a new HTTP connection for each request, this
+    connection uses a pool of HTTP connections.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def close_idle_connections(self, idle_time):
+        """
+        Closes all HTTP connections that have been idle for the specified time.
+        This should also include all expired HTTP connections.
+
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def close_expired_connections(self):
+        """
+        Closes all expired HTTP connections.
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/request_header.py

@@ -0,0 +1,57 @@
+class RequestHeader(object):
+    """
+    A single request header. Immutable.
+    """
+
+    def __init__(self, name, value):
+        if name is None or not name.strip():
+            raise ValueError("name is required")
+        self.__name = name
+        self.__value = value
+
+    @property
+    def name(self):
+        """
+        :return: The header name.
+        """
+        return self.__name
+
+    @property
+    def value(self):
+        """
+        :return: The un-encoded value.
+        """
+        return self.__value
+
+    def __str__(self):
+        return self.__name + ":" + self.__value
+
+
+def get_header_value(headers, header_name):
+    """
+    :return: The value of the header with the given name, or None if there was no such header.
+    """
+    if isinstance(headers, dict):
+        for name, value in headers.iteritems():
+            if name.lower() == header_name.lower():
+                return value
+    elif headers is not None:
+        for header in headers:
+            if header.name.lower() == header_name.lower():
+                return header.value
+    return None
+
+
+def get_header(headers, header_name):
+    """
+    :return: The header with the given name, or None if there was no such header.
+    """
+    if isinstance(headers, dict):
+        for name, value in headers.iteritems():
+            if name.lower() == header_name.lower():
+                return RequestHeader(name, value)
+    elif headers is not None:
+        for header in headers:
+            if header.name.lower() == header_name.lower():
+                return header
+    return None

connect-sdk-python2-4.0.1/worldline/connect/sdk/communication/response_exception.py

@@ -0,0 +1,56 @@
+from response_header import get_header_value, get_header
+
+
+class ResponseException(RuntimeError):
+    """
+    Thrown when a response was received from the Worldline Global Collect platform which indicates an error.
+    """
+
+    def __init__(self, status, body, headers):
+        super(ResponseException, self).__init__("the Worldline Global Collect platform returned an error response")
+        self.__status_code = status
+        self.__headers = headers if headers is not None else {}
+        self.__body = body
+
+    @property
+    def status_code(self):
+        """
+        :return: The HTTP status code that was returned by the Worldline Global Collect platform.
+        """
+        return self.__status_code
+
+    @property
+    def body(self):
+        """
+        :return: The raw response body that was returned by the Worldline Global Collect platform.
+        """
+        return self.__body
+
+    @property
+    def headers(self):
+        """
+        :return: The headers that were returned by the Worldline Global Collect platform. Never None.
+        """
+        return self.__headers
+
+    def get_header(self, header_name):
+        """
+        :return: The header with the given name, or None if there was no such header.
+        """
+        return get_header(self.__headers, header_name)
+
+    def get_header_value(self, header_name):
+        """
+        :return: The value header with the given name, or None if there was no such header.
+        """
+        return get_header_value(self.__headers, header_name)
+
+    def __str__(self):
+        string = super(ResponseException, self).__str__()
+        status_code = self.__status_code
+        if status_code > 0:
+            string += "; status_code=" + str(status_code)
+        response_body = self.__body
+        if response_body:
+            string += "; response_body='" + response_body + "'"
+        return str(string)