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

onlinepayments/sdk/domain/external_cardholder_authentication_data.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ExternalCardholderAuthenticationData(DataObject):
+
+    __acs_transaction_id: Optional[str] = None
+    __applied_exemption: Optional[str] = None
+    __cavv: Optional[str] = None
+    __cavv_algorithm: Optional[str] = None
+    __directory_server_transaction_id: Optional[str] = None
+    __eci: Optional[int] = None
+    __flow: Optional[str] = None
+    __scheme_risk_score: Optional[int] = None
+    __three_d_secure_version: Optional[str] = None
+    __xid: Optional[str] = None
+
+    @property
+    def acs_transaction_id(self) -> Optional[str]:
+        """
+        | Identifier of the authenticated transaction at the ACS/Issuer.
+
+        Type: str
+        """
+        return self.__acs_transaction_id
+
+    @acs_transaction_id.setter
+    def acs_transaction_id(self, value: Optional[str]) -> None:
+        self.__acs_transaction_id = value
+
+    @property
+    def applied_exemption(self) -> Optional[str]:
+        """
+        | Exemption code from Carte Bancaire (130) (unknown possible values so far -free format).
+
+        Type: str
+        """
+        return self.__applied_exemption
+
+    @applied_exemption.setter
+    def applied_exemption(self, value: Optional[str]) -> None:
+        self.__applied_exemption = value
+
+    @property
+    def cavv(self) -> Optional[str]:
+        """
+        | The CAVV (cardholder authentication verification value) or AAV (accountholder authentication value) provides an authentication validation value. Note: This is mandatory for ECI 2 and 5.
+
+        Type: str
+        """
+        return self.__cavv
+
+    @cavv.setter
+    def cavv(self, value: Optional[str]) -> None:
+        self.__cavv = value
+
+    @property
+    def cavv_algorithm(self) -> Optional[str]:
+        """
+        | The algorithm, from your 3D Secure provider, used to generate the authentication CAVV. Note: Required when
+        
+        * The 3D Secure authentication for the transaction is managed by a third-party 3D Secure authentication provider
+        * You process the transaction through Atos
+
+        Type: str
+        """
+        return self.__cavv_algorithm
+
+    @cavv_algorithm.setter
+    def cavv_algorithm(self, value: Optional[str]) -> None:
+        self.__cavv_algorithm = value
+
+    @property
+    def directory_server_transaction_id(self) -> Optional[str]:
+        """
+        | The 3-D Secure Directory Server transaction ID that is used for the 3D Authentication Example: d4c849f8-24c6-4673-bf34-d0f822c81b16
+
+        Type: str
+        """
+        return self.__directory_server_transaction_id
+
+    @directory_server_transaction_id.setter
+    def directory_server_transaction_id(self, value: Optional[str]) -> None:
+        self.__directory_server_transaction_id = value
+
+    @property
+    def eci(self) -> Optional[int]:
+        """
+        | Electronic Commerce Indicator provides authentication validation results returned after AUTHENTICATIONVALIDATION
+        
+        * 0 = No authentication, Internet (no liability shift, not a 3D Secure transaction)
+        * 1 = Authentication attempted (MasterCard)
+        * 2 = Successful authentication (MasterCard)
+        * 5 = Successful authentication (Visa, Diners Club, Amex)
+        * 6 = Authentication attempted (Visa, Diners Club, Amex)
+        * 7 = No authentication, Internet (no liability shift, not a 3D Secure transaction)
+        * (empty) = Not checked or not enrolled
+
+        Type: int
+        """
+        return self.__eci
+
+    @eci.setter
+    def eci(self, value: Optional[int]) -> None:
+        self.__eci = value
+
+    @property
+    def flow(self) -> Optional[str]:
+        """
+        | 3D Secure Flow used during this transaction.
+
+        Type: str
+        """
+        return self.__flow
+
+    @flow.setter
+    def flow(self, value: Optional[str]) -> None:
+        self.__flow = value
+
+    @property
+    def scheme_risk_score(self) -> Optional[int]:
+        """
+        | Global score calculated by the Carte Bancaire (130) Scoring platform. Possible values from 0 to 99.
+
+        Type: int
+        """
+        return self.__scheme_risk_score
+
+    @scheme_risk_score.setter
+    def scheme_risk_score(self, value: Optional[int]) -> None:
+        self.__scheme_risk_score = value
+
+    @property
+    def three_d_secure_version(self) -> Optional[str]:
+        """
+        | The 3-D Secure version used for the authentication. Possible values:
+        
+        * v1
+        * v2
+        * 1.0.2
+        * 2.1.0
+        * 2.2.0
+
+        Type: str
+        """
+        return self.__three_d_secure_version
+
+    @three_d_secure_version.setter
+    def three_d_secure_version(self, value: Optional[str]) -> None:
+        self.__three_d_secure_version = value
+
+    @property
+    def xid(self) -> Optional[str]:
+        """
+        | The transaction ID that is used for the 3D Authentication
+
+        Type: str
+        """
+        return self.__xid
+
+    @xid.setter
+    def xid(self, value: Optional[str]) -> None:
+        self.__xid = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ExternalCardholderAuthenticationData, self).to_dictionary()
+        if self.acs_transaction_id is not None:
+            dictionary['acsTransactionId'] = self.acs_transaction_id
+        if self.applied_exemption is not None:
+            dictionary['appliedExemption'] = self.applied_exemption
+        if self.cavv is not None:
+            dictionary['cavv'] = self.cavv
+        if self.cavv_algorithm is not None:
+            dictionary['cavvAlgorithm'] = self.cavv_algorithm
+        if self.directory_server_transaction_id is not None:
+            dictionary['directoryServerTransactionId'] = self.directory_server_transaction_id
+        if self.eci is not None:
+            dictionary['eci'] = self.eci
+        if self.flow is not None:
+            dictionary['flow'] = self.flow
+        if self.scheme_risk_score is not None:
+            dictionary['schemeRiskScore'] = self.scheme_risk_score
+        if self.three_d_secure_version is not None:
+            dictionary['threeDSecureVersion'] = self.three_d_secure_version
+        if self.xid is not None:
+            dictionary['xid'] = self.xid
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ExternalCardholderAuthenticationData':
+        super(ExternalCardholderAuthenticationData, self).from_dictionary(dictionary)
+        if 'acsTransactionId' in dictionary:
+            self.acs_transaction_id = dictionary['acsTransactionId']
+        if 'appliedExemption' in dictionary:
+            self.applied_exemption = dictionary['appliedExemption']
+        if 'cavv' in dictionary:
+            self.cavv = dictionary['cavv']
+        if 'cavvAlgorithm' in dictionary:
+            self.cavv_algorithm = dictionary['cavvAlgorithm']
+        if 'directoryServerTransactionId' in dictionary:
+            self.directory_server_transaction_id = dictionary['directoryServerTransactionId']
+        if 'eci' in dictionary:
+            self.eci = dictionary['eci']
+        if 'flow' in dictionary:
+            self.flow = dictionary['flow']
+        if 'schemeRiskScore' in dictionary:
+            self.scheme_risk_score = dictionary['schemeRiskScore']
+        if 'threeDSecureVersion' in dictionary:
+            self.three_d_secure_version = dictionary['threeDSecureVersion']
+        if 'xid' in dictionary:
+            self.xid = dictionary['xid']
+        return self

