connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/customer_account.py

@@ -0,0 +1,273 @@
+# -*- 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.1.0/worldline/connect/sdk/v1/domain/customer_account_authentication.py

@@ -0,0 +1,93 @@
+# -*- 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.1.0/worldline/connect/sdk/v1/domain/customer_account_risk_assessment.py

@@ -0,0 +1,65 @@
+# -*- 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.1.0/worldline/connect/sdk/v1/domain/customer_approve_payment.py

@@ -0,0 +1,42 @@
+# -*- 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.1.0/worldline/connect/sdk/v1/domain/customer_base.py

@@ -0,0 +1,83 @@
+# -*- 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