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

onlinepayments/sdk/domain/token_card_data.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .card_bin_details import CardBinDetails
+from .card_without_cvv import CardWithoutCvv
+from .data_object import DataObject
+
+
+class TokenCardData(DataObject):
+
+    __card_bin_details: Optional[CardBinDetails] = None
+    __card_without_cvv: Optional[CardWithoutCvv] = None
+    __cobrand_selection_indicator: Optional[str] = None
+
+    @property
+    def card_bin_details(self) -> Optional[CardBinDetails]:
+        """
+        | Card BIN details
+
+        Type: :class:`onlinepayments.sdk.domain.card_bin_details.CardBinDetails`
+        """
+        return self.__card_bin_details
+
+    @card_bin_details.setter
+    def card_bin_details(self, value: Optional[CardBinDetails]) -> None:
+        self.__card_bin_details = value
+
+    @property
+    def card_without_cvv(self) -> Optional[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: Optional[CardWithoutCvv]) -> None:
+        self.__card_without_cvv = value
+
+    @property
+    def cobrand_selection_indicator(self) -> Optional[str]:
+        """
+        | For cobranded cards, this field indicates the brand selection method:
+        
+        * default - The holder implicitly accepted the default brand.
+        * alternative - The holder explicitly selected an alternative brand.
+        * notApplicable - The card is not cobranded.
+
+        Type: str
+        """
+        return self.__cobrand_selection_indicator
+
+    @cobrand_selection_indicator.setter
+    def cobrand_selection_indicator(self, value: Optional[str]) -> None:
+        self.__cobrand_selection_indicator = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(TokenCardData, self).to_dictionary()
+        if self.card_bin_details is not None:
+            dictionary['cardBinDetails'] = self.card_bin_details.to_dictionary()
+        if self.card_without_cvv is not None:
+            dictionary['cardWithoutCvv'] = self.card_without_cvv.to_dictionary()
+        if self.cobrand_selection_indicator is not None:
+            dictionary['cobrandSelectionIndicator'] = self.cobrand_selection_indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'TokenCardData':
+        super(TokenCardData, self).from_dictionary(dictionary)
+        if 'cardBinDetails' in dictionary:
+            if not isinstance(dictionary['cardBinDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardBinDetails']))
+            value = CardBinDetails()
+            self.card_bin_details = value.from_dictionary(dictionary['cardBinDetails'])
+        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'])
+        if 'cobrandSelectionIndicator' in dictionary:
+            self.cobrand_selection_indicator = dictionary['cobrandSelectionIndicator']
+        return self

onlinepayments/sdk/domain/token_card_specific_input.py

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

