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

onlinepayments/sdk/domain/credit_card_validation_rules_hosted_tokenization.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CreditCardValidationRulesHostedTokenization(DataObject):
+
+    __cvv_mandatory_for_existing_token: Optional[bool] = None
+    __cvv_mandatory_for_new_token: Optional[bool] = None
+
+    @property
+    def cvv_mandatory_for_existing_token(self) -> Optional[bool]:
+        """
+        | Determines whether the Card Verification Value must be provided for existing tokens. This option overrides the payment method configuration for the session.
+
+        Type: bool
+        """
+        return self.__cvv_mandatory_for_existing_token
+
+    @cvv_mandatory_for_existing_token.setter
+    def cvv_mandatory_for_existing_token(self, value: Optional[bool]) -> None:
+        self.__cvv_mandatory_for_existing_token = value
+
+    @property
+    def cvv_mandatory_for_new_token(self) -> Optional[bool]:
+        """
+        | Determines whether the Card Verification Value must be provided for new tokens. This option overrides the payment method configuration for the session.
+
+        Type: bool
+        """
+        return self.__cvv_mandatory_for_new_token
+
+    @cvv_mandatory_for_new_token.setter
+    def cvv_mandatory_for_new_token(self, value: Optional[bool]) -> None:
+        self.__cvv_mandatory_for_new_token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreditCardValidationRulesHostedTokenization, self).to_dictionary()
+        if self.cvv_mandatory_for_existing_token is not None:
+            dictionary['cvvMandatoryForExistingToken'] = self.cvv_mandatory_for_existing_token
+        if self.cvv_mandatory_for_new_token is not None:
+            dictionary['cvvMandatoryForNewToken'] = self.cvv_mandatory_for_new_token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreditCardValidationRulesHostedTokenization':
+        super(CreditCardValidationRulesHostedTokenization, self).from_dictionary(dictionary)
+        if 'cvvMandatoryForExistingToken' in dictionary:
+            self.cvv_mandatory_for_existing_token = dictionary['cvvMandatoryForExistingToken']
+        if 'cvvMandatoryForNewToken' in dictionary:
+            self.cvv_mandatory_for_new_token = dictionary['cvvMandatoryForNewToken']
+        return self

onlinepayments/sdk/domain/crm_token.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CrmToken(DataObject):
+
+    __unique_account_identifier: Optional[str] = None
+    __unique_card_identifier: Optional[str] = None
+
+    @property
+    def unique_account_identifier(self) -> Optional[str]:
+        """
+        | A unique identifier that remains constant across different formats of the same card (whether used via wallets such as Apple Pay, Google Pay, etc., or the physical card), even if the tokenID may differ. The unique account identifier cannot be used to trigger a payment.
+
+        Type: str
+        """
+        return self.__unique_account_identifier
+
+    @unique_account_identifier.setter
+    def unique_account_identifier(self, value: Optional[str]) -> None:
+        self.__unique_account_identifier = value
+
+    @property
+    def unique_card_identifier(self) -> Optional[str]:
+        """
+        | A unique identifier for the card that was tokenized. This identifier remains the same for a given card, even if the tokenID may differ. The unique card identifier cannot be used to trigger a payment.
+
+        Type: str
+        """
+        return self.__unique_card_identifier
+
+    @unique_card_identifier.setter
+    def unique_card_identifier(self, value: Optional[str]) -> None:
+        self.__unique_card_identifier = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CrmToken, self).to_dictionary()
+        if self.unique_account_identifier is not None:
+            dictionary['uniqueAccountIdentifier'] = self.unique_account_identifier
+        if self.unique_card_identifier is not None:
+            dictionary['uniqueCardIdentifier'] = self.unique_card_identifier
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CrmToken':
+        super(CrmToken, self).from_dictionary(dictionary)
+        if 'uniqueAccountIdentifier' in dictionary:
+            self.unique_account_identifier = dictionary['uniqueAccountIdentifier']
+        if 'uniqueCardIdentifier' in dictionary:
+            self.unique_card_identifier = dictionary['uniqueCardIdentifier']
+        return self

onlinepayments/sdk/domain/csr_request.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CsrRequest(DataObject):
+
+    __csr: Optional[str] = None
+
+    @property
+    def csr(self) -> Optional[str]:
+        """
+        | A Certificate Signing Request (CSR) string that contains the encoded information necessary for generating a digital certificate, including the public key and identity details of the requester.
+
+        Type: str
+        """
+        return self.__csr
+
+    @csr.setter
+    def csr(self, value: Optional[str]) -> None:
+        self.__csr = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CsrRequest, self).to_dictionary()
+        if self.csr is not None:
+            dictionary['csr'] = self.csr
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CsrRequest':
+        super(CsrRequest, self).from_dictionary(dictionary)
+        if 'csr' in dictionary:
+            self.csr = dictionary['csr']
+        return self

