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

onlinepayments/sdk/communicator_configuration.py

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

onlinepayments/sdk/declined_payment_exception.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .declined_transaction_exception import DeclinedTransactionException
+
+from onlinepayments.sdk.domain.create_payment_response import CreatePaymentResponse
+from onlinepayments.sdk.domain.payment_error_response import PaymentErrorResponse
+
+
+class DeclinedPaymentException(DeclinedTransactionException):
+    """
+    Represents an error response from a create payment call.
+    """
+
+    def __init__(self, status_code: int, response_body: str, response: Optional[PaymentErrorResponse]):
+        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: Optional[PaymentErrorResponse]) -> str:
+        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 payment platform returned a declined payment response"
+
+    @property
+    def create_payment_response(self) -> Optional[CreatePaymentResponse]:
+        """
+        :return: The result of creating a payment if available, otherwise None.
+        """
+        if self.__response is None:
+            return None
+        else:
+            return self.__response.payment_result

onlinepayments/sdk/declined_payout_exception.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .declined_transaction_exception import DeclinedTransactionException
+
+from onlinepayments.sdk.domain.payout_error_response import PayoutErrorResponse
+from onlinepayments.sdk.domain.payout_result import PayoutResult
+
+
+class DeclinedPayoutException(DeclinedTransactionException):
+    """
+    Represents an error response from a payout call.
+    """
+
+    def __init__(self, status_code: int, response_body: str, response: Optional[PayoutErrorResponse]):
+        if response is not None:
+            super(DeclinedPayoutException, self).__init__(status_code, response_body, response.error_id, response.errors,
+                                                          DeclinedPayoutException.__create_message(response))
+        else:
+            super(DeclinedPayoutException, self).__init__(status_code, response_body, None, None,
+                                                          DeclinedPayoutException.__create_message(response))
+        self.__response = response
+
+    @staticmethod
+    def __create_message(response: Optional[PayoutErrorResponse]) -> str:
+        if response is not None:
+            payout_result = response.payout_result
+        else:
+            payout_result = None
+        if payout_result is not None:
+            return "declined payout '%s' with status '%s'" % (payout_result.id, payout_result.status)
+        else:
+            return "the payment platform returned a declined payout response"
+
+    @property
+    def payout_result(self) -> Optional[PayoutResult]:
+        """
+        :return: The result of creating a payout if available, otherwise None.
+        """
+        if self.__response is None:
+            return None
+        else:
+            return self.__response.payout_result

onlinepayments/sdk/declined_refund_exception.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .declined_transaction_exception import DeclinedTransactionException
+
+from onlinepayments.sdk.domain.refund_error_response import RefundErrorResponse
+from onlinepayments.sdk.domain.refund_response import RefundResponse
+
+
+class DeclinedRefundException(DeclinedTransactionException):
+    """
+    Represents an error response from a refund call.
+    """
+
+    def __init__(self, status_code: int, response_body: str, response: Optional[RefundErrorResponse]):
+        if response is not None:
+            super(DeclinedRefundException, self).__init__(status_code, response_body, response.error_id, response.errors,
+                                                          DeclinedRefundException.__create_message(response))
+        else:
+            super(DeclinedRefundException, self).__init__(status_code, response_body, None, None,
+                                                          DeclinedRefundException.__create_message(response))
+        self.__response = response
+
+    @staticmethod
+    def __create_message(response: Optional[RefundErrorResponse]) -> str:
+        if response is not None:
+            refund_result = response.refund_result
+        else:
+            refund_result = None
+        if refund_result is not None:
+            return "declined refund '%s' with status '%s'" % (refund_result.id, refund_result.status)
+        else:
+            return "the payment platform returned a declined refund response"
+
+    @property
+    def refund_response(self) -> Optional[RefundResponse]:
+        """
+        :return: The result of creating a refund if available, otherwise None.
+        """
+        if self.__response is None:
+            return None
+        else:
+            return self.__response.refund_result

onlinepayments/sdk/declined_transaction_exception.py

