onlinepayments-sdk-python3 4.23.0__zip → 5.1.0__zip

onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/endpoint_configuration.py

@@ -1,126 +0,0 @@
-from typing import Union
-from urllib.parse import ParseResult, ParseResultBytes, urlparse
-
-from onlinepayments.sdk.domain.shopping_cart_extension import ShoppingCartExtension
-from onlinepayments.sdk.proxy_configuration import ProxyConfiguration
-
-
-class EndpointConfiguration:
-    """
-    Base class for endpoint configurations.
-    """
-    # The default number of maximum connections.
-    DEFAULT_CONNECT_TIMEOUT = 5
-    DEFAULT_SOCKET_TIMEOUT = 300
-    DEFAULT_MAX_CONNECTIONS = 10
-
-    def __init__(self, properties=None, prefix=None):
-        if properties and properties.sections() and properties.options("OnlinePaymentsSDK"):
-            self.__endpoint = self.__get_endpoint(properties, prefix)
-            self.__connect_timeout = int(properties.get("OnlinePaymentsSDK", prefix + ".connectTimeout", fallback=self.DEFAULT_CONNECT_TIMEOUT))
-            self.__socket_timeout = int(properties.get("OnlinePaymentsSDK", prefix + ".socketTimeout", fallback=self.DEFAULT_SOCKET_TIMEOUT))
-            self.__max_connections = int(properties.get("OnlinePaymentsSDK", prefix + ".maxConnections", fallback=self.DEFAULT_MAX_CONNECTIONS))
-            proxy_uri = properties.get("OnlinePaymentsSDK", prefix + ".proxy.uri", fallback=None)
-            if proxy_uri is None:
-                self.__proxy_configuration = None
-            else:
-                self.__proxy_configuration = ProxyConfiguration.from_uri(
-                    proxy_uri,
-                    properties.get("OnlinePaymentsSDK", prefix + ".proxy.username", fallback=None),
-                    properties.get("OnlinePaymentsSDK", prefix + ".proxy.password", fallback=None))
-            self.__integrator = properties.get("OnlinePaymentsSDK", prefix + ".integrator", fallback=None)
-            self.__shopping_cart_extension = self.__get_shopping_cart_extension(properties, prefix)
-
-    def __get_endpoint(self, properties, prefix):
-        host = properties.get("OnlinePaymentsSDK", prefix + ".endpoint.host")
-        scheme = properties.get("OnlinePaymentsSDK", prefix + ".endpoint.scheme", fallback="https")
-        port = int(properties.get("OnlinePaymentsSDK", prefix + ".endpoint.port", fallback=-1))
-        return self.__create_uri(scheme, host, port)
-
-    @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, prefix):
-        creator = properties.get("OnlinePaymentsSDK", prefix + ".shoppingCartExtension.creator", fallback=None)
-        name = properties.get("OnlinePaymentsSDK", prefix + ".shoppingCartExtension.name", fallback=None)
-        version = properties.get("OnlinePaymentsSDK", prefix + ".shoppingCartExtension.version", fallback=None)
-        extension_id = properties.get("OnlinePaymentsSDK", prefix + ".shoppingCartExtension.extensionId", fallback=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 _endpoint(self) -> Union[ParseResult, ParseResultBytes]:
-        return self.__endpoint
-
-    def _set_endpoint(self, endpoint: Union[str, ParseResult, ParseResultBytes]):
-        if isinstance(endpoint, str):
-            endpoint = urlparse(str(endpoint))
-        if endpoint is not None and endpoint.path:
-            raise ValueError("apiEndpoint should not contain a path")
-        if endpoint is not None and (
-                endpoint.username is not None or
-                endpoint.query or endpoint.fragment):
-            raise ValueError(
-                "apiEndpoint should not contain user info, query or fragment")
-        self.__endpoint = endpoint
-
-    @property
-    def connect_timeout(self) -> int:
-        """Connection timeout for the underlying network communication in seconds"""
-        return self.__connect_timeout
-
-    @connect_timeout.setter
-    def connect_timeout(self, connect_timeout: int):
-        self.__connect_timeout = connect_timeout
-
-    @property
-    def socket_timeout(self) -> int:
-        """Socket timeout for the underlying network communication in seconds"""
-        return self.__socket_timeout
-
-    @socket_timeout.setter
-    def socket_timeout(self, socket_timeout: int):
-        self.__socket_timeout = socket_timeout
-
-    @property
-    def max_connections(self) -> int:
-        return self.__max_connections
-
-    @max_connections.setter
-    def max_connections(self, max_connections: int):
-        self.__max_connections = max_connections
-
-    @property
-    def proxy_configuration(self) -> ProxyConfiguration:
-        return self.__proxy_configuration
-
-    @proxy_configuration.setter
-    def proxy_configuration(self, proxy_configuration: ProxyConfiguration):
-        self.__proxy_configuration = proxy_configuration
-
-    @property
-    def integrator(self) -> str:
-        return self.__integrator
-
-    @integrator.setter
-    def integrator(self, integrator: str):
-        self.__integrator = integrator
-
-    @property
-    def shopping_cart_extension(self) -> ShoppingCartExtension:
-        return self.__shopping_cart_extension
-
-    @shopping_cart_extension.setter
-    def shopping_cart_extension(self, shopping_cart_extension: ShoppingCartExtension):
-        self.__shopping_cart_extension = shopping_cart_extension

onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/factory.py

@@ -1,117 +0,0 @@
-from configparser import ConfigParser
-
-from onlinepayments.sdk.client import Client
-from onlinepayments.sdk.communicator import Communicator
-from onlinepayments.sdk.communicator_configuration import CommunicatorConfiguration
-from onlinepayments.sdk.defaultimpl.default_authenticator import DefaultAuthenticator
-from onlinepayments.sdk.defaultimpl.default_connection import DefaultConnection
-from onlinepayments.sdk.defaultimpl.default_marshaller import DefaultMarshaller
-from onlinepayments.sdk.i_client import IClient
-from onlinepayments.sdk.meta_data_provider import MetaDataProvider
-
-
-class Factory:
-    """
-    Online Payments platform factory for several SDK components.
-    """
-
-    @staticmethod
-    def create_configuration(configuration_file_name, api_key_id, secret_api_key) -> CommunicatorConfiguration:
-        """
-        Creates a CommunicatorConfiguration based on the configuration
-        values in configuration_file_name, api_key_id and secret_api_key.
-        """
-        parser = ConfigParser()
-        try:
-            parser.read(configuration_file_name)
-            with open(configuration_file_name) as f:
-                parser.read_file(f)
-            return CommunicatorConfiguration(
-                properties=parser,
-                api_key_id=api_key_id,
-                secret_api_key=secret_api_key)
-        except IOError as e:
-            raise RuntimeError("Unable to read configuration located at {}".format(e.filename), e)
-
-    @staticmethod
-    def create_communicator_from_configuration(communicator_configuration,
-                                               meta_data_provider=None,
-                                               connection=None,
-                                               authenticator=None,
-                                               marshaller=DefaultMarshaller.INSTANCE()) -> Communicator:
-        """
-        Creates a Communicator based on the configuration stored in the CommunicatorConfiguration argument
-        """
-        # If an authenticator is not given, api_key_id and secret_api_key are
-        # used to create a DefaultAuthenticator used to create the communicator.
-        if connection is None:
-            connection = DefaultConnection(
-                connect_timeout=communicator_configuration.connect_timeout,
-                socket_timeout=communicator_configuration.socket_timeout,
-                max_connections=communicator_configuration.max_connections,
-                proxy_configuration=communicator_configuration.proxy_configuration)
-        if authenticator is None:
-            authenticator = DefaultAuthenticator(
-                api_key_id=communicator_configuration.api_key_id,
-                secret_api_key=communicator_configuration.secret_api_key,
-                authorization_type=communicator_configuration.authorization_type)
-        if meta_data_provider is None:
-            meta_data_provider = MetaDataProvider(
-                integrator=communicator_configuration.integrator,
-                shopping_cart_extension=communicator_configuration.shopping_cart_extension)
-        return Communicator(
-            api_endpoint=communicator_configuration.api_endpoint,
-            authenticator=authenticator,
-            connection=connection,
-            meta_data_provider=meta_data_provider,
-            marshaller=marshaller)
-
-    @staticmethod
-    def create_communicator_from_file(configuration_file_name,
-                                      api_key_id,
-                                      secret_api_key,
-                                      meta_data_provider=None,
-                                      connection=None,
-                                      authenticator=None,
-                                      marshaller=DefaultMarshaller.INSTANCE()) -> Communicator:
-        """
-        Creates a Communicator based on the configuration values in configuration_file_name, api_id_key and secret_api_key.
-        """
-        configuration = Factory.create_configuration(configuration_file_name, api_key_id, secret_api_key)
-        return Factory.create_communicator_from_configuration(configuration, meta_data_provider, connection, authenticator, marshaller)
-
-    @staticmethod
-    def create_client_from_configuration(communicator_configuration) -> IClient:
-        """
-        Create a Client based on the configuration stored in the CommunicatorConfiguration argument
-        """
-        communicator = Factory.create_communicator_from_configuration(communicator_configuration)
-        return Client(communicator)
-
-    @staticmethod
-    def create_client_from_communicator(communicator) -> IClient:
-        """
-        Create a Client based on the settings stored in the Communicator argument
-        """
-        return Client(communicator)
-
-    @staticmethod
-    def create_client_from_file(configuration_file_name,
-                                api_key_id,
-                                secret_api_key,
-                                meta_data_provider=None,
-                                connection=None,
-                                authenticator=None,
-                                marshaller=DefaultMarshaller.INSTANCE()) -> IClient:
-        """
-        Creates a Client based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
-        """
-        communicator = Factory.create_communicator_from_file(
-            configuration_file_name,
-            api_key_id,
-            secret_api_key,
-            meta_data_provider,
-            connection,
-            authenticator,
-            marshaller)
-        return Client(communicator)

onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/i_client.py

@@ -1,67 +0,0 @@
-#
-# This class was auto-generated.
-#
-from abc import abstractmethod
-
-from onlinepayments.sdk.log.logging_capable import LoggingCapable
-from onlinepayments.sdk.merchant.merchant_client import MerchantClient
-
-
-class IClient(LoggingCapable):
-    """
-    Payment platform client interface.
-
-    This client interface and all its child client interfaces are bound to one specific value for the X-GCS-ClientMetaInfo header.
-    To get a new client with a different header value, use with_client_meta_info.
-
-    Thread-safe.
-    """
-
-    @staticmethod
-    def API_VERSION():
-        return "v2"
-
-    @abstractmethod
-    def with_client_meta_info(self, client_meta_info):
-        """
-        :param client_meta_info: JSON string containing the meta data for the client
-        :return: a new Client which uses the passed meta data for the X-GCS-ClientMetaInfo header.
-        :raise: MarshallerSyntaxException if the given clientMetaInfo is not a valid JSON string
-        """
-
-    @abstractmethod
-    def close_idle_connections(self, idle_time):
-        """
-        Utility method that delegates the call to this client's communicator.
-
-        :param idle_time: a datetime.timedelta object indicating the idle time
-        """
-
-    @abstractmethod
-    def close_expired_connections(self):
-        """
-        Utility method that delegates the call to this client's communicator.
-        """
-
-    @abstractmethod
-    def enable_logging(self, communicator_logger):
-        """"""
-
-    @abstractmethod
-    def disable_logging(self):
-        """"""
-
-    @abstractmethod
-    def close(self):
-        """
-        Releases any system resources associated with this object.
-        """
-
-    @abstractmethod
-    def merchant(self, merchant_id: str) -> MerchantClient:
-        """
-        Resource /v2/{merchantId}
-
-        :param merchant_id: str
-        :return: :class:`onlinepayments.sdk.merchant.i_merchant_client.IMerchantClient`
-        """

onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/idempotence_exception.py

@@ -1,29 +0,0 @@
-from onlinepayments.sdk.api_exception import ApiException
-
-
-class IdempotenceException(ApiException):
-    """
-    Represents an error response from the Online Payments platform when an
-    idempotent request failed because the first request has not finished yet.
-    """
-
-    def __init__(self, idempotence_key, idempotence_request_timestamp, status_code, response_body, error_id, errors,
-                 message="the Online Payments 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):
-        """
-        :return: The key that was used for the idempotent request.
-        """
-        return self.__idempotence_key
-
-    @property
-    def idempotence_request_timestamp(self):
-        """
-        :return: The request timestamp of the first idempotent request with the
-         same key.
-        """
-        return self.__idempotence_request_timestamp

onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/log/log_message.py

@@ -1,70 +0,0 @@
-from abc import ABC, abstractmethod
-
-from onlinepayments.sdk.log.logging_util import LoggingUtil
-
-
-class LogMessage(ABC):
-    """
-    A utility class to build log messages.
-    """
-    __request_id = None
-    __headers = None
-    __body = None
-    __content_type = None
-    __header_list = None
-
-    def __init__(self, request_id):
-        if not request_id:
-            raise ValueError("request_id is required")
-        self.__request_id = request_id
-        self.__headers = ""
-        self.__header_list = []
-
-    @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':
-            value = str(value)
-            obfuscated_value = LoggingUtil.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 charset is not None:
-            self.__body = LoggingUtil.obfuscate_body(body, charset)
-        else:
-            self.__body = LoggingUtil.obfuscate_body(body)
-
-    @staticmethod
-    def empty_if_none(value):
-        if value is not None:
-            return value
-        return ""
-
-    @abstractmethod
-    def get_message(self):
-        """"""
-
-    def get_header_list(self):
-        return self.__header_list

onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/log/logging_util.py

@@ -1,144 +0,0 @@
-import codecs
-import re
-
-from typing import List
-
-
-class LoggingUtil:
-    """
-    A utility class to support logging.
-    """
-
-    class Obfuscator:
-
-        __obfuscators = None
-        __obfuscator_keys = None
-
-        def __init__(self, case_insensitive, values: List[str] = None, sensitive_values: List[str] = None):
-            obfuscators = {}
-            self.case_insensitive = case_insensitive
-            if values:
-                obfuscator = self.ValueObfuscator()
-                for value in values:
-                    obfuscators[value] = obfuscator
-            if sensitive_values:
-                value_obfuscator = self.SensitiveValueObfuscator()
-                for value in sensitive_values:
-                    obfuscators[value] = value_obfuscator
-            self.__obfuscators = tuple(obfuscators.items())
-            self.__obfuscator_keys = tuple(obfuscators)
-
-        def obfuscate_value(self, key, value):
-            obfuscator = self.find_obfuscator(key)
-            if obfuscator is not None:
-                return obfuscator.obfuscate_value(value)
-            return value
-
-        def find_obfuscator(self, key):
-            for item in self.__obfuscators:
-                x, y = item
-                if self.case_insensitive:
-                    if x.lower() == key.lower():
-                        return y
-                else:
-                    if x == key:
-                        return y
-            return None
-
-        class ValueObfuscator:
-            def obfuscate_value(self, value):
-                return '*' + str(len(value)) if value else value
-
-        class SensitiveValueObfuscator:
-            def obfuscate_value(self, value):
-                return '***' if value else value
-
-        def build_property_pattern(self, 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(self, body):
-            if body is None:
-                return None
-            if not body:
-                return ""
-            index = 0
-            s_obfuscate = ""
-            pattern = self.build_property_pattern(self.__obfuscator_keys)
-            matcher = 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:]
-
-    __properties = ["accountNumber",
-                    "additionalInfo",
-                    "bin",
-                    "cardNumber",
-                    "cardholderName",
-                    "cvv",
-                    "dateOfBirth",
-                    "emailAddress",
-                    "expiryDate",
-                    "faxNumber",
-                    "firstName",
-                    "houseNumber",
-                    "iban",
-                    "mobilePhoneNumber",
-                    "passengerName",
-                    "phoneNumber",
-                    "reformattedAccountNumber",
-                    "street",
-                    "surname",
-                    "value",
-                    "workPhoneNumber",
-                    "zip"]
-    __sensitive_properties = ["decryptedPayload",
-                              "encryptedCustomerInput",
-                              "encryptedPayload",
-                              "keyId",
-                              "publicKey",
-                              "secretKey",
-                              "userAuthenticationToken"]
-    __property_obfuscator = Obfuscator(False, __properties, __sensitive_properties)
-
-    __sensitive_headers = ["Authorization",
-                           "Proxy-Authenticate",
-                           "Proxy-Authorization",
-                           "X-GCS-Authentication-Token",
-                           "WWW-Authenticate",
-                           "X-GCS-CallerPassword"]
-    __header_obfuscator = Obfuscator(True, sensitive_values=__sensitive_headers)
-
-    @staticmethod
-    def obfuscate_body(body, charset=None):
-        """
-        Obfuscates the body from the given stream as necessary.
-        :param body: The body stream to obfuscate
-        :param charset: The charset to use to read the body input stream.
-        """
-        if charset is None:
-            return LoggingUtil.__property_obfuscator.obfuscate(body)
-        else:  # possible dead code
-            return LoggingUtil.obfuscate_body(codecs.decode(body, charset))
-
-    @staticmethod
-    def obfuscate_header(name, value):
-        """
-        Obfuscates the value for the given header as necessary.
-        """
-        return LoggingUtil.__header_obfuscator.obfuscate_value(name, value)

onlinepayments-sdk-python3-4.23.0/onlinepayments/sdk/log/request_log_message.py

@@ -1,24 +0,0 @@
-from onlinepayments.sdk.log.log_message import LogMessage
-
-
-class RequestLogMessage(LogMessage):
-    """
-    A utility class to build request log messages.
-    """
-
-    def __init__(self, request_id, method, uri):
-        super(RequestLogMessage, self).__init__(request_id)
-        self.method = method
-        self.uri = uri
-
-    def get_message(self):
-        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 + "'"