connect-sdk-python2 4.0.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/third_party_status_response.py

@@ -1,41 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class ThirdPartyStatusResponse(DataObject):
-
-    __third_party_status = None
-
-    @property
-    def third_party_status(self):
-        """
-        | The status returned by the third party.Possible values:
-        
-        * WAITING - The customer has not connected to the third party
-        * INITIALIZED - Authentication in progress
-        * AUTHORIZED - Payment in progress
-        * COMPLETED - The customer has completed the payment at the third party
-        
-        Type: str
-        """
-        return self.__third_party_status
-
-    @third_party_status.setter
-    def third_party_status(self, value):
-        self.__third_party_status = value
-
-    def to_dictionary(self):
-        dictionary = super(ThirdPartyStatusResponse, self).to_dictionary()
-        if self.third_party_status is not None:
-            dictionary['thirdPartyStatus'] = self.third_party_status
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ThirdPartyStatusResponse, self).from_dictionary(dictionary)
-        if 'thirdPartyStatus' in dictionary:
-            self.third_party_status = dictionary['thirdPartyStatus']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/three_d_secure.py

@@ -1,65 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.v1.domain.abstract_three_d_secure import AbstractThreeDSecure
-from worldline.connect.sdk.v1.domain.external_cardholder_authentication_data import ExternalCardholderAuthenticationData
-from worldline.connect.sdk.v1.domain.redirection_data import RedirectionData
-
-
-class ThreeDSecure(AbstractThreeDSecure):
-    """
-    | Object containing specific data regarding 3-D Secure
-    """
-
-    __external_cardholder_authentication_data = None
-    __redirection_data = None
-
-    @property
-    def external_cardholder_authentication_data(self):
-        """
-        | Object containing 3D secure details.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.external_cardholder_authentication_data.ExternalCardholderAuthenticationData`
-        """
-        return self.__external_cardholder_authentication_data
-
-    @external_cardholder_authentication_data.setter
-    def external_cardholder_authentication_data(self, value):
-        self.__external_cardholder_authentication_data = value
-
-    @property
-    def redirection_data(self):
-        """
-        | Object containing browser specific redirection related data
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.redirection_data.RedirectionData`
-        """
-        return self.__redirection_data
-
-    @redirection_data.setter
-    def redirection_data(self, value):
-        self.__redirection_data = value
-
-    def to_dictionary(self):
-        dictionary = super(ThreeDSecure, self).to_dictionary()
-        if self.external_cardholder_authentication_data is not None:
-            dictionary['externalCardholderAuthenticationData'] = self.external_cardholder_authentication_data.to_dictionary()
-        if self.redirection_data is not None:
-            dictionary['redirectionData'] = self.redirection_data.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ThreeDSecure, self).from_dictionary(dictionary)
-        if 'externalCardholderAuthenticationData' in dictionary:
-            if not isinstance(dictionary['externalCardholderAuthenticationData'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['externalCardholderAuthenticationData']))
-            value = ExternalCardholderAuthenticationData()
-            self.external_cardholder_authentication_data = value.from_dictionary(dictionary['externalCardholderAuthenticationData'])
-        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'])
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/three_d_secure_data.py

