connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/customer_account.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 typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.customer_account_authentication import CustomerAccountAuthentication
-from worldline.connect.sdk.v1.domain.customer_payment_activity import CustomerPaymentActivity
-from worldline.connect.sdk.v1.domain.payment_account_on_file import PaymentAccountOnFile
-
-
-class CustomerAccount(DataObject):
-    """
-    | Object containing data related to the account the customer has with you
-    """
-
-    __authentication: Optional[CustomerAccountAuthentication] = None
-    __change_date: Optional[str] = None
-    __changed_during_checkout: Optional[bool] = None
-    __create_date: Optional[str] = None
-    __had_suspicious_activity: Optional[bool] = None
-    __has_forgotten_password: Optional[bool] = None
-    __has_password: Optional[bool] = None
-    __password_change_date: Optional[str] = None
-    __password_changed_during_checkout: Optional[bool] = None
-    __payment_account_on_file: Optional[PaymentAccountOnFile] = None
-    __payment_account_on_file_type: Optional[str] = None
-    __payment_activity: Optional[CustomerPaymentActivity] = None
-
-    @property
-    def authentication(self) -> Optional[CustomerAccountAuthentication]:
-        """
-        | Object containing data on the authentication used by the customer to access their account
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.customer_account_authentication.CustomerAccountAuthentication`
-        """
-        return self.__authentication
-
-    @authentication.setter
-    def authentication(self, value: Optional[CustomerAccountAuthentication]) -> None:
-        self.__authentication = value
-
-    @property
-    def change_date(self) -> Optional[str]:
-        """
-        | The last date (YYYYMMDD) on which the customer made changes to their account with you. These are changes to billing & shipping address details, new payment account (tokens), or new users(s) added.
-        
-        Type: str
-        """
-        return self.__change_date
-
-    @change_date.setter
-    def change_date(self, value: Optional[str]) -> None:
-        self.__change_date = value
-
-    @property
-    def changed_during_checkout(self) -> Optional[bool]:
-        """
-        | true = the customer made changes to their account during this checkout
-        
-        | false = the customer didn't change anything to their account during this checkout/n
-        
-        | The changes ment here are changes to billing & shipping address details, new payment account (tokens), or new users(s) added.
-        
-        Type: bool
-        """
-        return self.__changed_during_checkout
-
-    @changed_during_checkout.setter
-    def changed_during_checkout(self, value: Optional[bool]) -> None:
-        self.__changed_during_checkout = value
-
-    @property
-    def create_date(self) -> Optional[str]:
-        """
-        | The date (YYYYMMDD) on which the customer created their account with you
-        
-        Type: str
-        """
-        return self.__create_date
-
-    @create_date.setter
-    def create_date(self, value: Optional[str]) -> None:
-        self.__create_date = value
-
-    @property
-    def had_suspicious_activity(self) -> Optional[bool]:
-        """
-        | Specifies if you have experienced suspicious activity on the account of the customer
-        
-        | true = you have experienced suspicious activity (including previous fraud) on the customer account used for this transaction
-        
-        | false = you have experienced no suspicious activity (including previous fraud) on the customer account used for this transaction
-        
-        Type: bool
-        """
-        return self.__had_suspicious_activity
-
-    @had_suspicious_activity.setter
-    def had_suspicious_activity(self, value: Optional[bool]) -> None:
-        self.__had_suspicious_activity = value
-
-    @property
-    def has_forgotten_password(self) -> Optional[bool]:
-        """
-        | Specifies if the customer (initially) had forgotten their password
-        
-        * true - The customer has forgotten their password
-        * false - The customer has not forgotten their password
-        
-        Type: bool
-        """
-        return self.__has_forgotten_password
-
-    @has_forgotten_password.setter
-    def has_forgotten_password(self, value: Optional[bool]) -> None:
-        self.__has_forgotten_password = value
-
-    @property
-    def has_password(self) -> Optional[bool]:
-        """
-        | Specifies if the customer entered a password to gain access to an account registered with the you
-        
-        * true - The customer has used a password to gain access
-        * false - The customer has not used a password to gain access
-        
-        Type: bool
-        """
-        return self.__has_password
-
-    @has_password.setter
-    def has_password(self, value: Optional[bool]) -> None:
-        self.__has_password = value
-
-    @property
-    def password_change_date(self) -> Optional[str]:
-        """
-        | The last date (YYYYMMDD) on which the customer changed their password for the account used in this transaction
-        
-        Type: str
-        """
-        return self.__password_change_date
-
-    @password_change_date.setter
-    def password_change_date(self, value: Optional[str]) -> None:
-        self.__password_change_date = value
-
-    @property
-    def password_changed_during_checkout(self) -> Optional[bool]:
-        """
-        | Indicates if the password of an account is changed during this checkout
-        
-        | true = the customer made changes to their password of the account used during this checkout
-        
-        | alse = the customer didn't change anything to their password of the account used during this checkout
-        
-        Type: bool
-        """
-        return self.__password_changed_during_checkout
-
-    @password_changed_during_checkout.setter
-    def password_changed_during_checkout(self, value: Optional[bool]) -> None:
-        self.__password_changed_during_checkout = value
-
-    @property
-    def payment_account_on_file(self) -> Optional[PaymentAccountOnFile]:
-        """
-        | Object containing information on the payment account data on file (tokens)
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_account_on_file.PaymentAccountOnFile`
-        """
-        return self.__payment_account_on_file
-
-    @payment_account_on_file.setter
-    def payment_account_on_file(self, value: Optional[PaymentAccountOnFile]) -> None:
-        self.__payment_account_on_file = value
-
-    @property
-    def payment_account_on_file_type(self) -> Optional[str]:
-        """
-        | Indicates the type of account. For example, for a multi-account card product. 
-        
-        * not-applicable = the card used doesn't support multiple card products
-        * credit = the card used is a credit card
-        * debit = the card used is a debit card
-        
-        Type: str
-        """
-        return self.__payment_account_on_file_type
-
-    @payment_account_on_file_type.setter
-    def payment_account_on_file_type(self, value: Optional[str]) -> None:
-        self.__payment_account_on_file_type = value
-
-    @property
-    def payment_activity(self) -> Optional[CustomerPaymentActivity]:
-        """
-        | Object containing data on the purchase history of the customer with you
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.customer_payment_activity.CustomerPaymentActivity`
-        """
-        return self.__payment_activity
-
-    @payment_activity.setter
-    def payment_activity(self, value: Optional[CustomerPaymentActivity]) -> None:
-        self.__payment_activity = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(CustomerAccount, self).to_dictionary()
-        if self.authentication is not None:
-            dictionary['authentication'] = self.authentication.to_dictionary()
-        if self.change_date is not None:
-            dictionary['changeDate'] = self.change_date
-        if self.changed_during_checkout is not None:
-            dictionary['changedDuringCheckout'] = self.changed_during_checkout
-        if self.create_date is not None:
-            dictionary['createDate'] = self.create_date
-        if self.had_suspicious_activity is not None:
-            dictionary['hadSuspiciousActivity'] = self.had_suspicious_activity
-        if self.has_forgotten_password is not None:
-            dictionary['hasForgottenPassword'] = self.has_forgotten_password
-        if self.has_password is not None:
-            dictionary['hasPassword'] = self.has_password
-        if self.password_change_date is not None:
-            dictionary['passwordChangeDate'] = self.password_change_date
-        if self.password_changed_during_checkout is not None:
-            dictionary['passwordChangedDuringCheckout'] = self.password_changed_during_checkout
-        if self.payment_account_on_file is not None:
-            dictionary['paymentAccountOnFile'] = self.payment_account_on_file.to_dictionary()
-        if self.payment_account_on_file_type is not None:
-            dictionary['paymentAccountOnFileType'] = self.payment_account_on_file_type
-        if self.payment_activity is not None:
-            dictionary['paymentActivity'] = self.payment_activity.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'CustomerAccount':
-        super(CustomerAccount, self).from_dictionary(dictionary)
-        if 'authentication' in dictionary:
-            if not isinstance(dictionary['authentication'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['authentication']))
-            value = CustomerAccountAuthentication()
-            self.authentication = value.from_dictionary(dictionary['authentication'])
-        if 'changeDate' in dictionary:
-            self.change_date = dictionary['changeDate']
-        if 'changedDuringCheckout' in dictionary:
-            self.changed_during_checkout = dictionary['changedDuringCheckout']
-        if 'createDate' in dictionary:
-            self.create_date = dictionary['createDate']
-        if 'hadSuspiciousActivity' in dictionary:
-            self.had_suspicious_activity = dictionary['hadSuspiciousActivity']
-        if 'hasForgottenPassword' in dictionary:
-            self.has_forgotten_password = dictionary['hasForgottenPassword']
-        if 'hasPassword' in dictionary:
-            self.has_password = dictionary['hasPassword']
-        if 'passwordChangeDate' in dictionary:
-            self.password_change_date = dictionary['passwordChangeDate']
-        if 'passwordChangedDuringCheckout' in dictionary:
-            self.password_changed_during_checkout = dictionary['passwordChangedDuringCheckout']
-        if 'paymentAccountOnFile' in dictionary:
-            if not isinstance(dictionary['paymentAccountOnFile'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentAccountOnFile']))
-            value = PaymentAccountOnFile()
-            self.payment_account_on_file = value.from_dictionary(dictionary['paymentAccountOnFile'])
-        if 'paymentAccountOnFileType' in dictionary:
-            self.payment_account_on_file_type = dictionary['paymentAccountOnFileType']
-        if 'paymentActivity' in dictionary:
-            if not isinstance(dictionary['paymentActivity'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentActivity']))
-            value = CustomerPaymentActivity()
-            self.payment_activity = value.from_dictionary(dictionary['paymentActivity'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/customer_account_authentication.py

@@ -1,93 +0,0 @@
-# -*- 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 CustomerAccountAuthentication(DataObject):
-    """
-    | Object containing data on the authentication used by the customer to access their account
-    """
-
-    __data: Optional[str] = None
-    __method: Optional[str] = None
-    __utc_timestamp: Optional[str] = None
-
-    @property
-    def data(self) -> Optional[str]:
-        """
-        | Data that documents and supports a specific authentication process submitted using the order.customer.account.authentication.method property. The data submitted using this property will be used by the issuer to validate the used authentication method.
-        | For example, if the order.customer.account.authentication.method is:
-        
-        * federated-id, then this element can carry information about the provider of the federated ID and related information.
-        * fido-authentication, then this element can carry the FIDO attestation data (including the signature).
-        * fido-authentication-with-signed-assurance-data, then this element can carry FIDO Attestation data with the FIDO assurance data signed.
-        * src-assurance-data, then this element can carry the SRC assurance data
-        
-        Type: str
-        """
-        return self.__data
-
-    @data.setter
-    def data(self, value: Optional[str]) -> None:
-        self.__data = value
-
-    @property
-    def method(self) -> Optional[str]:
-        """
-        | Authentication used by the customer on your website or app
-        | Possible values :
-        
-        * guest = no login occurred, customer is 'logged in' as guest
-        * merchant-credentials = the customer logged in using credentials that are specific to you 
-        * federated-id = the customer logged in using a federated ID
-        * issuer-credentials = the customer logged in using credentials from the card issuer (of the card used in this transaction)
-        * third-party-authentication = the customer logged in using third-party authentication
-        * fido-authentication = the customer logged in using a FIDO authenticator
-        * fido-authentication-with-signed-assurance-data = the customer logged in using a FIDO authenticator which also provides signed assurance data
-        * src-assurance-data = the customer authenticated themselves during a Secure Remote Commerce session
-        
-        Type: str
-        """
-        return self.__method
-
-    @method.setter
-    def method(self, value: Optional[str]) -> None:
-        self.__method = value
-
-    @property
-    def utc_timestamp(self) -> Optional[str]:
-        """
-        | Timestamp (YYYYMMDDHHmm) of the authentication of the customer to their account with you
-        
-        Type: str
-        """
-        return self.__utc_timestamp
-
-    @utc_timestamp.setter
-    def utc_timestamp(self, value: Optional[str]) -> None:
-        self.__utc_timestamp = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(CustomerAccountAuthentication, self).to_dictionary()
-        if self.data is not None:
-            dictionary['data'] = self.data
-        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: dict) -> 'CustomerAccountAuthentication':
-        super(CustomerAccountAuthentication, self).from_dictionary(dictionary)
-        if 'data' in dictionary:
-            self.data = dictionary['data']
-        if 'method' in dictionary:
-            self.method = dictionary['method']
-        if 'utcTimestamp' in dictionary:
-            self.utc_timestamp = dictionary['utcTimestamp']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/customer_account_risk_assessment.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 typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class CustomerAccountRiskAssessment(DataObject):
-    """
-    | Object containing data related to the account the customer has with you
-    """
-
-    __has_forgotten_password: Optional[bool] = None
-    __has_password: Optional[bool] = None
-
-    @property
-    def has_forgotten_password(self) -> Optional[bool]:
-        """
-        | Specifies if the customer (initially) had forgotten their password
-        
-        * true - The customer has forgotten their password
-        * false - The customer has not forgotten their password
-        
-        Type: bool
-        """
-        return self.__has_forgotten_password
-
-    @has_forgotten_password.setter
-    def has_forgotten_password(self, value: Optional[bool]) -> None:
-        self.__has_forgotten_password = value
-
-    @property
-    def has_password(self) -> Optional[bool]:
-        """
-        | Specifies if the customer entered a password to gain access to an account registered with the you
-        
-        * true - The customer has used a password to gain access
-        * false - The customer has not used a password to gain access
-        
-        Type: bool
-        """
-        return self.__has_password
-
-    @has_password.setter
-    def has_password(self, value: Optional[bool]) -> None:
-        self.__has_password = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(CustomerAccountRiskAssessment, self).to_dictionary()
-        if self.has_forgotten_password is not None:
-            dictionary['hasForgottenPassword'] = self.has_forgotten_password
-        if self.has_password is not None:
-            dictionary['hasPassword'] = self.has_password
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'CustomerAccountRiskAssessment':
-        super(CustomerAccountRiskAssessment, self).from_dictionary(dictionary)
-        if 'hasForgottenPassword' in dictionary:
-            self.has_forgotten_password = dictionary['hasForgottenPassword']
-        if 'hasPassword' in dictionary:
-            self.has_password = dictionary['hasPassword']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/customer_approve_payment.py

@@ -1,42 +0,0 @@
-# -*- 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 CustomerApprovePayment(DataObject):
-
-    __account_type: Optional[str] = None
-
-    @property
-    def account_type(self) -> Optional[str]:
-        """
-        | Type of the customer account that is used to place this order. Can have one of the following values:
-        
-        * none - The account that was used to place the order is a guest account or no account was used at all
-        * created - The customer account was created during this transaction
-        * existing - The customer account was an already existing account prior to this transaction
-        
-        Type: str
-        """
-        return self.__account_type
-
-    @account_type.setter
-    def account_type(self, value: Optional[str]) -> None:
-        self.__account_type = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(CustomerApprovePayment, self).to_dictionary()
-        if self.account_type is not None:
-            dictionary['accountType'] = self.account_type
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'CustomerApprovePayment':
-        super(CustomerApprovePayment, self).from_dictionary(dictionary)
-        if 'accountType' in dictionary:
-            self.account_type = dictionary['accountType']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/customer_base.py

@@ -1,83 +0,0 @@
-# -*- 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
-from worldline.connect.sdk.v1.domain.company_information import CompanyInformation
-
-
-class CustomerBase(DataObject):
-    """
-    | Basic information of a customer
-    """
-
-    __company_information: Optional[CompanyInformation] = None
-    __merchant_customer_id: Optional[str] = None
-    __vat_number: Optional[str] = None
-
-    @property
-    def company_information(self) -> Optional[CompanyInformation]:
-        """
-        | Object containing company information
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.company_information.CompanyInformation`
-        """
-        return self.__company_information
-
-    @company_information.setter
-    def company_information(self, value: Optional[CompanyInformation]) -> None:
-        self.__company_information = value
-
-    @property
-    def merchant_customer_id(self) -> Optional[str]:
-        """
-        | Your identifier for the customer. It can be used as a search criteria in the GlobalCollect Payment Console and is also included in the GlobalCollect report files. It is used in the fraud-screening process for payments on the Ogone Payment Platform.
-        
-        Type: str
-        """
-        return self.__merchant_customer_id
-
-    @merchant_customer_id.setter
-    def merchant_customer_id(self, value: Optional[str]) -> None:
-        self.__merchant_customer_id = value
-
-    @property
-    def vat_number(self) -> Optional[str]:
-        """
-        | Local VAT number of the company
-        
-        Type: str
-        
-        Deprecated; Use companyInformation.vatNumber instead
-        """
-        return self.__vat_number
-
-    @vat_number.setter
-    def vat_number(self, value: Optional[str]) -> None:
-        self.__vat_number = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(CustomerBase, self).to_dictionary()
-        if self.company_information is not None:
-            dictionary['companyInformation'] = self.company_information.to_dictionary()
-        if self.merchant_customer_id is not None:
-            dictionary['merchantCustomerId'] = self.merchant_customer_id
-        if self.vat_number is not None:
-            dictionary['vatNumber'] = self.vat_number
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'CustomerBase':
-        super(CustomerBase, self).from_dictionary(dictionary)
-        if 'companyInformation' in dictionary:
-            if not isinstance(dictionary['companyInformation'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['companyInformation']))
-            value = CompanyInformation()
-            self.company_information = value.from_dictionary(dictionary['companyInformation'])
-        if 'merchantCustomerId' in dictionary:
-            self.merchant_customer_id = dictionary['merchantCustomerId']
-        if 'vatNumber' in dictionary:
-            self.vat_number = dictionary['vatNumber']
-        return self