onlinepayments/sdk/domain/external_token_linked.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ExternalTokenLinked(DataObject):
+
+    __computed_token: Optional[str] = None
+    __gts_computed_token: Optional[str] = None
+    __generated_token: Optional[str] = None
+
+    @property
+    def computed_token(self) -> Optional[str]:
+        """
+        | The computed token
+
+        Type: str
+        """
+        return self.__computed_token
+
+    @computed_token.setter
+    def computed_token(self, value: Optional[str]) -> None:
+        self.__computed_token = value
+
+    @property
+    def gts_computed_token(self) -> Optional[str]:
+        """
+        | Deprecated: Use the field ComputedToken instead.
+
+        Type: str
+
+        Deprecated; Use the field ComputedToken instead.
+        """
+        return self.__gts_computed_token
+
+    @gts_computed_token.setter
+    def gts_computed_token(self, value: Optional[str]) -> None:
+        self.__gts_computed_token = value
+
+    @property
+    def generated_token(self) -> Optional[str]:
+        """
+        | The generated token
+
+        Type: str
+        """
+        return self.__generated_token
+
+    @generated_token.setter
+    def generated_token(self, value: Optional[str]) -> None:
+        self.__generated_token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ExternalTokenLinked, self).to_dictionary()
+        if self.computed_token is not None:
+            dictionary['ComputedToken'] = self.computed_token
+        if self.gts_computed_token is not None:
+            dictionary['GTSComputedToken'] = self.gts_computed_token
+        if self.generated_token is not None:
+            dictionary['GeneratedToken'] = self.generated_token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ExternalTokenLinked':
+        super(ExternalTokenLinked, self).from_dictionary(dictionary)
+        if 'ComputedToken' in dictionary:
+            self.computed_token = dictionary['ComputedToken']
+        if 'GTSComputedToken' in dictionary:
+            self.gts_computed_token = dictionary['GTSComputedToken']
+        if 'GeneratedToken' in dictionary:
+            self.generated_token = dictionary['GeneratedToken']
+        return self