onlinepayments/sdk/domain/currency_conversion.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .dcc_proposal import DccProposal
+
+
+class CurrencyConversion(DataObject):
+
+    __accepted_by_user: Optional[bool] = None
+    __proposal: Optional[DccProposal] = None
+
+    @property
+    def accepted_by_user(self) -> Optional[bool]:
+        """
+        | Dynamic Currency Conversion(DCC) Proposal accepted by user
+
+        Type: bool
+        """
+        return self.__accepted_by_user
+
+    @accepted_by_user.setter
+    def accepted_by_user(self, value: Optional[bool]) -> None:
+        self.__accepted_by_user = value
+
+    @property
+    def proposal(self) -> Optional[DccProposal]:
+        """
+        | Details of currency conversion to be proposed to the cardholder
+
+        Type: :class:`onlinepayments.sdk.domain.dcc_proposal.DccProposal`
+        """
+        return self.__proposal
+
+    @proposal.setter
+    def proposal(self, value: Optional[DccProposal]) -> None:
+        self.__proposal = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CurrencyConversion, self).to_dictionary()
+        if self.accepted_by_user is not None:
+            dictionary['acceptedByUser'] = self.accepted_by_user
+        if self.proposal is not None:
+            dictionary['proposal'] = self.proposal.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CurrencyConversion':
+        super(CurrencyConversion, self).from_dictionary(dictionary)
+        if 'acceptedByUser' in dictionary:
+            self.accepted_by_user = dictionary['acceptedByUser']
+        if 'proposal' in dictionary:
+            if not isinstance(dictionary['proposal'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['proposal']))
+            value = DccProposal()
+            self.proposal = value.from_dictionary(dictionary['proposal'])
+        return self

onlinepayments/sdk/domain/currency_conversion_input.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CurrencyConversionInput(DataObject):
+
+    __accepted_by_user: Optional[bool] = None
+    __dcc_session_id: Optional[str] = None
+
+    @property
+    def accepted_by_user(self) -> Optional[bool]:
+        """
+        | Dynamic Currency Conversion(DCC) Proposal accepted by user
+
+        Type: bool
+        """
+        return self.__accepted_by_user
+
+    @accepted_by_user.setter
+    def accepted_by_user(self, value: Optional[bool]) -> None:
+        self.__accepted_by_user = value
+
+    @property
+    def dcc_session_id(self) -> Optional[str]:
+        """
+        | Dynamic Currency Conversion(DCC) Session Id that was previously returned by rate enquiry (/dccrate).
+
+        Type: str
+        """
+        return self.__dcc_session_id
+
+    @dcc_session_id.setter
+    def dcc_session_id(self, value: Optional[str]) -> None:
+        self.__dcc_session_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CurrencyConversionInput, self).to_dictionary()
+        if self.accepted_by_user is not None:
+            dictionary['acceptedByUser'] = self.accepted_by_user
+        if self.dcc_session_id is not None:
+            dictionary['dccSessionId'] = self.dcc_session_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CurrencyConversionInput':
+        super(CurrencyConversionInput, self).from_dictionary(dictionary)
+        if 'acceptedByUser' in dictionary:
+            self.accepted_by_user = dictionary['acceptedByUser']
+        if 'dccSessionId' in dictionary:
+            self.dcc_session_id = dictionary['dccSessionId']
+        return self