@@ -1,80 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class ThreeDSecureData(DataObject):
-    """
-    | Object containing data regarding the 3D Secure authentication
-    """
-
-    __acs_transaction_id = None
-    __method = None
-    __utc_timestamp = None
-
-    @property
-    def acs_transaction_id(self):
-        """
-        | The ACS Transaction ID for a prior 3-D Secure authenticated transaction (for example, the first recurring transaction that was authenticated with the customer)
-        
-        Type: str
-        """
-        return self.__acs_transaction_id
-
-    @acs_transaction_id.setter
-    def acs_transaction_id(self, value):
-        self.__acs_transaction_id = value
-
-    @property
-    def method(self):
-        """
-        | Method of authentication used for this transaction.Possible values:
-        
-        * frictionless = The authentication went without a challenge
-        * challenged = Cardholder was challenged
-        * avs-verified = The authentication was verified by AVS
-        * other = Another issuer method was used to authenticate this transaction
-        
-        Type: str
-        """
-        return self.__method
-
-    @method.setter
-    def method(self, value):
-        self.__method = value
-
-    @property
-    def utc_timestamp(self):
-        """
-        | Timestamp in UTC (YYYYMMDDHHmm) of the 3-D Secure authentication of this transaction
-        
-        Type: str
-        """
-        return self.__utc_timestamp
-
-    @utc_timestamp.setter
-    def utc_timestamp(self, value):
-        self.__utc_timestamp = value
-
-    def to_dictionary(self):
-        dictionary = super(ThreeDSecureData, self).to_dictionary()
-        if self.acs_transaction_id is not None:
-            dictionary['acsTransactionId'] = self.acs_transaction_id
-        if self.method is not None:
-            dictionary['method'] = self.method
-        if self.utc_timestamp is not None:
-            dictionary['utcTimestamp'] = self.utc_timestamp
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ThreeDSecureData, self).from_dictionary(dictionary)
-        if 'acsTransactionId' in dictionary:
-            self.acs_transaction_id = dictionary['acsTransactionId']
-        if 'method' in dictionary:
-            self.method = dictionary['method']
-        if 'utcTimestamp' in dictionary:
-            self.utc_timestamp = dictionary['utcTimestamp']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/three_d_secure_results.py

