onlinepayments-sdk-python3 7.4.1__py3-none-any.whl

onlinepayments/sdk/idempotence_exception.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_exception import ApiException
+
+from onlinepayments.sdk.domain.api_error import APIError
+
+
+class IdempotenceException(ApiException):
+    """
+    Represents an error response from the payment platform when an idempotent request failed because the first request has not finished yet.
+    """
+
+    def __init__(self, idempotence_key: str, idempotence_request_timestamp: int,
+                 status_code: int, response_body: str, error_id: Optional[str], errors: Optional[List[APIError]],
+                 message: str = "the payment platform returned a duplicate request error response"):
+        super(IdempotenceException, self).__init__(status_code, response_body, error_id, errors, message)
+        self.__idempotence_key = idempotence_key
+        self.__idempotence_request_timestamp = idempotence_request_timestamp
+
+    @property
+    def idempotence_key(self) -> str:
+        """
+        :return: The key that was used for the idempotent request.
+        """
+        return self.__idempotence_key
+
+    @property
+    def idempotence_request_timestamp(self) -> int:
+        """
+        :return: The request timestamp of the first idempotent request with the same key.
+        """
+        return self.__idempotence_request_timestamp

onlinepayments/sdk/json/default_marshaller.py

@@ -0,0 +1,60 @@
+from json import dumps, loads
+from typing import Any, Type, Union
+
+from .marshaller import Marshaller, T
+from .marshaller_syntax_exception import MarshallerSyntaxException
+
+from onlinepayments.sdk.domain.data_object import DataObject
+
+
+class DefaultMarshaller(Marshaller):
+    """
+    Marshaller implementation based on json.
+    """
+
+    @staticmethod
+    def instance() -> 'DefaultMarshaller':
+        return _DEFAULT_MARSHALLER_INSTANCE
+
+    def marshal(self, request_object: Any) -> str:
+        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: Union[str, bytes, None], type_class: Type[T]) -> T:
+        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) from 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.items():
+                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) from e
+
+
+_DEFAULT_MARSHALLER_INSTANCE = DefaultMarshaller()

onlinepayments/sdk/json/marshaller.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Type, TypeVar, Union
+
+
+T = TypeVar('T')
+
+
+class Marshaller(ABC):
+    """
+    Used to marshal and unmarshal Online Payments platform request and response objects to and from JSON.
+    """
+
+    @abstractmethod
+    def marshal(self, request_object: Any) -> str:
+        """
+        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: Union[str, bytes, None], type_class: Type[T]) -> Optional[T]:
+        """
+        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

onlinepayments/sdk/json/marshaller_syntax_exception.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+
+class MarshallerSyntaxException(RuntimeError):
+    """
+    Thrown when a JSON string cannot be converted to a response object.
+    """
+
+    def __init__(self, cause: Optional[Exception] = None):
+        if cause:
+            super(MarshallerSyntaxException, self).__init__(cause)
+        else:
+            super(MarshallerSyntaxException, self).__init__()

onlinepayments/sdk/log/body_obfuscator.py