onlinepayments/sdk/domain/currency_conversion_request.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .dcc_card_source import DccCardSource
+from .transaction import Transaction
+
+
+class CurrencyConversionRequest(DataObject):
+
+    __card_source: Optional[DccCardSource] = None
+    __transaction: Optional[Transaction] = None
+
+    @property
+    def card_source(self) -> Optional[DccCardSource]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.dcc_card_source.DccCardSource`
+        """
+        return self.__card_source
+
+    @card_source.setter
+    def card_source(self, value: Optional[DccCardSource]) -> None:
+        self.__card_source = value
+
+    @property
+    def transaction(self) -> Optional[Transaction]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.transaction.Transaction`
+        """
+        return self.__transaction
+
+    @transaction.setter
+    def transaction(self, value: Optional[Transaction]) -> None:
+        self.__transaction = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CurrencyConversionRequest, self).to_dictionary()
+        if self.card_source is not None:
+            dictionary['cardSource'] = self.card_source.to_dictionary()
+        if self.transaction is not None:
+            dictionary['transaction'] = self.transaction.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CurrencyConversionRequest':
+        super(CurrencyConversionRequest, self).from_dictionary(dictionary)
+        if 'cardSource' in dictionary:
+            if not isinstance(dictionary['cardSource'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardSource']))
+            value = DccCardSource()
+            self.card_source = value.from_dictionary(dictionary['cardSource'])
+        if 'transaction' in dictionary:
+            if not isinstance(dictionary['transaction'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['transaction']))
+            value = Transaction()
+            self.transaction = value.from_dictionary(dictionary['transaction'])
+        return self

onlinepayments/sdk/domain/currency_conversion_response.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .currency_conversion_result import CurrencyConversionResult
+from .data_object import DataObject
+from .dcc_proposal import DccProposal
+
+
+class CurrencyConversionResponse(DataObject):
+
+    __dcc_session_id: Optional[str] = None
+    __proposal: Optional[DccProposal] = None
+    __result: Optional[CurrencyConversionResult] = None
+
+    @property
+    def dcc_session_id(self) -> Optional[str]:
+        """
+        | The identifier of the Dynamic Currency Conversion(DCC) session that has been created. 'dccSessionId' will be populated exclusively when the result is "Allowed" for other outcomes such as "InvalidCard", "InvalidMerchant", "NoRate" or "NotAvailable" this field value will be an empty string.
+
+        Type: str
+        """
+        return self.__dcc_session_id
+
+    @dcc_session_id.setter
+    def dcc_session_id(self, value: Optional[str]) -> None:
+        self.__dcc_session_id = value
+
+    @property
+    def proposal(self) -> Optional[DccProposal]:
+        """
+        | Details of currency conversion to be proposed to the cardholder
+
+        Type: :class:`onlinepayments.sdk.domain.dcc_proposal.DccProposal`
+        """
+        return self.__proposal
+
+    @proposal.setter
+    def proposal(self, value: Optional[DccProposal]) -> None:
+        self.__proposal = value
+
+    @property
+    def result(self) -> Optional[CurrencyConversionResult]:
+        """
+        | Result of a requested currency conversion
+
+        Type: :class:`onlinepayments.sdk.domain.currency_conversion_result.CurrencyConversionResult`
+        """
+        return self.__result
+
+    @result.setter
+    def result(self, value: Optional[CurrencyConversionResult]) -> None:
+        self.__result = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CurrencyConversionResponse, self).to_dictionary()
+        if self.dcc_session_id is not None:
+            dictionary['dccSessionId'] = self.dcc_session_id
+        if self.proposal is not None:
+            dictionary['proposal'] = self.proposal.to_dictionary()
+        if self.result is not None:
+            dictionary['result'] = self.result.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CurrencyConversionResponse':
+        super(CurrencyConversionResponse, self).from_dictionary(dictionary)
+        if 'dccSessionId' in dictionary:
+            self.dcc_session_id = dictionary['dccSessionId']
+        if 'proposal' in dictionary:
+            if not isinstance(dictionary['proposal'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['proposal']))
+            value = DccProposal()
+            self.proposal = value.from_dictionary(dictionary['proposal'])
+        if 'result' in dictionary:
+            if not isinstance(dictionary['result'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['result']))
+            value = CurrencyConversionResult()
+            self.result = value.from_dictionary(dictionary['result'])
+        return self

onlinepayments/sdk/domain/currency_conversion_result.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CurrencyConversionResult(DataObject):
+
+    __result: Optional[str] = None
+    __result_reason: Optional[str] = None
+
+    @property
+    def result(self) -> Optional[str]:
+        """
+        | Functional response to the request:
+        
+        * Allowed: Dynamic currency conversion may be offered to the cardholder
+        * InvalidCard: The card is not valid for dynamic currency conversion
+        * InvalidMerchant: The card acceptor has not been recognised
+        * NoRate: Exchange rates are not available
+        * NotAvailable: Dynamic currency conversion is not available for other reason
+
+        Type: str
+        """
+        return self.__result
+
+    @result.setter
+    def result(self, value: Optional[str]) -> None:
+        self.__result = value
+
+    @property
+    def result_reason(self) -> Optional[str]:
+        """
+        | Plain text explaining the result of the currency conversion request
+
+        Type: str
+        """
+        return self.__result_reason
+
+    @result_reason.setter
+    def result_reason(self, value: Optional[str]) -> None:
+        self.__result_reason = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CurrencyConversionResult, self).to_dictionary()
+        if self.result is not None:
+            dictionary['result'] = self.result
+        if self.result_reason is not None:
+            dictionary['resultReason'] = self.result_reason
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CurrencyConversionResult':
+        super(CurrencyConversionResult, self).from_dictionary(dictionary)
+        if 'result' in dictionary:
+            self.result = dictionary['result']
+        if 'resultReason' in dictionary:
+            self.result_reason = dictionary['resultReason']
+        return self

onlinepayments/sdk/domain/currency_conversion_specific_input.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CurrencyConversionSpecificInput(DataObject):
+
+    __dcc_enabled: Optional[bool] = None
+
+    @property
+    def dcc_enabled(self) -> Optional[bool]:
+        """
+        | Indicates if this transaction is Dynamic Currency Conversion (DCC) enabled.
+        
+        * true - Dynamic Currency Conversion (DCC) is enabled in this transaction.
+        * false - Dynamic Currency Conversion (DCC) is disabled in this transaction. The default value for this property is false.
+
+        Type: bool
+        """
+        return self.__dcc_enabled
+
+    @dcc_enabled.setter
+    def dcc_enabled(self, value: Optional[bool]) -> None:
+        self.__dcc_enabled = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CurrencyConversionSpecificInput, self).to_dictionary()
+        if self.dcc_enabled is not None:
+            dictionary['dccEnabled'] = self.dcc_enabled
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CurrencyConversionSpecificInput':
+        super(CurrencyConversionSpecificInput, self).from_dictionary(dictionary)
+        if 'dccEnabled' in dictionary:
+            self.dcc_enabled = dictionary['dccEnabled']
+        return self