onlinepayments-sdk-python3 4.22.0__zip → 5.0.0__zip

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/token_response.py

@@ -1,23 +1,26 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.external_token_linked import ExternalTokenLinked
-from onlinepayments.sdk.domain.token_card import TokenCard
-from onlinepayments.sdk.domain.token_e_wallet import TokenEWallet
+from typing import Optional
+
+from .data_object import DataObject
+from .external_token_linked import ExternalTokenLinked
+from .token_card import TokenCard
+from .token_e_wallet import TokenEWallet
 
 
 class TokenResponse(DataObject):
-    __card = None
-    __e_wallet = None
-    __external_token_linked = None
-    __id = None
-    __is_temporary = None
-    __payment_product_id = None
+
+    __card: Optional[TokenCard] = None
+    __e_wallet: Optional[TokenEWallet] = None
+    __external_token_linked: Optional[ExternalTokenLinked] = None
+    __id: Optional[str] = None
+    __is_temporary: Optional[bool] = None
+    __payment_product_id: Optional[int] = None
 
     @property
-    def card(self) -> TokenCard:
+    def card(self) -> Optional[TokenCard]:
         """
         | Object containing card details
 
@@ -26,11 +29,11 @@ class TokenResponse(DataObject):
         return self.__card
 
     @card.setter
-    def card(self, value: TokenCard):
+    def card(self, value: Optional[TokenCard]) -> None:
         self.__card = value
 
     @property
-    def e_wallet(self) -> TokenEWallet:
+    def e_wallet(self) -> Optional[TokenEWallet]:
         """
         | Object containing eWallet details
 
@@ -39,22 +42,22 @@ class TokenResponse(DataObject):
         return self.__e_wallet
 
     @e_wallet.setter
-    def e_wallet(self, value: TokenEWallet):
+    def e_wallet(self, value: Optional[TokenEWallet]) -> None:
         self.__e_wallet = value
 
     @property
-    def external_token_linked(self) -> ExternalTokenLinked:
+    def external_token_linked(self) -> Optional[ExternalTokenLinked]:
         """
         Type: :class:`onlinepayments.sdk.domain.external_token_linked.ExternalTokenLinked`
         """
         return self.__external_token_linked
 
     @external_token_linked.setter
-    def external_token_linked(self, value: ExternalTokenLinked):
+    def external_token_linked(self, value: Optional[ExternalTokenLinked]) -> None:
         self.__external_token_linked = value
 
     @property
-    def id(self) -> str:
+    def id(self) -> Optional[str]:
         """
         | ID of the token
 
@@ -63,11 +66,11 @@ class TokenResponse(DataObject):
         return self.__id
 
     @id.setter
-    def id(self, value: str):
+    def id(self, value: Optional[str]) -> None:
         self.__id = value
 
     @property
-    def is_temporary(self) -> bool:
+    def is_temporary(self) -> Optional[bool]:
         """
         | Temporary tokens have a lifespan of two hours and can only be used once.
 
@@ -76,11 +79,11 @@ class TokenResponse(DataObject):
         return self.__is_temporary
 
     @is_temporary.setter
-    def is_temporary(self, value: bool):
+    def is_temporary(self, value: Optional[bool]) -> None:
         self.__is_temporary = 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.
 