@@ -0,0 +1,113 @@
+import codecs
+import re
+
+from typing import AnyStr, Dict, Mapping, Optional, Pattern, Sequence, Union
+
+from .obfuscation_rule import ObfuscationRule, 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: Dict[str, ObfuscationRule] = None
+    __property_pattern: Pattern[AnyStr] = None
+
+    def __init__(self, additional_rules: Optional[Mapping[str, ObfuscationRule]] = 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 = {
+            "additionalInfo": obfuscate_all(),
+            "cardholderName": obfuscate_all(),
+            "dateOfBirth": obfuscate_all(),
+            "emailAddress": obfuscate_all(),
+            "faxNumber": obfuscate_all(),
+            "firstName": obfuscate_all(),
+            "houseNumber": obfuscate_all(),
+            "mobilePhoneNumber": obfuscate_all(),
+            "passengerName": obfuscate_all(),
+            "phoneNumber": obfuscate_all(),
+            "street": obfuscate_all(),
+            "workPhoneNumber": obfuscate_all(),
+            "zip": obfuscate_all(),
+            "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.items():
+                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: Sequence[str]) -> Pattern[AnyStr]:
+        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: str, value: str) -> str:
+        obfuscation_rule = self.__obfuscation_rules.get(property_name)
+        if obfuscation_rule:
+            return obfuscation_rule(value)
+        return value
+
+    def obfuscate_body(self, body: Union[str, bytes, None], charset: Optional[str] = None) -> Optional[str]:
+        """
+        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() -> 'BodyObfuscator':
+        return _DEFAULT_BODY_OBFUSCATOR
+
+
+_DEFAULT_BODY_OBFUSCATOR = BodyObfuscator()

onlinepayments/sdk/log/communicator_logger.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from .request_log_message import RequestLogMessage
+from .response_log_message import ResponseLogMessage
+
+
+class CommunicatorLogger(ABC):
+    """
+    Used to log messages from communicators.
+    """
+
+    def log_request(self, request_log_message: RequestLogMessage) -> None:
+        """
+        Logs a request message object
+
+        """
+        self.log(request_log_message.get_message())
+
+    def log_response(self, response_log_message: ResponseLogMessage) -> None:
+        """
+        Logs a response message object
+
+        """
+        self.log(response_log_message.get_message())
+
+    @abstractmethod
+    def log(self, message: str, thrown: Optional[Exception] = None) -> None:
+        """
+        Logs a throwable with an accompanying message.
+
+        :param message: The message accompanying the throwable.
+        :param thrown: The throwable to log.
+        """
+        raise NotImplementedError

onlinepayments/sdk/log/header_obfuscator.py

@@ -0,0 +1,49 @@
+from typing import Dict, Mapping, Optional
+
+from .obfuscation_rule import ObfuscationRule, obfuscate_with_fixed_length
+
+
+class HeaderObfuscator(object):
+    """
+    A class that can be used to obfuscate headers.
+    """
+
+    __obfuscation_rules: Dict[str, ObfuscationRule] = None
+
+    def __init__(self, additional_rules: Optional[Mapping[str, ObfuscationRule]] = 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 = {
+            "X-GCS-Authentication-Token": obfuscate_with_fixed_length(8),
+            "X-GCS-CallerPassword": obfuscate_with_fixed_length(8),
+            "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),
+        }
+        if additional_rules:
+            for name, rule in additional_rules.items():
+                name = name.lower()
+                self.__obfuscation_rules[name] = rule
+
+    def obfuscate_header(self, header_name: str, value: str) -> str:
+        """
+        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() -> 'HeaderObfuscator':
+        return _DEFAULT_HEADER_OBFUSCATOR
+
+
+_DEFAULT_HEADER_OBFUSCATOR = HeaderObfuscator()

onlinepayments/sdk/log/log_message.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional, Sequence, Tuple, Union
+
+from .body_obfuscator import BodyObfuscator
+from .header_obfuscator import HeaderObfuscator
+
+
+class LogMessage(ABC):
+    """
+    A utility class to build log messages.
+    """
+    __request_id: str = None
+    __headers: str = None
+    __body: Optional[str] = None
+    __content_type: Optional[str] = None
+    __header_list: List[Tuple[str, str]] = None
+    __body_obfuscator: BodyObfuscator = None
+    __header_obfuscator: HeaderObfuscator = None
+
+    def __init__(self, request_id: str,
+                 body_obfuscator: BodyObfuscator = BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator: HeaderObfuscator = 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) -> str:
+        return self.__request_id
+
+    @property
+    def headers(self) -> str:
+        return str(self.__headers)
+
+    @property
+    def body(self) -> Optional[str]:
+        return self.__body
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.__content_type
+
+    def add_header(self, name: str, value: Optional[str]) -> None:
+        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: Union[str, bytes, None], content_type: Optional[str], charset: Optional[str] = None) -> 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: Optional[str]) -> None:
+        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: Optional[str]) -> bool:
+        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: Optional[str]) -> str:
+        if value is not None:
+            return value
+        return ""
+
+    @abstractmethod
+    def get_message(self) -> str:
+        raise NotImplementedError
+
+    def get_header_list(self) -> Sequence[Tuple[str, str]]:
+        return self.__header_list

onlinepayments/sdk/log/logging_capable.py

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

