connect-sdk-python2 3.47.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.1/worldline/connect/sdk/communicator_configuration.py

@@ -0,0 +1,296 @@
+from ConfigParser import NoOptionError
+from urlparse import urlparse
+
+from proxy_configuration import ProxyConfiguration
+
+from worldline.connect.sdk.authentication.authorization_type import AuthorizationType
+from worldline.connect.sdk.domain.shopping_cart_extension import ShoppingCartExtension
+
+
+# pylint: disable=too-many-instance-attributes
+# Necessary to load information from config
+class CommunicatorConfiguration(object):
+    """
+    Configuration for the communicator.
+    """
+    # The default number of maximum connections.
+    DEFAULT_MAX_CONNECTIONS = 10
+
+    __api_endpoint = None
+    __connect_timeout = None
+    __socket_timeout = None
+    __max_connections = None
+    __authorization_type = None
+    __authorization_id = None
+    __authorization_secret = None
+    __proxy_configuration = None
+    __integrator = None
+    __shopping_cart_extension = None
+
+    def __init__(self, properties=None,
+                 api_endpoint=None,
+                 authorization_id=None, authorization_secret=None,
+                 api_key_id=None, secret_api_key=None,
+                 authorization_type=None,
+                 connect_timeout=None, socket_timeout=None,
+                 max_connections=None, proxy_configuration=None,
+                 integrator=None, shopping_cart_extension=None):
+        """
+        :param properties: a ConfigParser.ConfigParser object containing configuration data
+        :param connect_timeout: connection timeout for the network communication in seconds
+        :param socket_timeout: socket timeout for the network communication in seconds
+        :param max_connections: The maximum number of connections in the connection pool
+        """
+        if properties and properties.sections() and properties.options("ConnectSDK"):
+            self.__api_endpoint = self.__get_endpoint(properties)
+            authorization = properties.get("ConnectSDK", "connect.api.authorizationType")
+            self.__authorization_type = AuthorizationType.get_authorization(authorization)
+            self.__connect_timeout = int(properties.get("ConnectSDK", "connect.api.connectTimeout"))
+            self.__socket_timeout = int(properties.get("ConnectSDK", "connect.api.socketTimeout"))
+            self.__max_connections = self.__get_property(properties, "connect.api.maxConnections",
+                                                         self.DEFAULT_MAX_CONNECTIONS)
+            try:
+                proxy_uri = properties.get("ConnectSDK", "connect.api.proxy.uri")
+            except NoOptionError:
+                proxy_uri = None
+            try:
+                proxy_user = properties.get("ConnectSDK", "connect.api.proxy.username")
+            except NoOptionError:
+                proxy_user = None
+            try:
+                proxy_pass = properties.get("ConnectSDK", "connect.api.proxy.password")
+            except NoOptionError:
+                proxy_pass = None
+            if proxy_uri is not None:
+                self.__proxy_configuration = ProxyConfiguration.from_uri(proxy_uri, proxy_user, proxy_pass)
+            else:
+                self.__proxy_configuration = None
+            try:
+                self.__integrator = properties.get("ConnectSDK", "connect.api.integrator")
+            except NoOptionError:
+                self.__integrator = None
+            try:
+                self.__shopping_cart_extension = self.__get_shopping_cart_extension(properties)
+            except NoOptionError:
+                self.__shopping_cart_extension = None
+
+        if api_endpoint:
+            self.api_endpoint = api_endpoint
+        if authorization_id:
+            self.authorization_id = authorization_id
+        if authorization_secret:
+            self.authorization_secret = authorization_secret
+        if api_key_id:
+            self.api_key_id = api_key_id
+        if secret_api_key:
+            self.secret_api_key = secret_api_key
+        if authorization_type:
+            self.authorization_type = authorization_type
+        if connect_timeout:
+            self.connect_timeout = connect_timeout
+        if socket_timeout:
+            self.socket_timeout = socket_timeout
+        if max_connections:
+            self.max_connections = max_connections
+        if proxy_configuration:
+            self.proxy_configuration = proxy_configuration
+        if integrator:
+            self.integrator = integrator
+        if shopping_cart_extension:
+            self.shopping_cart_extension = shopping_cart_extension
+
+    @staticmethod
+    def __get_property(properties, key, default_value):
+        try:
+            property_value = properties.get("ConnectSDK", key)
+        except NoOptionError:
+            property_value = None
+        if property_value is not None:
+            return int(property_value)
+        else:
+            return default_value
+
+    def __get_endpoint(self, properties):
+        host = properties.get("ConnectSDK", "connect.api.endpoint.host")
+        try:
+            scheme = properties.get("ConnectSDK", "connect.api.endpoint.scheme")
+        except NoOptionError:
+            scheme = None
+        try:
+            port = properties.get("ConnectSDK", "connect.api.endpoint.port")
+        except NoOptionError:
+            port = None
+        if scheme:
+            if port:
+                return self.__create_uri(scheme, host, int(port))
+            else:
+                return self.__create_uri(scheme, host, -1)
+        elif port:
+            return self.__create_uri("https", host, int(port))
+        else:
+            return self.__create_uri("https", host, -1)
+
+    @staticmethod
+    def __create_uri(scheme, host, port):
+        if port != -1:
+            uri = scheme + "://" + host + ":" + str(port)
+        else:
+            uri = scheme + "://" + host
+        url = urlparse(uri)
+        if not url.scheme.lower() in ["http", "https"] or not url.netloc:
+            raise ValueError("Unable to construct endpoint URI")
+        return url
+
+    @staticmethod
+    def __get_shopping_cart_extension(properties):
+        try:
+            creator = properties.get("ConnectSDK", "connect.api.shoppingCartExtension.creator")
+        except NoOptionError:
+            creator = None
+        try:
+            name = properties.get("ConnectSDK", "connect.api.shoppingCartExtension.name")
+        except NoOptionError:
+            name = None
+        try:
+            version = properties.get("ConnectSDK", "connect.api.shoppingCartExtension.version")
+        except NoOptionError:
+            version = None
+        try:
+            extension_id = properties.get("ConnectSDK", "connect.api.shoppingCartExtension.extensionId")
+        except NoOptionError:
+            extension_id = None
+        if creator is None and name is None and version is None and extension_id is None:
+            return None
+        else:
+            return ShoppingCartExtension(creator, name, version, extension_id)
+
+    @property
+    def api_endpoint(self):
+        """
+        The Worldline Global Collect platform API endpoint URI.
+        """
+        return self.__api_endpoint
+
+    @api_endpoint.setter
+    def api_endpoint(self, api_endpoint):
+        if isinstance(api_endpoint, basestring):
+            api_endpoint = urlparse(str(api_endpoint))
+        if api_endpoint is not None and api_endpoint.path:
+            raise ValueError("apiEndpoint should not contain a path")
+        if api_endpoint is not None and \
+                (api_endpoint.username is not None or api_endpoint.query or api_endpoint.fragment):
+            raise ValueError("apiEndpoint should not contain user info, query or fragment")
+        self.__api_endpoint = api_endpoint
+
+    @property
+    def authorization_id(self):
+        """
+        An id used for authorization. The meaning of this id is different for each authorization type.
+        For instance, for v1HMAC this is the identifier for the secret API key.
+        """
+        return self.__authorization_id
+
+    @authorization_id.setter
+    def authorization_id(self, authorization_id):
+        self.__authorization_id = authorization_id
+
+    @property
+    def authorization_secret(self):
+        """
+        A secret used for authorization. The meaning of this secret is different for each authorization type.
+        For instance, for v1HMAC this is the secret API key.
+        """
+        return self.__authorization_secret
+
+    @authorization_secret.setter
+    def authorization_secret(self, authorization_secret):
+        self.__authorization_secret = authorization_secret
+
+    @property
+    def api_key_id(self):
+        """
+        An identifier for the secret API key. The api_key_id can be
+        retrieved from the Configuration Center. This identifier is visible in
+        the HTTP request and is also used to identify the correct account.
+
+        This property is an alias for authorization_id
+        """
+        return self.authorization_id
+
+    @api_key_id.setter
+    def api_key_id(self, api_key_id):
+        self.authorization_id = api_key_id
+
+    @property
+    def secret_api_key(self):
+        """
+        A shared secret. The shared secret can be retrieved from the
+        Configuration Center. An api_key_id and secret_api_key always go
+        hand-in-hand, the difference is that secret_api_key is never visible in
+        the HTTP request. This secret is used as input for the HMAC algorithm.
+
+        This property is an alias for authorization_secret
+        """
+        return self.authorization_secret
+
+    @secret_api_key.setter
+    def secret_api_key(self, secret_api_key):
+        self.authorization_secret = secret_api_key
+
+    @property
+    def authorization_type(self):
+        return self.__authorization_type
+
+    @authorization_type.setter
+    def authorization_type(self, authorization_type):
+        self.__authorization_type = authorization_type
+
+    @property
+    def connect_timeout(self):
+        """Connection timeout for the underlying network communication in seconds"""
+        return self.__connect_timeout
+
+    @connect_timeout.setter
+    def connect_timeout(self, connect_timeout):
+        self.__connect_timeout = connect_timeout
+
+    @property
+    def socket_timeout(self):
+        """Socket timeout for the underlying network communication in seconds"""
+        return self.__socket_timeout
+
+    @socket_timeout.setter
+    def socket_timeout(self, socket_timeout):
+        self.__socket_timeout = socket_timeout
+
+    @property
+    def max_connections(self):
+        return self.__max_connections
+
+    @max_connections.setter
+    def max_connections(self, max_connections):
+        self.__max_connections = max_connections
+
+    @property
+    def proxy_configuration(self):
+        return self.__proxy_configuration
+
+    @proxy_configuration.setter
+    def proxy_configuration(self, proxy_configuration):
+        self.__proxy_configuration = proxy_configuration
+
+    @property
+    def integrator(self):
+        return self.__integrator
+
+    @integrator.setter
+    def integrator(self, integrator):
+        self.__integrator = integrator
+
+    @property
+    def shopping_cart_extension(self):
+        return self.__shopping_cart_extension
+
+    @shopping_cart_extension.setter
+    def shopping_cart_extension(self, shopping_cart_extension):
+        self.__shopping_cart_extension = shopping_cart_extension

