Source code for worldline.connect.sdk.v1.domain.external_cardholder_authentication_data

# -*- coding: utf-8 -*-
#
# This class was auto-generated from the API references found at
# https://apireference.connect.worldline-solutions.com/
#
from typing import Optional

from worldline.connect.sdk.domain.data_object import DataObject




class ExternalCardholderAuthenticationData(DataObject):
    """
    | Object containing 3D secure details.
    """

    __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
    __scheme_risk_score: Optional[int] = None
    __three_d_secure_version: Optional[str] = None
    __three_d_server_transaction_id: Optional[str] = None
    __validation_result: 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]:
        """
        | When you request an exemptions via your non-Worldline 3D Secure provider successfully, you need to provide in this property the exemption that was granted, in combination with all 3DS results given by issuer.
        | Possible values:
        
        * transaction-risk-analysis - You have determined that this transaction is of low risk and are willing to take the liability. Please note that your fraud rate needs to stay below thresholds to allow your use of this exemption.
        * low-value - The value of the transaction is below 30 EUR. Please note that the issuer will still require every 5th low-value transaction pithing 24 hours to be strongly authenticated. The issuer will also keep track of the cumulative amount authorized on the card. When this exceeds 100 EUR strong customer authentication is also required.
        * whitelist - You have been whitelisted by the customer at the issuer.

        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.

        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.

        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

        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 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
        * 2.3
        * 2.3.0
        * 2.3.1
        * 2.3.1.1

        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 three_d_server_transaction_id(self) -> Optional[str]:
        """
        | The 3-D Secure Server transaction ID that is used for the 3-D Secure version 2 Authentication.

        Type: str

        Deprecated; No replacement
        """
        return self.__three_d_server_transaction_id

    @three_d_server_transaction_id.setter
    def three_d_server_transaction_id(self, value: Optional[str]) -> None:
        self.__three_d_server_transaction_id = value

    @property
    def validation_result(self) -> Optional[str]:
        """
        | The 3D Secure authentication result from your 3D Secure provider.

        Type: str
        """
        return self.__validation_result

    @validation_result.setter
    def validation_result(self, value: Optional[str]) -> None:
        self.__validation_result = 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.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.three_d_server_transaction_id is not None:
            dictionary['threeDServerTransactionId'] = self.three_d_server_transaction_id
        if self.validation_result is not None:
            dictionary['validationResult'] = self.validation_result
        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 'schemeRiskScore' in dictionary:
            self.scheme_risk_score = dictionary['schemeRiskScore']
        if 'threeDSecureVersion' in dictionary:
            self.three_d_secure_version = dictionary['threeDSecureVersion']
        if 'threeDServerTransactionId' in dictionary:
            self.three_d_server_transaction_id = dictionary['threeDServerTransactionId']
        if 'validationResult' in dictionary:
            self.validation_result = dictionary['validationResult']
        if 'xid' in dictionary:
            self.xid = dictionary['xid']
        return self