onlinepayments/sdk/log/obfuscation_capable.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+
+from .body_obfuscator import BodyObfuscator
+from .header_obfuscator import HeaderObfuscator
+
+
+class ObfuscationCapable(ABC):
+    """
+    Classes that extend this class support obfuscating bodies and headers.
+    """
+
+    @abstractmethod
+    def set_body_obfuscator(self, body_obfuscator: BodyObfuscator) -> None:
+        """
+        Sets the current body obfuscator to use.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
+        """
+        Sets the current header obfuscator to use.
+        """
+        raise NotImplementedError

onlinepayments/sdk/log/obfuscation_rule.py

@@ -0,0 +1,50 @@
+from typing import Callable
+
+
+ObfuscationRule = Callable[[str], str]
+
+
+def obfuscate_all() -> ObfuscationRule:
+    """
+    Returns an obfuscation rule (function) that will replace all characters with *
+    """
+    return lambda value: '*' * len(value) if value else value
+
+
+def obfuscate_with_fixed_length(fixed_length: int) -> ObfuscationRule:
+    """
+    Returns an obfuscation rule (function) that will replace values with a fixed length string containing only *
+    """
+    return lambda value: '*' * fixed_length
+
+
+def obfuscate_all_but_first(count: int) -> ObfuscationRule:
+    """
+    Returns an obfuscation rule (function) that will keep a fixed number of characters at the start,
+    then replaces all other characters with *
+    """
+    def obfuscate_value(value: str) -> str:
+        if not value:
+            return value
+        length = len(value)
+        if length < count:
+            return value
+        end = '*' * (length - count)
+        return value[:count] + end
+    return obfuscate_value
+
+
+def obfuscate_all_but_last(count: int) -> ObfuscationRule:
+    """
+    Returns an obfuscation rule that will keep a fixed number of characters at the end,
+    then replaces all other characters with *
+    """
+    def obfuscate_value(value: str) -> str:
+        if not value:
+            return value
+        length = len(value)
+        if length < count:
+            return value
+        start = '*' * (length - count)
+        return start + value[-count:]
+    return obfuscate_value

onlinepayments/sdk/log/python_communicator_logger.py

@@ -0,0 +1,54 @@
+from logging import Logger
+from typing import Optional
+
+from .communicator_logger import CommunicatorLogger
+
+
+class PythonCommunicatorLogger(CommunicatorLogger):
+    """
+    A communicator logger that is backed by the log library.
+    """
+
+    def __init__(self, logger: Logger, log_level: int, error_log_level: Optional[int] = 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: str, thrown: Optional[Exception] = None) -> 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)

onlinepayments/sdk/log/request_log_message.py

@@ -0,0 +1,28 @@
+from .body_obfuscator import BodyObfuscator
+from .header_obfuscator import HeaderObfuscator
+from .log_message import LogMessage
+
+
+class RequestLogMessage(LogMessage):
+    """
+    A utility class to build request log messages.
+    """
+
+    def __init__(self, request_id: str, method: str, uri: str,
+                 body_obfuscator: BodyObfuscator = BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator: HeaderObfuscator = HeaderObfuscator.default_header_obfuscator()):
+        super(RequestLogMessage, self).__init__(request_id, body_obfuscator, header_obfuscator)
+        self.method = method
+        self.uri = uri
+
+    def get_message(self) -> str:
+        string = "Outgoing request (requestId='" + str(self.request_id) + "'):\n" + \
+                 "  method:       " + self.empty_if_none("'" + self.method + "'") + "\n" + \
+                 "  uri:          " + self.empty_if_none("'" + self.uri + "'") + "\n" + \
+                 "  headers:      " + self.headers
+        body = self.body
+        if body is None:
+            return string
+        else:
+            return string + "\n  content-type: '" + self.empty_if_none(self.content_type) + "'\n" + \
+                   "  body:         '" + body + "'"

onlinepayments/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: str, status_code: int, duration: int = -1,
+                 body_obfuscator: BodyObfuscator = BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator: HeaderObfuscator = 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) -> int:
+        return self.__duration
+
+    def get_status_code(self) -> int:
+        return self.__status_code
+
+    def get_message(self) -> str:
+        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)