connect-sdk-python2-4.0.1/worldline/connect/sdk/domain/shopping_cart_extension.py

@@ -0,0 +1,75 @@
+from data_object import DataObject
+
+
+class ShoppingCartExtension(DataObject):
+    def __init__(self, creator, name, version, extension_id=None):
+        if not creator:
+            raise ValueError("creator is required")
+        if not name:
+            raise ValueError("name is required")
+        if not version:
+            raise ValueError("version is required")
+        self.__creator = creator
+        self.__name = name
+        self.__version = version
+        self.__extension_id = extension_id
+
+    def to_dictionary(self):
+        dictionary = super(ShoppingCartExtension, self).to_dictionary()
+        if self.__creator is not None:
+            dictionary['creator'] = self.__creator
+        if self.__name is not None:
+            dictionary['name'] = self.__name
+        if self.__version is not None:
+            dictionary['version'] = self.__version
+        if self.__extension_id is not None:
+            dictionary['extensionId'] = self.__extension_id
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(ShoppingCartExtension, self).from_dictionary(dictionary)
+        if 'creator' in dictionary:
+            self.__creator = dictionary['creator']
+        if 'name' in dictionary:
+            self.__name = dictionary['name']
+        if 'version' in dictionary:
+            self.__version = dictionary['version']
+        if 'extensionId' in dictionary:
+            self.__extension_id = dictionary['extensionId']
+        return self
+
+    @staticmethod
+    def create_from_dictionary(dictionary):
+        if 'creator' in dictionary:
+            creator = dictionary['creator']
+        else:
+            raise ValueError("creator is required")
+        if 'name' in dictionary:
+            name = dictionary['name']
+        else:
+            raise ValueError("name is required")
+        if 'version' in dictionary:
+            version = dictionary['version']
+        else:
+            raise ValueError("version is required")
+        if 'extensionId' in dictionary:
+            extension_id = dictionary['extensionId']
+        else:
+            extension_id = None
+        return ShoppingCartExtension(creator, name, version, extension_id)
+
+    @property
+    def creator(self):
+        return self.__creator
+
+    @property
+    def name(self):
+        return self.__name
+
+    @property
+    def version(self):
+        return self.__version
+
+    @property
+    def extension_id(self):
+        return self.__extension_id