onlinepayments/sdk/domain/token_data.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .card import Card
+from .data_object import DataObject
+
+
+class TokenData(DataObject):
+
+    __card: Optional[Card] = None
+    __cobrand_selection_indicator: Optional[str] = None
+
+    @property
+    def card(self) -> Optional[Card]:
+        """
+        | Object containing card details
+
+        Type: :class:`onlinepayments.sdk.domain.card.Card`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[Card]) -> None:
+        self.__card = value
+
+    @property
+    def cobrand_selection_indicator(self) -> Optional[str]:
+        """
+        | For cobranded cards, this field indicates the brand selection method:
+        
+        * default - The holder implicitly accepted the default brand.
+        * alternative - The holder explicitly selected an alternative brand.
+        * notApplicable - The card is not cobranded.
+
+        Type: str
+        """
+        return self.__cobrand_selection_indicator
+
+    @cobrand_selection_indicator.setter
+    def cobrand_selection_indicator(self, value: Optional[str]) -> None:
+        self.__cobrand_selection_indicator = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(TokenData, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.cobrand_selection_indicator is not None:
+            dictionary['cobrandSelectionIndicator'] = self.cobrand_selection_indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'TokenData':
+        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'])
+        if 'cobrandSelectionIndicator' in dictionary:
+            self.cobrand_selection_indicator = dictionary['cobrandSelectionIndicator']
+        return self

onlinepayments/sdk/domain/token_e_wallet.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .customer_token import CustomerToken
+from .data_object import DataObject
+
+
+class TokenEWallet(DataObject):
+
+    __alias: Optional[str] = None
+    __customer: Optional[CustomerToken] = None
+
+    @property
+    def alias(self) -> Optional[str]:
+        """
+        | Deprecated: This field is not used by any payment product An alias for the token. This can be used to visually represent the token.
+
+        Type: str
+
+        Deprecated; This field is not used by any payment product An alias for the token. This can be used to visually represent the token.
+        """
+        return self.__alias
+
+    @alias.setter
+    def alias(self, value: Optional[str]) -> None:
+        self.__alias = value
+
+    @property
+    def customer(self) -> Optional[CustomerToken]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.customer_token.CustomerToken`
+        """
+        return self.__customer
+
+    @customer.setter
+    def customer(self, value: Optional[CustomerToken]) -> None:
+        self.__customer = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(TokenEWallet, self).to_dictionary()
+        if self.alias is not None:
+            dictionary['alias'] = self.alias
+        if self.customer is not None:
+            dictionary['customer'] = self.customer.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'TokenEWallet':
+        super(TokenEWallet, self).from_dictionary(dictionary)
+        if 'alias' in dictionary:
+            self.alias = dictionary['alias']
+        if 'customer' in dictionary:
+            if not isinstance(dictionary['customer'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
+            value = CustomerToken()
+            self.customer = value.from_dictionary(dictionary['customer'])
+        return self

onlinepayments/sdk/domain/token_response.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .crm_token import CrmToken
+from .data_object import DataObject
+from .external_token_linked import ExternalTokenLinked
+from .network_token_linked import NetworkTokenLinked
+from .token_card import TokenCard
+from .token_e_wallet import TokenEWallet
+
+
+class TokenResponse(DataObject):
+
+    __card: Optional[TokenCard] = None
+    __crm_token: Optional[CrmToken] = None
+    __e_wallet: Optional[TokenEWallet] = None
+    __external_token_linked: Optional[ExternalTokenLinked] = None
+    __id: Optional[str] = None
+    __is_temporary: Optional[bool] = None
+    __network_token_linked: Optional[NetworkTokenLinked] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def card(self) -> Optional[TokenCard]:
+        """
+        | Object containing card details
+
+        Type: :class:`onlinepayments.sdk.domain.token_card.TokenCard`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[TokenCard]) -> None:
+        self.__card = value
+
+    @property
+    def crm_token(self) -> Optional[CrmToken]:
+        """
+        | The CRM (Customer Relationship Management) token group. CRM tokens are available to enhance knowledge of a merchant's customers by attempting to identify the customer.
+
+        Type: :class:`onlinepayments.sdk.domain.crm_token.CrmToken`
+        """
+        return self.__crm_token
+
+    @crm_token.setter
+    def crm_token(self, value: Optional[CrmToken]) -> None:
+        self.__crm_token = value
+
+    @property
+    def e_wallet(self) -> Optional[TokenEWallet]:
+        """
+        | Object containing eWallet details
+
+        Type: :class:`onlinepayments.sdk.domain.token_e_wallet.TokenEWallet`
+        """
+        return self.__e_wallet
+
+    @e_wallet.setter
+    def e_wallet(self, value: Optional[TokenEWallet]) -> None:
+        self.__e_wallet = value
+
+    @property
+    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: Optional[ExternalTokenLinked]) -> None:
+        self.__external_token_linked = 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 is_temporary(self) -> Optional[bool]:
+        """
+        | Temporary tokens have a lifespan of two hours and can only be used once.
+
+        Type: bool
+        """
+        return self.__is_temporary
+
+    @is_temporary.setter
+    def is_temporary(self, value: Optional[bool]) -> None:
+        self.__is_temporary = value
+
+    @property
+    def network_token_linked(self) -> Optional[NetworkTokenLinked]:
+        """
+        | Object containing Network Token details, when the Network Token was created on behalf of the merchant and is activated.
+
+        Type: :class:`onlinepayments.sdk.domain.network_token_linked.NetworkTokenLinked`
+        """
+        return self.__network_token_linked
+
+    @network_token_linked.setter
+    def network_token_linked(self, value: Optional[NetworkTokenLinked]) -> None:
+        self.__network_token_linked = 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(TokenResponse, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.crm_token is not None:
+            dictionary['crmToken'] = self.crm_token.to_dictionary()
+        if self.e_wallet is not None:
+            dictionary['eWallet'] = self.e_wallet.to_dictionary()
+        if self.external_token_linked is not None:
+            dictionary['externalTokenLinked'] = self.external_token_linked.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.is_temporary is not None:
+            dictionary['isTemporary'] = self.is_temporary
+        if self.network_token_linked is not None:
+            dictionary['networkTokenLinked'] = self.network_token_linked.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'TokenResponse':
+        super(TokenResponse, 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 = TokenCard()
+            self.card = value.from_dictionary(dictionary['card'])
+        if 'crmToken' in dictionary:
+            if not isinstance(dictionary['crmToken'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['crmToken']))
+            value = CrmToken()
+            self.crm_token = value.from_dictionary(dictionary['crmToken'])
+        if 'eWallet' in dictionary:
+            if not isinstance(dictionary['eWallet'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eWallet']))
+            value = TokenEWallet()
+            self.e_wallet = value.from_dictionary(dictionary['eWallet'])
+        if 'externalTokenLinked' in dictionary:
+            if not isinstance(dictionary['externalTokenLinked'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['externalTokenLinked']))
+            value = ExternalTokenLinked()
+            self.external_token_linked = value.from_dictionary(dictionary['externalTokenLinked'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'isTemporary' in dictionary:
+            self.is_temporary = dictionary['isTemporary']
+        if 'networkTokenLinked' in dictionary:
+            if not isinstance(dictionary['networkTokenLinked'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['networkTokenLinked']))
+            value = NetworkTokenLinked()
+            self.network_token_linked = value.from_dictionary(dictionary['networkTokenLinked'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

onlinepayments/sdk/domain/transaction.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+
+
+class Transaction(DataObject):
+
+    __amount: Optional[AmountOfMoney] = None
+
+    @property
+    def amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount = value
+
+    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: dict) -> 'Transaction':
+        super(Transaction, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            if not isinstance(dictionary['amount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amount']))
+            value = AmountOfMoney()
+            self.amount = value.from_dictionary(dictionary['amount'])
+        return self

onlinepayments/sdk/domain/uploadable_file.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+
+class UploadableFile(object):
+    """
+    A file that can be uploaded.
+
+    The allowed forms of content are defined by the Connection implementation.
+    The default implementation supports strings, file descriptors and io.BytesIO objects.
+    """
+
+    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:
+            raise ValueError("content is required")
+        if content_type is None or not content_type.strip():
+            raise ValueError("file_name is required")
+
+        self.__file_name = file_name
+        self.__content = content
+        self.__content_type = content_type
+        self.__content_length = max(content_length, -1)
+
+    @property
+    def file_name(self) -> str:
+        """
+        :return: The name of the file.
+        """
+        return self.__file_name
+
+    @property
+    def content(self) -> Any:
+        """
+        :return: The file's content.
+        """
+        return self.__content
+
+    @property
+    def content_type(self) -> str:
+        """
+        :return: The file's content type.
+        """
+        return self.__content_type
+
+    @property
+    def content_length(self) -> int:
+        """
+        :return: The file's content length, or -1 if not known.
+        """
+        return self.__content_length

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/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/domain/value_mapping_element.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .payment_product_field_display_element import PaymentProductFieldDisplayElement
+
+
+class ValueMappingElement(DataObject):
+
+    __display_elements: Optional[List[PaymentProductFieldDisplayElement]] = None
+    __value: Optional[str] = None
+
+    @property
+    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: Optional[List[PaymentProductFieldDisplayElement]]) -> None:
+        self.__display_elements = value
+
+    @property
+    def value(self) -> Optional[str]:
+        """
+        | Value corresponding to the key
+
+        Type: str
+        """
+        return self.__value
+
+    @value.setter
+    def value(self, value: Optional[str]) -> None:
+        self.__value = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ValueMappingElement, self).to_dictionary()
+        if self.display_elements is not None:
+            dictionary['displayElements'] = []
+            for element in self.display_elements:
+                if element is not None:
+                    dictionary['displayElements'].append(element.to_dictionary())
+        if self.value is not None:
+            dictionary['value'] = self.value
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ValueMappingElement':
+        super(ValueMappingElement, self).from_dictionary(dictionary)
+        if 'displayElements' in dictionary:
+            if not isinstance(dictionary['displayElements'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['displayElements']))
+            self.display_elements = []
+            for element in dictionary['displayElements']:
+                value = PaymentProductFieldDisplayElement()
+                self.display_elements.append(value.from_dictionary(element))
+        if 'value' in dictionary:
+            self.value = dictionary['value']
+        return self