@@ -1,273 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
-from worldline.connect.sdk.v1.domain.exemption_output import ExemptionOutput
-from worldline.connect.sdk.v1.domain.sdk_data_output import SdkDataOutput
-from worldline.connect.sdk.v1.domain.three_d_secure_data import ThreeDSecureData
-
-
-class ThreeDSecureResults(DataObject):
-    """
-    | Object containing the 3-D Secure specific results
-    """
-
-    __acs_transaction_id = None
-    __applied_exemption = None
-    __authentication_amount = None
-    __cavv = None
-    __directory_server_transaction_id = None
-    __eci = None
-    __exemption_output = None
-    __scheme_risk_score = None
-    __sdk_data = None
-    __three_d_secure_data = None
-    __three_d_secure_version = None
-    __three_d_server_transaction_id = None
-    __xid = None
-
-    @property
-    def acs_transaction_id(self):
-        """
-        | 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):
-        self.__acs_transaction_id = value
-
-    @property
-    def applied_exemption(self):
-        """
-        | 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):
-        self.__applied_exemption = value
-
-    @property
-    def authentication_amount(self):
-        """
-        | The amount for which this transaction has been authenticated.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
-        """
-        return self.__authentication_amount
-
-    @authentication_amount.setter
-    def authentication_amount(self, value):
-        self.__authentication_amount = value
-
-    @property
-    def cavv(self):
-        """
-        | CAVV or AVV result indicating authentication validation value
-        
-        Type: str
-        """
-        return self.__cavv
-
-    @cavv.setter
-    def cavv(self, value):
-        self.__cavv = value
-
-    @property
-    def directory_server_transaction_id(self):
-        """
-        | 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):
-        self.__directory_server_transaction_id = value
-
-    @property
-    def eci(self):
-        """
-        | Indicates Authentication validation results returned after AuthenticationValidation
-        
-        Type: str
-        """
-        return self.__eci
-
-    @eci.setter
-    def eci(self, value):
-        self.__eci = value
-
-    @property
-    def exemption_output(self):
-        """
-        | Object containing exemption output
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.exemption_output.ExemptionOutput`
-        """
-        return self.__exemption_output
-
-    @exemption_output.setter
-    def exemption_output(self, value):
-        self.__exemption_output = value
-
-    @property
-    def scheme_risk_score(self):
-        """
-        | 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):
-        self.__scheme_risk_score = value
-
-    @property
-    def sdk_data(self):
-        """
-        | Object containing 3-D Secure in-app SDK data
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.sdk_data_output.SdkDataOutput`
-        """
-        return self.__sdk_data
-
-    @sdk_data.setter
-    def sdk_data(self, value):
-        self.__sdk_data = value
-
-    @property
-    def three_d_secure_data(self):
-        """
-        | Object containing data regarding the 3-D Secure authentication
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.three_d_secure_data.ThreeDSecureData`
-        """
-        return self.__three_d_secure_data
-
-    @three_d_secure_data.setter
-    def three_d_secure_data(self, value):
-        self.__three_d_secure_data = value
-
-    @property
-    def three_d_secure_version(self):
-        """
-        | The 3-D Secure version used for the authentication.
-        
-        | This property is used in the communication with the acquirer
-        
-        Type: str
-        """
-        return self.__three_d_secure_version
-
-    @three_d_secure_version.setter
-    def three_d_secure_version(self, value):
-        self.__three_d_secure_version = value
-
-    @property
-    def three_d_server_transaction_id(self):
-        """
-        | The 3-D Secure Server transaction ID that is used for the 3-D Secure version 2 Authentication.
-        
-        Type: str
-        """
-        return self.__three_d_server_transaction_id
-
-    @three_d_server_transaction_id.setter
-    def three_d_server_transaction_id(self, value):
-        self.__three_d_server_transaction_id = value
-
-    @property
-    def xid(self):
-        """
-        | Transaction ID for the Authentication
-        
-        Type: str
-        """
-        return self.__xid
-
-    @xid.setter
-    def xid(self, value):
-        self.__xid = value
-
-    def to_dictionary(self):
-        dictionary = super(ThreeDSecureResults, 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.authentication_amount is not None:
-            dictionary['authenticationAmount'] = self.authentication_amount.to_dictionary()
-        if self.cavv is not None:
-            dictionary['cavv'] = self.cavv
-        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.exemption_output is not None:
-            dictionary['exemptionOutput'] = self.exemption_output.to_dictionary()
-        if self.scheme_risk_score is not None:
-            dictionary['schemeRiskScore'] = self.scheme_risk_score
-        if self.sdk_data is not None:
-            dictionary['sdkData'] = self.sdk_data.to_dictionary()
-        if self.three_d_secure_data is not None:
-            dictionary['threeDSecureData'] = self.three_d_secure_data.to_dictionary()
-        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.xid is not None:
-            dictionary['xid'] = self.xid
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ThreeDSecureResults, self).from_dictionary(dictionary)
-        if 'acsTransactionId' in dictionary:
-            self.acs_transaction_id = dictionary['acsTransactionId']
-        if 'appliedExemption' in dictionary:
-            self.applied_exemption = dictionary['appliedExemption']
-        if 'authenticationAmount' in dictionary:
-            if not isinstance(dictionary['authenticationAmount'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['authenticationAmount']))
-            value = AmountOfMoney()
-            self.authentication_amount = value.from_dictionary(dictionary['authenticationAmount'])
-        if 'cavv' in dictionary:
-            self.cavv = dictionary['cavv']
-        if 'directoryServerTransactionId' in dictionary:
-            self.directory_server_transaction_id = dictionary['directoryServerTransactionId']
-        if 'eci' in dictionary:
-            self.eci = dictionary['eci']
-        if 'exemptionOutput' in dictionary:
-            if not isinstance(dictionary['exemptionOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exemptionOutput']))
-            value = ExemptionOutput()
-            self.exemption_output = value.from_dictionary(dictionary['exemptionOutput'])
-        if 'schemeRiskScore' in dictionary:
-            self.scheme_risk_score = dictionary['schemeRiskScore']
-        if 'sdkData' in dictionary:
-            if not isinstance(dictionary['sdkData'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sdkData']))
-            value = SdkDataOutput()
-            self.sdk_data = value.from_dictionary(dictionary['sdkData'])
-        if 'threeDSecureData' in dictionary:
-            if not isinstance(dictionary['threeDSecureData'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecureData']))
-            value = ThreeDSecureData()
-            self.three_d_secure_data = value.from_dictionary(dictionary['threeDSecureData'])
-        if 'threeDSecureVersion' in dictionary:
-            self.three_d_secure_version = dictionary['threeDSecureVersion']
-        if 'threeDServerTransactionId' in dictionary:
-            self.three_d_server_transaction_id = dictionary['threeDServerTransactionId']
-        if 'xid' in dictionary:
-            self.xid = dictionary['xid']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/token_card.py

@@ -1,62 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.v1.domain.abstract_token import AbstractToken
-from worldline.connect.sdk.v1.domain.customer_token import CustomerToken
-from worldline.connect.sdk.v1.domain.token_card_data import TokenCardData
-
-
-class TokenCard(AbstractToken):
-
-    __customer = None
-    __data = None
-
-    @property
-    def customer(self):
-        """
-        | Object containing the details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.customer_token.CustomerToken`
-        """
-        return self.__customer
-
-    @customer.setter
-    def customer(self, value):
-        self.__customer = value
-
-    @property
-    def data(self):
-        """
-        | Object containing the card tokenizable details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_card_data.TokenCardData`
-        """
-        return self.__data
-
-    @data.setter
-    def data(self, value):
-        self.__data = value
-
-    def to_dictionary(self):
-        dictionary = super(TokenCard, self).to_dictionary()
-        if self.customer is not None:
-            dictionary['customer'] = self.customer.to_dictionary()
-        if self.data is not None:
-            dictionary['data'] = self.data.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(TokenCard, self).from_dictionary(dictionary)
-        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'])
-        if 'data' in dictionary:
-            if not isinstance(dictionary['data'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['data']))
-            value = TokenCardData()
-            self.data = value.from_dictionary(dictionary['data'])
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/token_card_data.py

@@ -1,77 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.card_without_cvv import CardWithoutCvv
-
-
-class TokenCardData(DataObject):
-
-    __card_without_cvv = None
-    __first_transaction_date = None
-    __provider_reference = None
-
-    @property
-    def card_without_cvv(self):
-        """
-        | Object containing the card details (without CVV)
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.card_without_cvv.CardWithoutCvv`
-        """
-        return self.__card_without_cvv
-
-    @card_without_cvv.setter
-    def card_without_cvv(self, value):
-        self.__card_without_cvv = value
-
-    @property
-    def first_transaction_date(self):
-        """
-        | Date of the first transaction (for ATOS)
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__first_transaction_date
-
-    @first_transaction_date.setter
-    def first_transaction_date(self, value):
-        self.__first_transaction_date = value
-
-    @property
-    def provider_reference(self):
-        """
-        | Reference of the provider (of the first transaction) - used to store the ATOS Transaction Certificate
-        
-        Type: str
-        """
-        return self.__provider_reference
-
-    @provider_reference.setter
-    def provider_reference(self, value):
-        self.__provider_reference = value
-
-    def to_dictionary(self):
-        dictionary = super(TokenCardData, self).to_dictionary()
-        if self.card_without_cvv is not None:
-            dictionary['cardWithoutCvv'] = self.card_without_cvv.to_dictionary()
-        if self.first_transaction_date is not None:
-            dictionary['firstTransactionDate'] = self.first_transaction_date
-        if self.provider_reference is not None:
-            dictionary['providerReference'] = self.provider_reference
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(TokenCardData, self).from_dictionary(dictionary)
-        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 'firstTransactionDate' in dictionary:
-            self.first_transaction_date = dictionary['firstTransactionDate']
-        if 'providerReference' in dictionary:
-            self.provider_reference = dictionary['providerReference']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/token_e_wallet.py