connect-sdk-python2-4.0.1/worldline/connect/sdk/domain/uploadable_file.py

@@ -0,0 +1,48 @@
+class UploadableFile(object):
+    """
+    A file that can be uploaded.
+
+    The allowed forms of content are defined by the Connection implementation.
+    The default implementation supports strings, file descriptors and io.BytesIO objects.
+    """
+
+    def __init__(self, file_name, content, content_type, content_length=-1):
+        if file_name is None or not file_name.strip():
+            raise ValueError("file_name is required")
+        if content is None:
+            raise ValueError("content is required")
+        if content_type is None or not content_type.strip():
+            raise ValueError("file_name is required")
+
+        self.__file_name = file_name
+        self.__content = content
+        self.__content_type = content_type
+        self.__content_length = max(content_length, -1)
+
+    @property
+    def file_name(self):
+        """
+        :return: The name of the file.
+        """
+        return self.__file_name
+
+    @property
+    def content(self):
+        """
+        :return: The file's content.
+        """
+        return self.__content
+
+    @property
+    def content_type(self):
+        """
+        :return: The file's content type.
+        """
+        return self.__content_type
+
+    @property
+    def content_length(self):
+        """
+        :return: The file's content length, or -1 if not known.
+        """
+        return self.__content_length

connect-sdk-python2-4.0.1/worldline/connect/sdk/factory.py