onlinepayments/sdk/domain/feedbacks.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class Feedbacks(DataObject):
+
+    __webhook_url: Optional[str] = None
+    __webhooks_urls: Optional[List[str]] = None
+
+    @property
+    def webhook_url(self) -> Optional[str]:
+        """
+        | The URL where the webhook will be dispatched for all status change events related to this payment.
+
+        Type: str
+
+        Deprecated; The URL where the webhook will be dispatched for all status change events related to this payment.
+        """
+        return self.__webhook_url
+
+    @webhook_url.setter
+    def webhook_url(self, value: Optional[str]) -> None:
+        self.__webhook_url = value
+
+    @property
+    def webhooks_urls(self) -> Optional[List[str]]:
+        """
+        | The list of the URLs where the webhook will be dispatched for all status change events related to this payment.
+
+        Type: list[str]
+        """
+        return self.__webhooks_urls
+
+    @webhooks_urls.setter
+    def webhooks_urls(self, value: Optional[List[str]]) -> None:
+        self.__webhooks_urls = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Feedbacks, self).to_dictionary()
+        if self.webhook_url is not None:
+            dictionary['webhookUrl'] = self.webhook_url
+        if self.webhooks_urls is not None:
+            dictionary['webhooksUrls'] = []
+            for element in self.webhooks_urls:
+                if element is not None:
+                    dictionary['webhooksUrls'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Feedbacks':
+        super(Feedbacks, self).from_dictionary(dictionary)
+        if 'webhookUrl' in dictionary:
+            self.webhook_url = dictionary['webhookUrl']
+        if 'webhooksUrls' in dictionary:
+            if not isinstance(dictionary['webhooksUrls'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['webhooksUrls']))
+            self.webhooks_urls = []
+            for element in dictionary['webhooksUrls']:
+                self.webhooks_urls.append(element)
+        return self

onlinepayments/sdk/domain/fixed_list_validator.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class FixedListValidator(DataObject):
+
+    __allowed_values: Optional[List[str]] = None
+
+    @property
+    def allowed_values(self) -> Optional[List[str]]:
+        """
+        Type: list[str]
+        """
+        return self.__allowed_values
+
+    @allowed_values.setter
+    def allowed_values(self, value: Optional[List[str]]) -> None:
+        self.__allowed_values = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FixedListValidator, self).to_dictionary()
+        if self.allowed_values is not None:
+            dictionary['allowedValues'] = []
+            for element in self.allowed_values:
+                if element is not None:
+                    dictionary['allowedValues'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FixedListValidator':
+        super(FixedListValidator, self).from_dictionary(dictionary)
+        if 'allowedValues' in dictionary:
+            if not isinstance(dictionary['allowedValues'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['allowedValues']))
+            self.allowed_values = []
+            for element in dictionary['allowedValues']:
+                self.allowed_values.append(element)
+        return self

onlinepayments/sdk/domain/fraud_fields.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class FraudFields(DataObject):
+
+    __black_list_data: Optional[str] = None
+    __customer_ip_address: Optional[str] = None
+    __product_categories: Optional[List[str]] = None
+
+    @property
+    def black_list_data(self) -> Optional[str]:
+        """
+        | Additional black list input
+
+        Type: str
+        """
+        return self.__black_list_data
+
+    @black_list_data.setter
+    def black_list_data(self, value: Optional[str]) -> None:
+        self.__black_list_data = value
+
+    @property
+    def customer_ip_address(self) -> Optional[str]:
+        """
+        | Deprecated: Use order.customer.device.ipAddress instead.
+        |
+        | The IP Address of the customer that is making the payment
+
+        Type: str
+
+        Deprecated; Use order.customer.device.ipAddress instead.  The IP Address of the customer that is making the payment
+        """
+        return self.__customer_ip_address
+
+    @customer_ip_address.setter
+    def customer_ip_address(self, value: Optional[str]) -> None:
+        self.__customer_ip_address = value
+
+    @property
+    def product_categories(self) -> Optional[List[str]]:
+        """
+        | List of product categories that are being purchased.
+
+        Type: list[str]
+        """
+        return self.__product_categories
+
+    @product_categories.setter
+    def product_categories(self, value: Optional[List[str]]) -> None:
+        self.__product_categories = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FraudFields, self).to_dictionary()
+        if self.black_list_data is not None:
+            dictionary['blackListData'] = self.black_list_data
+        if self.customer_ip_address is not None:
+            dictionary['customerIpAddress'] = self.customer_ip_address
+        if self.product_categories is not None:
+            dictionary['productCategories'] = []
+            for element in self.product_categories:
+                if element is not None:
+                    dictionary['productCategories'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FraudFields':
+        super(FraudFields, self).from_dictionary(dictionary)
+        if 'blackListData' in dictionary:
+            self.black_list_data = dictionary['blackListData']
+        if 'customerIpAddress' in dictionary:
+            self.customer_ip_address = dictionary['customerIpAddress']
+        if 'productCategories' in dictionary:
+            if not isinstance(dictionary['productCategories'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['productCategories']))
+            self.product_categories = []
+            for element in dictionary['productCategories']:
+                self.product_categories.append(element)
+        return self

onlinepayments/sdk/domain/fraud_results.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class FraudResults(DataObject):
+
+    __fraud_service_result: Optional[str] = None
+
+    @property
+    def fraud_service_result(self) -> Optional[str]:
+        """
+        | Resulting advice of the fraud prevention checks. Possible values are:
+        
+        * accepted - Based on the checks performed the transaction can be accepted
+        * challenged - Based on the checks performed the transaction should be manually reviewed
+        * denied - Based on the checks performed the transaction should be rejected
+        * no-advice - No fraud check was requested/performed
+        * error - The fraud check resulted an error. Note that the fraud check was thus not performed.
+
+        Type: str
+        """
+        return self.__fraud_service_result
+
+    @fraud_service_result.setter
+    def fraud_service_result(self, value: Optional[str]) -> None:
+        self.__fraud_service_result = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FraudResults, self).to_dictionary()
+        if self.fraud_service_result is not None:
+            dictionary['fraudServiceResult'] = self.fraud_service_result
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FraudResults':
+        super(FraudResults, self).from_dictionary(dictionary)
+        if 'fraudServiceResult' in dictionary:
+            self.fraud_service_result = dictionary['fraudServiceResult']
+        return self

