connect-sdk-python2 3.47.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/body_obfuscator.py

@@ -0,0 +1,98 @@
+import codecs
+import re
+
+from obfuscation_rule import obfuscate_all, obfuscate_with_fixed_length, obfuscate_all_but_first, obfuscate_all_but_last
+
+
+class BodyObfuscator(object):
+    """
+    A class that can be used to obfuscate properties in JSON bodies.
+    """
+
+    __obfuscation_rules = None
+    __property_pattern = None
+
+    def __init__(self, additional_rules=None):
+        """
+        Creates a new  body obfuscator.
+        This will contain some pre-defined obfuscation rules, as well as any provided custom rules
+
+        :param additional_rules: An optional mapping from property names to obfuscation rules,
+         where an obfuscation rule is a function that obfuscates a single string,
+        """
+        self.__obfuscation_rules = {
+            "cardNumber": obfuscate_all_but_last(4),
+            "expiryDate": obfuscate_all_but_last(2),
+            "cvv": obfuscate_all(),
+            "iban": obfuscate_all_but_last(4),
+            "accountNumber": obfuscate_all_but_last(4),
+            "reformattedAccountNumber": obfuscate_all_but_last(4),
+            "bin": obfuscate_all_but_first(6),
+            "value": obfuscate_all(),
+            "keyId": obfuscate_with_fixed_length(8),
+            "secretKey": obfuscate_with_fixed_length(8),
+            "publicKey": obfuscate_with_fixed_length(8),
+            "userAuthenticationToken": obfuscate_with_fixed_length(8),
+            "encryptedPayload": obfuscate_with_fixed_length(8),
+            "decryptedPayload": obfuscate_with_fixed_length(8),
+            "encryptedCustomerInput": obfuscate_with_fixed_length(8),
+        }
+        if additional_rules:
+            for name, rule in additional_rules.iteritems():
+                self.__obfuscation_rules[name] = rule
+
+        property_names = tuple(self.__obfuscation_rules.keys())
+        self.__property_pattern = self.__build_property_pattern(property_names)
+
+    @staticmethod
+    def __build_property_pattern(property_names):
+        if not property_names:
+            return re.compile("$^")
+        s = "([\"'])("
+        for p in property_names:
+            s += '|' + re.escape(p)
+        s += ")\\1\\s*:\\s*(?:([\"'])(.*?)(?<!\\\\)\\3|([^\"'\\s\\[\\{]((?!,)\\S)*))"
+        return re.compile(s, re.DOTALL)
+
+    def __obfuscate_value(self, property_name, value):
+        obfuscation_rule = self.__obfuscation_rules.get(property_name)
+        if obfuscation_rule:
+            return obfuscation_rule(value)
+        return value
+
+    def obfuscate_body(self, body, charset=None):
+        """
+        Obfuscates the body from the given stream as necessary.
+        :param body: The body to obfuscate, as string or bytes.
+        :param charset: The charset to use to read the body bytes.
+        """
+        if charset:
+            body = codecs.decode(body, charset)
+
+        if body is None:
+            return None
+        if not body:
+            return ""
+        index = 0
+        s_obfuscate = ""
+        matcher = self.__property_pattern.finditer(body)
+        for x in matcher:
+            property_name = x.group(2)
+            value = x.group(4)
+            value_start = x.start(4)
+            value_end = x.end(4)
+            if not value:
+                value = x.group(5)
+                value_start = x.start(5)
+                value_end = x.end(5)
+            obfuscated_value = self.__obfuscate_value(property_name, value)
+            s_obfuscate += body[index:value_start] + obfuscated_value
+            index = value_end
+        return s_obfuscate + body[index:]
+
+    @staticmethod
+    def default_body_obfuscator():
+        return _DEFAULT_BODY_OBFUSCATOR
+
+
+_DEFAULT_BODY_OBFUSCATOR = BodyObfuscator()

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/communicator_logger.py