@@ -0,0 +1,121 @@
+from ConfigParser import ConfigParser
+
+from client import Client
+from communicator import Communicator
+from communicator_configuration import CommunicatorConfiguration
+
+from worldline.connect.sdk.authentication.authorization_type import AuthorizationType
+from worldline.connect.sdk.authentication.v1hmac_authenticator import V1HMACAuthenticator
+from worldline.connect.sdk.communication.default_connection import DefaultConnection
+from worldline.connect.sdk.communication.metadata_provider import MetadataProvider
+from worldline.connect.sdk.json.default_marshaller import DefaultMarshaller
+
+
+class Factory(object):
+    """
+    Worldline Global Collect platform factory for several SDK components.
+    """
+
+    @staticmethod
+    def create_configuration(configuration_file_name, authorization_id, authorization_secret):
+        """
+        Creates a CommunicatorConfiguration based on the configuration values in configuration_file_name, authorization_id and authorization_secret.
+        """
+        try:
+            parser = ConfigParser()
+            parser.read(configuration_file_name)
+            with open(configuration_file_name) as f:
+                parser.readfp(f)
+            return CommunicatorConfiguration(properties=parser,
+                                             authorization_id=authorization_id,
+                                             authorization_secret=authorization_secret)
+        except IOError as e:
+            raise RuntimeError("Unable to read configuration located at {}".format(e.filename), e)
+
+    @staticmethod
+    def create_communicator_from_configuration(communicator_configuration,
+                                               metadata_provider=None,
+                                               connection=None,
+                                               authenticator=None,
+                                               marshaller=None):
+        """
+        Creates a Communicator based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        if metadata_provider is None:
+            metadata_provider = MetadataProvider(integrator=communicator_configuration.integrator,
+                                                 shopping_cart_extension=communicator_configuration.shopping_cart_extension)
+        if connection is None:
+            connection = DefaultConnection(communicator_configuration.connect_timeout,
+                                           communicator_configuration.socket_timeout,
+                                           communicator_configuration.max_connections,
+                                           communicator_configuration.proxy_configuration)
+        if authenticator is None:
+            authenticator = Factory.__get_authenticator(communicator_configuration)
+        if marshaller is None:
+            marshaller = DefaultMarshaller.instance()
+        return Communicator(api_endpoint=communicator_configuration.api_endpoint,
+                            metadata_provider=metadata_provider,
+                            connection=connection,
+                            authenticator=authenticator,
+                            marshaller=marshaller)
+
+    @staticmethod
+    def __get_authenticator(communicator_configuration):
+        if communicator_configuration.authorization_type == AuthorizationType.V1HMAC:
+            return V1HMACAuthenticator(communicator_configuration.api_key_id, communicator_configuration.secret_api_key)
+        raise RuntimeError("Unknown authorizationType " + communicator_configuration.authorization_type)
+
+    @staticmethod
+    def create_communicator_from_file(configuration_file_name, authorization_id, authorization_secret,
+                                      metadata_provider=None,
+                                      connection=None,
+                                      authenticator=None,
+                                      marshaller=None):
+        """
+        Creates a Communicator based on the configuration values in configuration_file_name, api_id_key and authorization_secret.
+        """
+        configuration = Factory.create_configuration(configuration_file_name, authorization_id, authorization_secret)
+        return Factory.create_communicator_from_configuration(configuration,
+                                                              metadata_provider=metadata_provider,
+                                                              connection=connection,
+                                                              authenticator=authenticator,
+                                                              marshaller=marshaller)
+
+    @staticmethod
+    def create_client_from_configuration(communicator_configuration,
+                                         metadata_provider=None,
+                                         connection=None,
+                                         authenticator=None,
+                                         marshaller=None):
+        """
+        Create a Client based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        communicator = Factory.create_communicator_from_configuration(communicator_configuration,
+                                                                      metadata_provider=metadata_provider,
+                                                                      connection=connection,
+                                                                      authenticator=authenticator,
+                                                                      marshaller=marshaller)
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_communicator(communicator):
+        """
+        Create a Client based on the settings stored in the Communicator argument
+        """
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_file(configuration_file_name, authorization_id, authorization_secret,
+                                metadata_provider=None,
+                                connection=None,
+                                authenticator=None,
+                                marshaller=None):
+        """
+        Creates a Client based on the configuration values in configuration_file_name, authorization_id and authorization_secret.
+        """
+        communicator = Factory.create_communicator_from_file(configuration_file_name, authorization_id, authorization_secret,
+                                                             metadata_provider=metadata_provider,
+                                                             connection=connection,
+                                                             authenticator=authenticator,
+                                                             marshaller=marshaller)
+        return Client(communicator)