@@ -0,0 +1,22 @@
+# -*- 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 DeclinedTransactionException(ApiException):
+    """
+    Represents an error response from a create payment, payout or refund call.
+    """
+
+    def __init__(self, status_code: int, response_body: str, error_id: Optional[str], errors: Optional[List[APIError]],
+                 message: Optional[str] = None):
+        if message:
+            super(DeclinedTransactionException, self).__init__(status_code, response_body, error_id, errors, message)
+        else:
+            super(DeclinedTransactionException, self).__init__(status_code, response_body, error_id, errors)

onlinepayments/sdk/domain/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#

onlinepayments/sdk/domain/acceptance.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import datetime
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class Acceptance(DataObject):
+
+    __acceptance_system_application_id: Optional[str] = None
+    __authorization_date: Optional[datetime] = None
+
+    @property
+    def acceptance_system_application_id(self) -> Optional[str]:
+        """
+        | Worldline application identifier used to transmit the authorization request. This data is transmitted as provided in the authorization request and in the response. It is named ITP (Terminal Application Identification at the Point of Acceptance) in the CB2A protocol.
+
+        Type: str
+        """
+        return self.__acceptance_system_application_id
+
+    @acceptance_system_application_id.setter
+    def acceptance_system_application_id(self, value: Optional[str]) -> None:
+        self.__acceptance_system_application_id = value
+
+    @property
+    def authorization_date(self) -> Optional[datetime]:
+        """
+        | It is the authorization processing date and time of the transaction.
+
+        Type: datetime
+        """
+        return self.__authorization_date
+
+    @authorization_date.setter
+    def authorization_date(self, value: Optional[datetime]) -> None:
+        self.__authorization_date = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Acceptance, self).to_dictionary()
+        if self.acceptance_system_application_id is not None:
+            dictionary['acceptanceSystemApplicationId'] = self.acceptance_system_application_id
+        if self.authorization_date is not None:
+            dictionary['authorizationDate'] = DataObject.format_datetime(self.authorization_date)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Acceptance':
+        super(Acceptance, self).from_dictionary(dictionary)
+        if 'acceptanceSystemApplicationId' in dictionary:
+            self.acceptance_system_application_id = dictionary['acceptanceSystemApplicationId']
+        if 'authorizationDate' in dictionary:
+            self.authorization_date = DataObject.parse_datetime(dictionary['authorizationDate'])
+        return self

onlinepayments/sdk/domain/account_on_file.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .account_on_file_attribute import AccountOnFileAttribute
+from .account_on_file_display_hints import AccountOnFileDisplayHints
+from .data_object import DataObject
+
+
+class AccountOnFile(DataObject):
+
+    __attributes: Optional[List[AccountOnFileAttribute]] = None
+    __display_hints: Optional[AccountOnFileDisplayHints] = None
+    __id: Optional[str] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def attributes(self) -> Optional[List[AccountOnFileAttribute]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.account_on_file_attribute.AccountOnFileAttribute`]
+        """
+        return self.__attributes
+
+    @attributes.setter
+    def attributes(self, value: Optional[List[AccountOnFileAttribute]]) -> None:
+        self.__attributes = value
+
+    @property
+    def display_hints(self) -> Optional[AccountOnFileDisplayHints]:
+        """
+        | Object containing information for the client on how best to display this field
+
+        Type: :class:`onlinepayments.sdk.domain.account_on_file_display_hints.AccountOnFileDisplayHints`
+        """
+        return self.__display_hints
+
+    @display_hints.setter
+    def display_hints(self, value: Optional[AccountOnFileDisplayHints]) -> None:
+        self.__display_hints = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | ID of the token
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AccountOnFile, self).to_dictionary()
+        if self.attributes is not None:
+            dictionary['attributes'] = []
+            for element in self.attributes:
+                if element is not None:
+                    dictionary['attributes'].append(element.to_dictionary())
+        if self.display_hints is not None:
+            dictionary['displayHints'] = self.display_hints.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFile':
+        super(AccountOnFile, self).from_dictionary(dictionary)
+        if 'attributes' in dictionary:
+            if not isinstance(dictionary['attributes'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['attributes']))
+            self.attributes = []
+            for element in dictionary['attributes']:
+                value = AccountOnFileAttribute()
+                self.attributes.append(value.from_dictionary(element))
+        if 'displayHints' in dictionary:
+            if not isinstance(dictionary['displayHints'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
+            value = AccountOnFileDisplayHints()
+            self.display_hints = value.from_dictionary(dictionary['displayHints'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self