@@ -1,62 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.v1.domain.abstract_token import AbstractToken
-from worldline.connect.sdk.v1.domain.customer_token import CustomerToken
-from worldline.connect.sdk.v1.domain.token_e_wallet_data import TokenEWalletData
-
-
-class TokenEWallet(AbstractToken):
-
-    __customer = None
-    __data = None
-
-    @property
-    def customer(self):
-        """
-        | Object containing the details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.customer_token.CustomerToken`
-        """
-        return self.__customer
-
-    @customer.setter
-    def customer(self, value):
-        self.__customer = value
-
-    @property
-    def data(self):
-        """
-        | Object containing the eWallet tokenizable data
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_e_wallet_data.TokenEWalletData`
-        """
-        return self.__data
-
-    @data.setter
-    def data(self, value):
-        self.__data = value
-
-    def to_dictionary(self):
-        dictionary = super(TokenEWallet, self).to_dictionary()
-        if self.customer is not None:
-            dictionary['customer'] = self.customer.to_dictionary()
-        if self.data is not None:
-            dictionary['data'] = self.data.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(TokenEWallet, self).from_dictionary(dictionary)
-        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'])
-        if 'data' in dictionary:
-            if not isinstance(dictionary['data'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['data']))
-            value = TokenEWalletData()
-            self.data = value.from_dictionary(dictionary['data'])
-        return self