connect-sdk-python2-4.0.1/worldline/connect/sdk/json/default_marshaller.py

@@ -0,0 +1,59 @@
+from json import dumps, loads
+
+from marshaller import Marshaller
+from marshaller_syntax_exception import MarshallerSyntaxException
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class DefaultMarshaller(Marshaller):
+    """
+    Marshaller implementation based on json.
+    """
+
+    @staticmethod
+    def instance():
+        return _DEFAULT_MARSHALLER_INSTANCE
+
+    def marshal(self, request_object):
+        if isinstance(request_object, DataObject):
+            dictionary = request_object.to_dictionary()
+            return dumps(dictionary,
+                         default=lambda o: o.to_dictionary(),
+                         indent=4)
+        else:
+            return dumps(request_object,
+                         default=lambda o: o.__dict__,
+                         indent=4)
+
+    def unmarshal(self, response_json, type_class):
+        if not response_json:
+            return None
+        if issubclass(type_class, DataObject):
+            try:
+                return type_class().from_dictionary(loads(response_json))
+            except ValueError as e:
+                raise MarshallerSyntaxException(e)
+
+        class Object(object):
+            pass
+
+        def convert_to_object(d):
+            try:
+                d = dict(d)
+            except (TypeError, ValueError):
+                return d
+            o = Object()
+            for key, value in d.iteritems():
+                o.__dict__[key] = convert_to_object(value)
+            return o
+
+        try:
+            dictionary = loads(response_json)
+            converted_object = convert_to_object(dictionary)
+            return converted_object
+        except ValueError as e:
+            raise MarshallerSyntaxException(e)
+
+
+_DEFAULT_MARSHALLER_INSTANCE = DefaultMarshaller()

connect-sdk-python2-4.0.1/worldline/connect/sdk/json/marshaller.py

@@ -0,0 +1,29 @@
+from abc import ABCMeta, abstractmethod
+
+
+class Marshaller(object):
+    """
+    Used to marshal and unmarshal Worldline Global Collect platform request and response objects to and from JSON.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def marshal(self, request_object):
+        """
+        Marshal a request object to a JSON string.
+
+        :param request_object: the object to marshal into a serialized JSON string
+        :return: the serialized JSON string of the request_object
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def unmarshal(self, response_json, type_class):
+        """
+        Unmarshal a JSON string to a response object.
+
+        :param response_json: the json body that should be unmarshalled
+        :param type_class: The class to which the response_json should be unmarshalled
+        :raise MarshallerSyntaxException: if the JSON is not a valid representation for an object of the given type
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/json/marshaller_syntax_exception.py

@@ -0,0 +1,10 @@
+class MarshallerSyntaxException(RuntimeError):
+    """
+    Thrown when a JSON string cannot be converted to a response object.
+    """
+
+    def __init__(self, cause=None):
+        if cause:
+            super(MarshallerSyntaxException, self).__init__(cause)
+        else:
+            super(MarshallerSyntaxException, self).__init__()