@@ -89,10 +92,10 @@ class TokenResponse(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(TokenResponse, self).to_dictionary()
         if self.card is not None:
             dictionary['card'] = self.card.to_dictionary()
@@ -108,7 +111,7 @@ class TokenResponse(DataObject):
             dictionary['paymentProductId'] = self.payment_product_id
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'TokenResponse':
         super(TokenResponse, self).from_dictionary(dictionary)
         if 'card' in dictionary:
             if not isinstance(dictionary['card'], dict):

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/transaction.py

@@ -1,16 +1,19 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.amount_of_money import AmountOfMoney
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
 
 
 class Transaction(DataObject):
-    __amount = None
+
+    __amount: Optional[AmountOfMoney] = None
 
     @property
-    def amount(self) -> AmountOfMoney:
+    def amount(self) -> Optional[AmountOfMoney]:
         """
         | Object containing amount and ISO currency code attributes
 
@@ -19,16 +22,16 @@ class Transaction(DataObject):
         return self.__amount
 
     @amount.setter
-    def amount(self, value: AmountOfMoney):
+    def amount(self, value: Optional[AmountOfMoney]) -> None:
         self.__amount = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(Transaction, self).to_dictionary()
         if self.amount is not None:
             dictionary['amount'] = self.amount.to_dictionary()
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'Transaction':
         super(Transaction, self).from_dictionary(dictionary)
         if 'amount' in dictionary:
             if not isinstance(dictionary['amount'], dict):

{onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk → onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/domain}/uploadable_file.py

@@ -1,4 +1,7 @@
-class UploadableFile:
+from typing import Any
+
+
+class UploadableFile(object):
     """
     A file that can be uploaded.
 
@@ -6,7 +9,7 @@ class UploadableFile:
     The default implementation supports strings, file descriptors and io.BytesIO objects.
     """
 
-    def __init__(self, file_name, content, content_type, content_length=-1):
+    def __init__(self, file_name: str, content: Any, content_type: str, content_length: int = -1):
         if file_name is None or not file_name.strip():
             raise ValueError("file_name is required")
         if content is None:
@@ -20,28 +23,28 @@ class UploadableFile:
         self.__content_length = max(content_length, -1)
 
     @property
-    def file_name(self):
+    def file_name(self) -> str:
         """
         :return: The name of the file.
         """
         return self.__file_name
 
     @property
-    def content(self):
+    def content(self) -> Any:
         """
         :return: The file's content.
         """
         return self.__content
 
     @property
-    def content_type(self):
+    def content_type(self) -> str:
         """
         :return: The file's content type.
         """
         return self.__content_type
 
     @property
-    def content_length(self):
+    def content_length(self) -> int:
         """
         :return: The file's content length, or -1 if not known.
         """

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/domain/validate_credentials_request.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ValidateCredentialsRequest(DataObject):
+
+    __key: Optional[str] = None
+    __secret: Optional[str] = None
+
+    @property
+    def key(self) -> Optional[str]:
+        """
+        | The webhook key and without any change applied to it.
+
+        Type: str
+        """
+        return self.__key
+
+    @key.setter
+    def key(self, value: Optional[str]) -> None:
+        self.__key = value
+
+    @property
+    def secret(self) -> Optional[str]:
+        """
+        | Send here the hashed webhooks key secret in the same way as the check is done in your system. The only difference is instead of providing the current body of the message, use an empty string as body while hashing it.
+
+        Type: str
+        """
+        return self.__secret
+
+    @secret.setter
+    def secret(self, value: Optional[str]) -> None:
+        self.__secret = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ValidateCredentialsRequest, self).to_dictionary()
+        if self.key is not None:
+            dictionary['key'] = self.key
+        if self.secret is not None:
+            dictionary['secret'] = self.secret
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ValidateCredentialsRequest':
+        super(ValidateCredentialsRequest, self).from_dictionary(dictionary)
+        if 'key' in dictionary:
+            self.key = dictionary['key']
+        if 'secret' in dictionary:
+            self.secret = dictionary['secret']
+        return self

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/domain/validate_credentials_response.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ValidateCredentialsResponse(DataObject):
+
+    __result: Optional[str] = None
+
+    @property
+    def result(self) -> Optional[str]:
+        """
+        | The webhooks validation was OK (Valid) or not OK (Invalid).
+
+        Type: str
+        """
+        return self.__result
+
+    @result.setter
+    def result(self, value: Optional[str]) -> None:
+        self.__result = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ValidateCredentialsResponse, self).to_dictionary()
+        if self.result is not None:
+            dictionary['result'] = self.result
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ValidateCredentialsResponse':
+        super(ValidateCredentialsResponse, self).from_dictionary(dictionary)
+        if 'result' in dictionary:
+            self.result = dictionary['result']
+        return self

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/value_mapping_element.py

@@ -1,34 +1,31 @@
 # -*- 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.payment_product_field_display_element import PaymentProductFieldDisplayElement
+from .data_object import DataObject
+from .payment_product_field_display_element import PaymentProductFieldDisplayElement
 
 
 class ValueMappingElement(DataObject):
-    """
-    | An array of values and displayNames that should be used to populate the list object in the GUI
-    """
 
-    __display_elements = None
-    __value = None
+    __display_elements: Optional[List[PaymentProductFieldDisplayElement]] = None
+    __value: Optional[str] = None
 
     @property
-    def display_elements(self) -> List[PaymentProductFieldDisplayElement]:
+    def display_elements(self) -> Optional[List[PaymentProductFieldDisplayElement]]:
         """
         Type: list[:class:`onlinepayments.sdk.domain.payment_product_field_display_element.PaymentProductFieldDisplayElement`]
         """
         return self.__display_elements
 
     @display_elements.setter
-    def display_elements(self, value: List[PaymentProductFieldDisplayElement]):
+    def display_elements(self, value: Optional[List[PaymentProductFieldDisplayElement]]) -> None:
         self.__display_elements = value
 
     @property
-    def value(self) -> str:
+    def value(self) -> Optional[str]:
         """
         | Value corresponding to the key
 
@@ -37,10 +34,10 @@ class ValueMappingElement(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(ValueMappingElement, self).to_dictionary()
         if self.display_elements is not None:
             dictionary['displayElements'] = []
@@ -51,7 +48,7 @@ class ValueMappingElement(DataObject):
             dictionary['value'] = self.value
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'ValueMappingElement':
         super(ValueMappingElement, self).from_dictionary(dictionary)
         if 'displayElements' in dictionary:
             if not isinstance(dictionary['displayElements'], list):

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/domain/web_hooks_event.py

@@ -0,0 +1,174 @@
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_response import PaymentResponse
+from .payout_response import PayoutResponse
+from .refund_response import RefundResponse
+from .token_response import TokenResponse
+
+class WebhooksEvent(DataObject):
+
+    __api_version: Optional[str] = None
+    __created: Optional[str] = None
+    __id: Optional[str] = None
+    __merchant_id: Optional[str] = None
+    __type: Optional[str] = None
+    __payment: Optional[PaymentResponse] = None
+    __payout: Optional[PayoutResponse] = None
+    __refund: Optional[RefundResponse] = None
+    __token: Optional[TokenResponse] = None
+
+    @property
+    def api_version(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__api_version
+
+    @api_version.setter
+    def api_version(self, value: Optional[str]) -> None:
+        self.__api_version = value
+
+    @property
+    def created(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__created
+
+    @created.setter
+    def created(self, value: Optional[str]) -> None:
+        self.__created = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def merchant_id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__merchant_id
+
+    @merchant_id.setter
+    def merchant_id(self, value: Optional[str]) -> None:
+        self.__merchant_id = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    @property
+    def payment(self) -> Optional[PaymentResponse]:
+        """
+        Type: PaymentResponse
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value: Optional[PaymentResponse]) -> None:
+        self.__payment = value
+
+    @property
+    def payout(self) -> Optional[PayoutResponse]:
+        """
+        Type: PayoutResponse
+        """
+        return self.__payout
+
+    @payout.setter
+    def payout(self, value: Optional[PayoutResponse]) -> None:
+        self.__payout = value
+
+    @property
+    def refund(self) -> Optional[RefundResponse]:
+        """
+        Type: RefundResponse
+        """
+        return self.__refund
+
+    @refund.setter
+    def refund(self, value: Optional[RefundResponse]) -> None:
+        self.__refund = value
+
+    @property
+    def token(self) -> Optional[TokenResponse]:
+        """
+        Type: TokenResponse
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[TokenResponse]) -> None:
+        self.__token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(WebhooksEvent, self).to_dictionary()
+        if self.api_version is not None:
+            dictionary['apiVersion'] = self.api_version
+        if self.created is not None:
+            dictionary['created'] = self.created
+        if self.id is not None:
+            dictionary['id'] = self.id
+        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: dict) -> 'WebhooksEvent':
+        super(WebhooksEvent, self).from_dictionary(dictionary)
+        if 'apiVersion' in dictionary:
+            self.api_version = dictionary['apiVersion']
+        if 'created' in dictionary:
+            self.created = dictionary['created']
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        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-5.0.0/onlinepayments/sdk/exception_factory.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Any, List, Optional
+
+from .api_exception import ApiException
+from .authorization_exception import AuthorizationException
+from .call_context import CallContext
+from .declined_payment_exception import DeclinedPaymentException
+from .declined_payout_exception import DeclinedPayoutException
+from .declined_refund_exception import DeclinedRefundException
+from .idempotence_exception import IdempotenceException
+from .platform_exception import PlatformException
+from .reference_exception import ReferenceException
+from .validation_exception import ValidationException
+
+from onlinepayments.sdk.domain.api_error import APIError
+from onlinepayments.sdk.domain.error_response import ErrorResponse
+from onlinepayments.sdk.domain.payment_error_response import PaymentErrorResponse
+from onlinepayments.sdk.domain.payout_error_response import PayoutErrorResponse
+from onlinepayments.sdk.domain.refund_error_response import RefundErrorResponse
+
+
+def create_exception(status_code: int, body: str, error_object: Any, context: Optional[CallContext]) -> Exception:
+    """Return a raisable API exception based on the error object given"""
+    def create_exception_from_response_fields(error_id: Optional[str], errors: Optional[List[APIError]]) -> Exception:
+        if is_idempotence_error(errors):
+            return IdempotenceException(context.idempotence_key, context.idempotence_request_timestamp,
+                                        status_code, body, error_id, errors)
+        # get error based on status code, defaulting to ApiException
+        return ERROR_MAP.get(status_code, ApiException)(status_code, body, error_id, errors)
+
+    def is_idempotence_error(errors: Optional[List[APIError]]) -> bool:
+        return status_code == 409 \
+            and context is not None \
+            and context.idempotence_key is not None \
+            and errors is not None \
+            and len(errors) == 1 \
+            and errors[0].error_code == '1409'
+
+    if isinstance(error_object, PaymentErrorResponse):
+        if error_object.payment_result is not None:
+            return DeclinedPaymentException(status_code=status_code,
+                                            response_body=body,
+                                            response=error_object)
+        return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+    if isinstance(error_object, PayoutErrorResponse):
+        if error_object.payout_result is not None:
+            return DeclinedPayoutException(status_code=status_code,
+                                           response_body=body,
+                                           response=error_object)
+        return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+    if isinstance(error_object, RefundErrorResponse):
+        if error_object.refund_result is not None:
+            return DeclinedRefundException(status_code=status_code,
+                                           response_body=body,
+                                           response=error_object)
+        return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+    if not isinstance(error_object, ErrorResponse):
+        raise ValueError("Unsupported error object encountered: {}".format(error_object.__class__.__name__))
+
+    return create_exception_from_response_fields(error_object.error_id, error_object.errors)
+
+
+ERROR_MAP = {
+    400: ValidationException,
+    403: AuthorizationException,
+    404: ReferenceException,
+    409: ReferenceException,  # idempotence has already been tested
+    410: ReferenceException,
+    500: PlatformException,
+    502: PlatformException,
+    503: PlatformException,
+}