@@ -0,0 +1,32 @@
+from abc import ABCMeta, abstractmethod
+
+
+class CommunicatorLogger(object):
+    """
+    Used to log messages from communicators.
+    """
+    __metaclass__ = ABCMeta
+
+    def log_request(self, request_log_message):
+        """
+        Logs a request message object
+
+        """
+        self.log(request_log_message.get_message())
+
+    def log_response(self, response_log_message):
+        """
+        Logs a response message object
+
+        """
+        self.log(response_log_message.get_message())
+
+    @abstractmethod
+    def log(self, message, thrown=None):
+        """
+        Logs a throwable with an accompanying message.
+
+        :param message: The message accompanying the throwable.
+        :param thrown: The throwable to log.
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/header_obfuscator.py

@@ -0,0 +1,47 @@
+from obfuscation_rule import obfuscate_with_fixed_length
+
+
+class HeaderObfuscator(object):
+    """
+    A class that can be used to obfuscate headers.
+    """
+
+    __obfuscation_rules = None
+
+    def __init__(self, additional_rules=None):
+        """
+        Creates a new  header obfuscator.
+        This will contain some pre-defined obfuscation rules, as well as any provided custom rules
+
+        :param additional_rules: An optional mapping from property names to obfuscation rules,
+         where an obfuscation rule is a function that obfuscates a single string,
+        """
+        self.__obfuscation_rules = {
+            "authorization": obfuscate_with_fixed_length(8),
+            "www-authenticate": obfuscate_with_fixed_length(8),
+            "proxy-authenticate": obfuscate_with_fixed_length(8),
+            "proxy-authorization": obfuscate_with_fixed_length(8),
+            "x-gcs-authentication-token": obfuscate_with_fixed_length(8),
+            "x-gcs-callerpassword": obfuscate_with_fixed_length(8),
+        }
+        if additional_rules:
+            for name, rule in additional_rules.iteritems():
+                name = name.lower()
+                self.__obfuscation_rules[name] = rule
+
+    def obfuscate_header(self, header_name, value):
+        """
+        Obfuscates the value for the given header as necessary.
+        """
+        header_name = header_name.lower()
+        obfuscation_rule = self.__obfuscation_rules.get(header_name)
+        if obfuscation_rule:
+            return obfuscation_rule(value)
+        return value
+
+    @staticmethod
+    def default_header_obfuscator():
+        return _DEFAULT_HEADER_OBFUSCATOR
+
+
+_DEFAULT_HEADER_OBFUSCATOR = HeaderObfuscator()

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/log_message.py

@@ -0,0 +1,95 @@
+from abc import ABCMeta, abstractmethod
+
+from body_obfuscator import BodyObfuscator
+from header_obfuscator import HeaderObfuscator
+
+
+class LogMessage(object):
+    """
+    A utility class to build log messages.
+    """
+    __metaclass__ = ABCMeta
+
+    __request_id = None
+    __headers = None
+    __body = None
+    __content_type = None
+    __header_list = None
+    __body_obfuscator = None
+    __header_obfuscator = None
+
+    def __init__(self, request_id,
+                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
+        if not request_id:
+            raise ValueError("request_id is required")
+        if not body_obfuscator:
+            raise ValueError("body_obfuscator is required")
+        if not header_obfuscator:
+            raise ValueError("header_obfuscator is required")
+        self.__request_id = request_id
+        self.__headers = ""
+        self.__header_list = []
+        self.__body_obfuscator = body_obfuscator
+        self.__header_obfuscator = header_obfuscator
+
+    @property
+    def request_id(self):
+        return self.__request_id
+
+    @property
+    def headers(self):
+        return str(self.__headers)
+
+    @property
+    def body(self):
+        return self.__body
+
+    @property
+    def content_type(self):
+        return self.__content_type
+
+    def add_header(self, name, value):
+        if self.__headers:
+            self.__headers += ", "
+        self.__headers += name + "=\""
+        if value is not None and value.lower() != 'none':
+            obfuscated_value = self.__header_obfuscator.obfuscate_header(name, value)
+            self.__headers += obfuscated_value
+            self.__header_list.append((name, "\"" + obfuscated_value + "\""))
+        else:
+            self.__header_list.append((name, "\"\""))
+        self.__headers += "\""
+
+    def set_body(self, body, content_type, charset=None):
+        self.__content_type = content_type
+        if self.__is_binary(content_type):
+            self.__body = "<binary content>"
+        else:
+            self.__body = self.__body_obfuscator.obfuscate_body(body, charset)
+
+    def set_binary_body(self, content_type):
+        if not self.__is_binary(content_type):
+            raise ValueError("Not a binary content type: " + content_type)
+        self.__content_type = content_type
+        self.__body = "<binary content>"
+
+    @staticmethod
+    def __is_binary(content_type):
+        if content_type is None:
+            return False
+        content_type = content_type.lower()
+        return not (content_type.startswith("text/") or "json" in content_type or "xml" in content_type)
+
+    @staticmethod
+    def empty_if_none(value):
+        if value is not None:
+            return value
+        return ""
+
+    @abstractmethod
+    def get_message(self):
+        raise NotImplementedError
+
+    def get_header_list(self):
+        return self.__header_list

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/logging_capable.py

@@ -0,0 +1,25 @@
+from abc import ABCMeta, abstractmethod
+
+
+class LoggingCapable(object):
+    """
+    Classes that extend this class have support for log messages from
+    communicators.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def enable_logging(self, communicator_logger):
+        """
+        Turns on logging using the given communicator logger.
+
+        :raise ValueError: If the given communicator logger is None.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def disable_logging(self):
+        """
+        Turns off logging.
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/obfuscation_capable.py