onlinepayments/sdk/domain/g_pay_three_d_secure.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .redirection_data import RedirectionData
+
+
+class GPayThreeDSecure(DataObject):
+
+    __challenge_canvas_size: Optional[str] = None
+    __challenge_indicator: Optional[str] = None
+    __exemption_request: Optional[str] = None
+    __redirection_data: Optional[RedirectionData] = None
+    __skip_authentication: Optional[bool] = None
+    __skip_soft_decline: Optional[bool] = None
+
+    @property
+    def challenge_canvas_size(self) -> Optional[str]:
+        """
+        | Dimensions of the challenge window that potentially will be displayed to the customer. The challenge content is formatted to appropriately render in this window to provide the best possible user experience. Preconfigured sizes are width x height in pixels of the window displayed in the customer browser window. Possible values are
+        
+        * 250x400 (default)
+        * 390x400
+        * 500x600
+        * 600x400
+        * full-screen
+
+        Type: str
+        """
+        return self.__challenge_canvas_size
+
+    @challenge_canvas_size.setter
+    def challenge_canvas_size(self, value: Optional[str]) -> None:
+        self.__challenge_canvas_size = value
+
+    @property
+    def challenge_indicator(self) -> Optional[str]:
+        """
+        | Allows you to indicate if you want the customer to be challenged for extra security on this transaction. Possible values:
+        
+        * no-preference - You have no preference whether or not to challenge the customer (default)
+        * no-challenge-requested - you prefer the cardholder not to be challenged
+        * challenge-requested - you prefer the customer to be challenged
+        * challenge-required - you require the customer to be challenged
+        * no-challenge-requested-risk-analysis-performed – letting the issuer know that you have already assessed the transaction with fraud prevention tool
+        * no-challenge-requested-data-share-only – sharing data only with the DS
+        * no-challenge-requested-consumer-authentication-performed – authentication already happened at your side – when login in to your website
+        * no-challenge-requested-use-whitelist-exemption – cardholder has whitelisted you at with the issuer
+        * challenge-requested-whitelist-prompt-requested – cardholder is trying to whitelist you
+        * request-scoring-without-connecting-to-acs – sending information to CB DS for a fraud scoring
+
+        Type: str
+        """
+        return self.__challenge_indicator
+
+    @challenge_indicator.setter
+    def challenge_indicator(self, value: Optional[str]) -> None:
+        self.__challenge_indicator = value
+
+    @property
+    def exemption_request(self) -> Optional[str]:
+        """
+        | In PSD2, the ExemptionRequest field is used by merchants requesting an exemption when not using authentication on a transaction, in order to keep the conversion up.
+        
+        * none = No exemption requested
+        * transaction-risk-analysis = Fraud analysis has been done already by your own fraud module and transaction scored as low risk
+        * low-value = Bellow 30 euros
+        * whitelist = The cardholder has whitelisted you with their issuer
+
+        Type: str
+        """
+        return self.__exemption_request
+
+    @exemption_request.setter
+    def exemption_request(self, value: Optional[str]) -> None:
+        self.__exemption_request = value
+
+    @property
+    def redirection_data(self) -> Optional[RedirectionData]:
+        """
+        | Object containing browser specific redirection related data
+
+        Type: :class:`onlinepayments.sdk.domain.redirection_data.RedirectionData`
+        """
+        return self.__redirection_data
+
+    @redirection_data.setter
+    def redirection_data(self, value: Optional[RedirectionData]) -> None:
+        self.__redirection_data = value
+
+    @property
+    def skip_authentication(self) -> Optional[bool]:
+        """
+        * true = 3D Secure authentication will be skipped for this transaction. This setting should be used when isRecurring is set to true and recurringPaymentSequenceIndicator is set to "recurring"
+        * false = 3D Secure authentication will not be skipped for this transaction
+        
+        | Note: This is only possible if your account in our system is setup for 3D Secure authentication and if your configuration in our system allows you to override it per transaction
+
+        Type: bool
+        """
+        return self.__skip_authentication
+
+    @skip_authentication.setter
+    def skip_authentication(self, value: Optional[bool]) -> None:
+        self.__skip_authentication = value
+
+    @property
+    def skip_soft_decline(self) -> Optional[bool]:
+        """
+        * true = Soft Decline retry mechanism will be skipped for this transaction. The transaction will result in "Authorization Declined" status. This setting should be used when skipAuthentication is set to true and the merchant does not want to use Soft Decline retry mechanism.
+        * false = Soft Decline retry mechanism will not be skipped for this transaction.
+        
+        | Note: skipSoftDecline defaults to false if empty. This is only possible if your account in our system is setup for 3D Secure authentication and if your configuration in our system allows you to override it per transaction.
+
+        Type: bool
+        """
+        return self.__skip_soft_decline
+
+    @skip_soft_decline.setter
+    def skip_soft_decline(self, value: Optional[bool]) -> None:
+        self.__skip_soft_decline = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GPayThreeDSecure, self).to_dictionary()
+        if self.challenge_canvas_size is not None:
+            dictionary['challengeCanvasSize'] = self.challenge_canvas_size
+        if self.challenge_indicator is not None:
+            dictionary['challengeIndicator'] = self.challenge_indicator
+        if self.exemption_request is not None:
+            dictionary['exemptionRequest'] = self.exemption_request
+        if self.redirection_data is not None:
+            dictionary['redirectionData'] = self.redirection_data.to_dictionary()
+        if self.skip_authentication is not None:
+            dictionary['skipAuthentication'] = self.skip_authentication
+        if self.skip_soft_decline is not None:
+            dictionary['skipSoftDecline'] = self.skip_soft_decline
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GPayThreeDSecure':
+        super(GPayThreeDSecure, self).from_dictionary(dictionary)
+        if 'challengeCanvasSize' in dictionary:
+            self.challenge_canvas_size = dictionary['challengeCanvasSize']
+        if 'challengeIndicator' in dictionary:
+            self.challenge_indicator = dictionary['challengeIndicator']
+        if 'exemptionRequest' in dictionary:
+            self.exemption_request = dictionary['exemptionRequest']
+        if 'redirectionData' in dictionary:
+            if not isinstance(dictionary['redirectionData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectionData']))
+            value = RedirectionData()
+            self.redirection_data = value.from_dictionary(dictionary['redirectionData'])
+        if 'skipAuthentication' in dictionary:
+            self.skip_authentication = dictionary['skipAuthentication']
+        if 'skipSoftDecline' in dictionary:
+            self.skip_soft_decline = dictionary['skipSoftDecline']
+        return self