onlinepayments-sdk-python3 4.22.0__zip → 5.0.0__zip

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/domain/three_ds_whitelist.py

@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated.
-#
-from onlinepayments.sdk.data_object import DataObject
-
-
-class ThreeDSWhitelist(DataObject):
-    __source = None
-    __status = None
-
-    @property
-    def source(self) -> str:
-        """
-        | Whitelist Status Source. This data element will be populated by the system setting Whitelist Status
-
-        Type: str
-        """
-        return self.__source
-
-    @source.setter
-    def source(self, value: str):
-        self.__source = value
-
-    @property
-    def status(self) -> str:
-        """
-        | Whitelist Status. Enables the communication of trusted beneficiary/whitelist status between the ACS, the DS and the 3DS Requestor.
-
-        Type: str
-        """
-        return self.__status
-
-    @status.setter
-    def status(self, value: str):
-        self.__status = value
-
-    def to_dictionary(self):
-        dictionary = super(ThreeDSWhitelist, self).to_dictionary()
-        if self.source is not None:
-            dictionary['source'] = self.source
-        if self.status is not None:
-            dictionary['status'] = self.status
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ThreeDSWhitelist, self).from_dictionary(dictionary)
-        if 'source' in dictionary:
-            self.source = dictionary['source']
-        if 'status' in dictionary:
-            self.status = dictionary['status']
-        return self

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/domain/token_card_data.py

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated.
-#
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.card_without_cvv import CardWithoutCvv
-
-
-class TokenCardData(DataObject):
-    __card_without_cvv = None
-
-    @property
-    def card_without_cvv(self) -> CardWithoutCvv:
-        """
-        Type: :class:`onlinepayments.sdk.domain.card_without_cvv.CardWithoutCvv`
-        """
-        return self.__card_without_cvv
-
-    @card_without_cvv.setter
-    def card_without_cvv(self, value: CardWithoutCvv):
-        self.__card_without_cvv = value
-
-    def to_dictionary(self):
-        dictionary = super(TokenCardData, self).to_dictionary()
-        if self.card_without_cvv is not None:
-            dictionary['cardWithoutCvv'] = self.card_without_cvv.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(TokenCardData, self).from_dictionary(dictionary)
-        if 'cardWithoutCvv' in dictionary:
-            if not isinstance(dictionary['cardWithoutCvv'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardWithoutCvv']))
-            value = CardWithoutCvv()
-            self.card_without_cvv = value.from_dictionary(dictionary['cardWithoutCvv'])
-        return self

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/domain/token_data.py

@@ -1,42 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated.
-#
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.card import Card
-
-
-class TokenData(DataObject):
-    """
-    | Object containing the token details for a card
-    """
-
-    __card = None
-
-    @property
-    def card(self) -> Card:
-        """
-        | Object containing card details
-
-        Type: :class:`onlinepayments.sdk.domain.card.Card`
-        """
-        return self.__card
-
-    @card.setter
-    def card(self, value: Card):
-        self.__card = value
-
-    def to_dictionary(self):
-        dictionary = super(TokenData, self).to_dictionary()
-        if self.card is not None:
-            dictionary['card'] = self.card.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(TokenData, self).from_dictionary(dictionary)
-        if 'card' in dictionary:
-            if not isinstance(dictionary['card'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
-            value = Card()
-            self.card = value.from_dictionary(dictionary['card'])
-        return self

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/domain/web_hooks_event.py

@@ -1,145 +0,0 @@
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.payment_response import PaymentResponse
-from onlinepayments.sdk.domain.payout_response import PayoutResponse
-from onlinepayments.sdk.domain.refund_response import RefundResponse
-from onlinepayments.sdk.domain.token_response import TokenResponse
-
-
-class WebhooksEvent(DataObject):
-    __api_version = None
-    __id = None
-    __created = None
-    __merchant_id = None
-    __type = None
-    __payment = None
-    __payout = None
-    __refund = None
-    __token = None
-
-    @property
-    def api_version(self) -> str:
-        return self.__api_version
-
-    @api_version.setter
-    def api_version(self, api_version: str):
-        self.__api_version = api_version
-
-    @property
-    def id(self) -> str:
-        return self.__id
-
-    @id.setter
-    def id(self, id: str):
-        self.__id = id
-
-    @property
-    def created(self) -> str:
-        return self.__created
-
-    @created.setter
-    def created(self, created: str):
-        self.__created = created
-
-    @property
-    def merchant_id(self) -> str:
-        return self.__merchant_id
-
-    @merchant_id.setter
-    def merchant_id(self, merchant_id: str):
-        self.__merchant_id = merchant_id
-
-    @property
-    def type(self) -> str:
-        return self.__type
-
-    @type.setter
-    def type(self, type: str):
-        self.__type = type
-
-    @property
-    def payment(self) -> PaymentResponse:
-        return self.__payment
-
-    @payment.setter
-    def payment(self, payment: PaymentResponse):
-        self.__payment = payment
-
-    @property
-    def payout(self) -> PayoutResponse:
-        return self.__payout
-
-    @payout.setter
-    def payout(self, payout: PayoutResponse):
-        self.__payout = payout
-
-    @property
-    def refund(self) -> RefundResponse:
-        return self.__refund
-
-    @refund.setter
-    def refund(self, refund: RefundResponse):
-        self.__refund = refund
-
-    @property
-    def token(self) -> TokenResponse:
-        return self.__token
-
-    @token.setter
-    def token(self, token: TokenResponse):
-        self.__token = token
-
-    def to_dictionary(self):
-        dictionary = super(WebhooksEvent, self).to_dictionary()
-        if self.__api_version is not None:
-            dictionary['apiVersion'] = self.__api_version
-        if self.__id is not None:
-            dictionary['id'] = self.__id
-        if self.__created is not None:
-            dictionary['created'] = self.__created
-        if self.__merchant_id is not None:
-            dictionary['merchantId'] = self.__merchant_id
-        if self.__type is not None:
-            dictionary['type'] = self.__type
-        if self.__payment is not None:
-            dictionary['payment'] = self.__payment
-        if self.__payout is not None:
-            dictionary['payout'] = self.__payout
-        if self.__refund is not None:
-            dictionary['refund'] = self.__refund
-        if self.__token is not None:
-            dictionary['token'] = self.__token
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(WebhooksEvent, self).from_dictionary(dictionary)
-        if 'apiVersion' in dictionary:
-            self.__api_version = dictionary['apiVersion']
-        if 'id' in dictionary:
-            self.__id = dictionary['id']
-        if 'created' in dictionary:
-            self.__created = dictionary['created']
-        if 'merchantId' in dictionary:
-            self.__merchant_id = dictionary['merchantId']
-        if 'type' in dictionary:
-            self.__type = dictionary['type']
-        if 'payment' in dictionary:
-            if not isinstance(dictionary['payment'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
-            value = PaymentResponse()
-            self.__payment = value.from_dictionary(dictionary['payment'])
-        if 'payout' in dictionary:
-            if not isinstance(dictionary['payout'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payout']))
-            value = PayoutResponse()
-            self.__payout = value.from_dictionary(dictionary['payout'])
-        if 'refund' in dictionary:
-            if not isinstance(dictionary['refund'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refund']))
-            value = RefundResponse()
-            self.__refund = value.from_dictionary(dictionary['refund'])
-        if 'token' in dictionary:
-            if not isinstance(dictionary['token'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['token']))
-            value = TokenResponse()
-            self.__token = value.from_dictionary(dictionary['token'])
-        return self

onlinepayments-sdk-python3-4.22.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.22.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.22.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.22.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.22.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