@@ -0,0 +1,22 @@
+from abc import ABCMeta, abstractmethod
+
+
+class ObfuscationCapable(object):
+    """
+    Classes that extend this class support obfuscating bodies and headers.
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def set_body_obfuscator(self, body_obfuscator):
+        """
+        Sets the current body obfuscator to use.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_header_obfuscator(self, header_obfuscator):
+        """
+        Sets the current header obfuscator to use.
+        """
+        raise NotImplementedError

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/python_communicator_logger.py

@@ -0,0 +1,51 @@
+from communicator_logger import CommunicatorLogger
+
+
+class PythonCommunicatorLogger(CommunicatorLogger):
+    """
+    A communicator logger that is backed by the log library.
+    """
+
+    def __init__(self, logger, log_level, error_log_level=None):
+        """
+        Logs messages to the argument logger using the argument log_level.
+        If absent, the error_log_level will be equal to the log_level.
+        Note that if the CommunicatorLogger's log level is lower than the
+        argument logger's log level (e.g. the CommunicatorLogger is given
+        log.INFO as level and the argument logger has a level of
+        log.WARNING), then nothing will be logged to the logger.
+
+        :param logger: the logger to log to
+        :param log_level: the log level that will be used for non-error
+         messages logged via the CommunicatorLogger
+        :param error_log_level: the log level that will be used for error
+         messages logged via the CommunicatorLogger.
+        """
+        CommunicatorLogger.__init__(self)
+        if not error_log_level:
+            error_log_level = log_level
+        if logger is None:
+            raise ValueError("logger is required")
+        if log_level is None:
+            raise ValueError("log_level is required")
+        if error_log_level is None:
+            raise ValueError("error_log_level is required")
+        self.__logger = logger
+        self.__log_level = log_level
+        self.__error_log_level = error_log_level
+
+    def log(self, message, thrown=None):
+        """
+        Log a message to the underlying logger.
+        If thrown is absent, the message will be logged with the
+        CommunicatorLogger's log_level, if a thrown object is provided,
+        the message and exception will be logged with the CommunicatorLogger's
+        error_log_level.
+
+        :param message: the message to be logged
+        :param thrown: an optional throwable object
+        """
+        if not thrown:
+            self.__logger.log(self.__log_level, message)
+        else:
+            self.__logger.log(self.__error_log_level, message, thrown)

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/response_log_message.py

