onlinepayments-sdk-python3 4.23.0__zip → 5.0.0__zip

onlinepayments_sdk_python3-5.0.0/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_python3-5.0.0/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_python3-5.0.0/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_python3-5.0.0/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_python3-5.0.0/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_python3-5.0.0/onlinepayments/sdk/domain/__init__.py

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

{onlinepayments-sdk-python3-4.23.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/account_on_file.py

@@ -1,33 +1,34 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from typing import List
+from typing import List, Optional
 
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.account_on_file_attribute import AccountOnFileAttribute
-from onlinepayments.sdk.domain.account_on_file_display_hints import AccountOnFileDisplayHints
+from .account_on_file_attribute import AccountOnFileAttribute
+from .account_on_file_display_hints import AccountOnFileDisplayHints
+from .data_object import DataObject
 
 
 class AccountOnFile(DataObject):
-    __attributes = None
-    __display_hints = None
-    __id = None
-    __payment_product_id = None
+
+    __attributes: Optional[List[AccountOnFileAttribute]] = None
+    __display_hints: Optional[AccountOnFileDisplayHints] = None
+    __id: Optional[int] = None
+    __payment_product_id: Optional[int] = None
 
     @property
-    def attributes(self) -> List[AccountOnFileAttribute]:
+    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: List[AccountOnFileAttribute]):
+    def attributes(self, value: Optional[List[AccountOnFileAttribute]]) -> None:
         self.__attributes = value
 
     @property
-    def display_hints(self) -> AccountOnFileDisplayHints:
+    def display_hints(self) -> Optional[AccountOnFileDisplayHints]:
         """
         | Object containing information for the client on how best to display this field
 
@@ -36,22 +37,22 @@ class AccountOnFile(DataObject):
         return self.__display_hints
 
     @display_hints.setter
-    def display_hints(self, value: AccountOnFileDisplayHints):
+    def display_hints(self, value: Optional[AccountOnFileDisplayHints]) -> None:
         self.__display_hints = value
 
     @property
-    def id(self) -> int:
+    def id(self) -> Optional[int]:
         """
         Type: int
         """
         return self.__id
 
     @id.setter
-    def id(self, value: int):
+    def id(self, value: Optional[int]) -> None:
         self.__id = value
 
     @property
-    def payment_product_id(self) -> int:
+    def payment_product_id(self) -> Optional[int]:
         """
         | Payment product identifier - Please see Products documentation for a full overview of possible values.
 
@@ -60,10 +61,10 @@ class AccountOnFile(DataObject):
         return self.__payment_product_id
 
     @payment_product_id.setter
-    def payment_product_id(self, value: int):
+    def payment_product_id(self, value: Optional[int]) -> None:
         self.__payment_product_id = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(AccountOnFile, self).to_dictionary()
         if self.attributes is not None:
             dictionary['attributes'] = []
@@ -78,7 +79,7 @@ class AccountOnFile(DataObject):
             dictionary['paymentProductId'] = self.payment_product_id
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFile':
         super(AccountOnFile, self).from_dictionary(dictionary)
         if 'attributes' in dictionary:
             if not isinstance(dictionary['attributes'], list):

{onlinepayments-sdk-python3-4.23.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/account_on_file_attribute.py

@@ -1,22 +1,21 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
+from typing import Optional
+
+from .data_object import DataObject
 
 
 class AccountOnFileAttribute(DataObject):
-    """
-    | Array containing the details of the stored token
-    """
 
-    __key = None
-    __must_write_reason = None
-    __status = None
-    __value = None
+    __key: Optional[str] = None
+    __must_write_reason: Optional[str] = None
+    __status: Optional[str] = None
+    __value: Optional[str] = None
 
     @property
-    def key(self) -> str:
+    def key(self) -> Optional[str]:
         """
         | Name of the key or property
 
@@ -25,42 +24,43 @@ class AccountOnFileAttribute(DataObject):
         return self.__key
 
     @key.setter
-    def key(self, value: str):
+    def key(self, value: Optional[str]) -> None:
         self.__key = value
 
     @property
-    def must_write_reason(self) -> str:
+    def must_write_reason(self) -> Optional[str]:
         """
-        | Deprecated: This field is not used by any payment product
-        | The reason why the status is MUST_WRITE. Currently only "IN_THE_PAST" is possible as value (for expiry date), but this can be extended with new values in the future.
+        | Deprecated: This field is not used by any payment product The reason why the status is MUST_WRITE. Currently only "IN_THE_PAST" is possible as value (for expiry date), but this can be extended with new values in the future.
 
         Type: str
+
+        Deprecated; Deprecated
         """
         return self.__must_write_reason
 
     @must_write_reason.setter
-    def must_write_reason(self, value: str):
+    def must_write_reason(self, value: Optional[str]) -> None:
         self.__must_write_reason = value
 
     @property
-    def status(self) -> str:
+    def status(self) -> Optional[str]:
         """
         | Possible values:
-        | * READ_ONLY - attribute cannot be updated and should be presented in that way to the user
-        | * CAN_WRITE - attribute can be updated and should be presented as an editable field, for example an expiration date that will expire very soon
-        | * MUST_WRITE - attribute should be updated and must be presented as an editable field, for example an expiration date that has already expired
-        | Any updated values that are entered for CAN_WRITE or MUST_WRITE will be used to update the values stored in the token.
+        
+        * READ_ONLY - attribute cannot be updated and should be presented in that way to the user
+        * CAN_WRITE - attribute can be updated and should be presented as an editable field, for example an expiration date that will expire very soon
+        * MUST_WRITE - attribute should be updated and must be presented as an editable field, for example an expiration date that has already expired Any updated values that are entered for CAN_WRITE or MUST_WRITE will be used to update the values stored in the token.
 
         Type: str
         """
         return self.__status
 
     @status.setter
-    def status(self, value: str):
+    def status(self, value: Optional[str]) -> None:
         self.__status = value
 
     @property
-    def value(self) -> str:
+    def value(self) -> Optional[str]:
         """
         | Value of the key or property
 
@@ -69,10 +69,10 @@ class AccountOnFileAttribute(DataObject):
         return self.__value
 
     @value.setter
-    def value(self, value: str):
+    def value(self, value: Optional[str]) -> None:
         self.__value = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(AccountOnFileAttribute, self).to_dictionary()
         if self.key is not None:
             dictionary['key'] = self.key
@@ -84,7 +84,7 @@ class AccountOnFileAttribute(DataObject):
             dictionary['value'] = self.value
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFileAttribute':
         super(AccountOnFileAttribute, self).from_dictionary(dictionary)
         if 'key' in dictionary:
             self.key = dictionary['key']