@@ -0,0 +1,37 @@
+from body_obfuscator import BodyObfuscator
+from header_obfuscator import HeaderObfuscator
+from log_message import LogMessage
+
+
+class ResponseLogMessage(LogMessage):
+    """
+    A utility class to build request log messages.
+    """
+
+    def __init__(self, request_id, status_code, duration=-1,
+                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
+        super(ResponseLogMessage, self).__init__(request_id, body_obfuscator, header_obfuscator)
+        self.__status_code = status_code
+        self.__duration = duration
+
+    def get_duration(self):
+        return self.__duration
+
+    def get_status_code(self):
+        return self.__status_code
+
+    def get_message(self):
+        if self.__duration < 0:
+            return "Incoming response (requestId='" + self.request_id + "'):\n" + \
+                   "  status_code:  " + str(self.__status_code) + "\n" + \
+                   "  headers:      " + self.headers + "\n" + \
+                   "  content-type: " + self.empty_if_none(self.content_type) + "\n" + \
+                   "  body:         " + self.empty_if_none(self.body)
+
+        else:
+            return "Incoming response (requestId='" + self.request_id + "', " + str(self.__duration) + " ms):\n" + \
+                   "  status_code:  " + str(self.__status_code) + "\n" + \
+                   "  headers:      " + self.headers + "\n" + \
+                   "  content-type: " + self.empty_if_none(self.content_type) + "\n" + \
+                   "  body:         " + self.empty_if_none(self.body).encode('utf-8', errors='backslashreplace')

connect-sdk-python2-4.0.1/worldline/connect/sdk/log/sys_out_communicator_logger.py

@@ -0,0 +1,37 @@
+from __future__ import print_function
+
+from datetime import datetime
+from threading import Lock
+
+from communicator_logger import CommunicatorLogger
+
+
+class SysOutCommunicatorLogger(CommunicatorLogger):
+    """
+    A communicator logger that prints its message to sys.stdout
+    It includes a timestamp in yyyy-MM-ddTHH:mm:ss format in the system time zone.
+    """
+
+    _global_lock = Lock()
+    _old_print = print
+
+    @staticmethod
+    def instance():
+        return _SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE
+
+    def __print(self, *a):
+        with self._global_lock:
+            self._old_print(*a)
+
+    def log(self, message, thrown=None):
+        # Make sure the same object is used for locking and printing
+        self.__print(self.__get_date_prefix() + message)
+        if thrown:
+            self.__print(str(thrown))
+
+    @staticmethod
+    def __get_date_prefix():
+        return datetime.now().strftime("%Y-%m-%dT%H:%M:%S ")
+
+
+_SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE = SysOutCommunicatorLogger()

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

@@ -0,0 +1,101 @@
+from urlparse import urlparse
+
+
+class ProxyConfiguration(object):
+    """
+    HTTP proxy configuration.
+
+    Can be initialised directly from a host and port or can be constructed from a uri using fromuri
+    """
+
+    def __init__(self, host, port, scheme="http", username=None, password=None):
+        if not host:
+            raise ValueError("host is required")
+        if not port:
+            raise ValueError("port is required")
+        if port <= 0 or port > 65535:
+            raise ValueError("""port "{}" is invalid""".format(port))
+        self.__scheme = scheme
+        self.__host = host
+        self.__port = port
+        self.__username = username
+        self.__password = password
+
+    @staticmethod
+    def from_uri(uri, username=None, password=None):
+        """
+        Constructs a ProxyConfiguration from a URI; if username and/or password
+        are given they will be used instead of corresponding data in the URI
+        """
+        parsed = urlparse(uri)
+        scheme = parsed.scheme
+        host = parsed.hostname + parsed.path
+        port = parsed.port
+        if username is None:
+            username = parsed.username
+        if password is None:
+            password = parsed.password
+        if port is None:
+            if scheme == "http":
+                port = 80
+            elif scheme == "https":
+                port = 443
+            else:
+                raise ValueError("unsupported scheme: " + scheme)
+        return ProxyConfiguration(scheme=scheme,
+                                  host=host,
+                                  port=port,
+                                  username=username,
+                                  password=password)
+
+    @property
+    def scheme(self):
+        return self.__scheme
+
+    @scheme.setter
+    def scheme(self, scheme):
+        self.__scheme = scheme
+
+    @property
+    def host(self):
+        return self.__host
+
+    @host.setter
+    def host(self, host):
+        self.__host = host
+
+    @property
+    def port(self):
+        return self.__port
+
+    @port.setter
+    def port(self, port):
+        self.__port = port
+
+    @property
+    def username(self):
+        return self.__username
+
+    @username.setter
+    def username(self, username):
+        self.__username = username
+
+    @property
+    def password(self):
+        return self.__password
+
+    @password.setter
+    def password(self, password):
+        self.__password = password
+
+    def __str__(self):
+        """
+        Return a proxy string in the form scheme://username:password@host:port
+        or scheme://host:port if authentication is absent
+
+        Supports HTTP Basic Auth
+        """
+        if self.username is None or self.password is None:
+            return r"{0}://{1}:{2}".format(self.scheme, self.host, self.port)
+        else:
+            return r"{0}://{3}:{4}@{1}:{2}".format(self.scheme, self.host, self.port, self.username, self.password)

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/__init__.py

@@ -0,0 +1,4 @@
+#
+# This file was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com
+#

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/api_exception.py

@@ -0,0 +1,55 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+class ApiException(RuntimeError):
+    """
+    Represents an error response from the Worldline Global Collect platform which contains an ID and a list of errors.
+    """
+
+    def __init__(self, status_code, response_body, error_id, errors,
+                 message="the Worldline Global Collect platform returned an error response"):
+        super(ApiException, self).__init__(message)
+        self.__status_code = status_code
+        self.__response_body = response_body
+        self.__error_id = error_id
+        if errors is None:
+            self.__errors = ()
+        else:
+            self.__errors = errors
+
+    @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 response_body(self):
+        """
+        :return: The raw response body that was returned by the Worldline Global Collect platform.
+        """
+        return self.__response_body
+
+    @property
+    def error_id(self):
+        """
+        :return: The errorId received from the Worldline Global Collect platform if available.
+        """
+        return self.__error_id
+
+    @property
+    def errors(self):
+        """
+        :return: The errors received from the Worldline Global Collect platform if available. Never None.
+        """
+        return self.__errors
+
+    def __str__(self):
+        string = super(ApiException, self).__str__()
+        if self.__status_code > 0:
+            string += "; status_code=" + str(self.__status_code)
+        if self.__response_body:
+            string += "; response_body='" + self.__response_body + "'"
+        return str(string)

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/authorization_exception.py

@@ -0,0 +1,15 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from api_exception import ApiException
+
+
+class AuthorizationException(ApiException):
+    """
+    Represents an error response from the Worldline Global Collect platform when authorization failed.
+    """
+
+    def __init__(self, status_code, response_body, error_id, errors,
+                 message="the Worldline Global Collect platform returned an authorization error response"):
+        super(AuthorizationException, self).__init__(status_code, response_body, error_id, errors, message)

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/declined_payment_exception.py

@@ -0,0 +1,41 @@
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from declined_transaction_exception import DeclinedTransactionException
+
+
+class DeclinedPaymentException(DeclinedTransactionException):
+    """
+    Represents an error response from a create payment call.
+    """
+
+    def __init__(self, status_code, response_body, response):
+        if response is not None:
+            super(DeclinedPaymentException, self).__init__(status_code, response_body, response.error_id, response.errors,
+                                                           DeclinedPaymentException.__create_message(response))
+        else:
+            super(DeclinedPaymentException, self).__init__(status_code, response_body, None, None,
+                                                           DeclinedPaymentException.__create_message(response))
+        self.__response = response
+
+    @staticmethod
+    def __create_message(response):
+        if response is not None and response.payment_result is not None:
+            payment = response.payment_result.payment
+        else:
+            payment = None
+        if payment is not None:
+            return "declined payment '%s' with status '%s'" % (payment.id, payment.status)
+        else:
+            return "the Worldline Global Collect platform returned a declined payment response"
+
+    @property
+    def create_payment_result(self):
+        """
+        :return: The result of creating a payment if available, otherwise None.
+        """
+        if self.__response is None:
+            return None
+        else:
+            return self.__response.payment_result