connect-sdk-python2 4.0.0__zip → 4.1.0__zip

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/customer.py

@@ -0,0 +1,274 @@
+# -*- 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.address import Address
+from worldline.connect.sdk.v1.domain.address_personal import AddressPersonal
+from worldline.connect.sdk.v1.domain.contact_details import ContactDetails
+from worldline.connect.sdk.v1.domain.customer_account import CustomerAccount
+from worldline.connect.sdk.v1.domain.customer_base import CustomerBase
+from worldline.connect.sdk.v1.domain.customer_device import CustomerDevice
+from worldline.connect.sdk.v1.domain.personal_information import PersonalInformation
+
+
+class Customer(CustomerBase):
+    """
+    | Object containing data related to the customer
+    """
+
+    __account = None
+    __account_type = None
+    __billing_address = None
+    __contact_details = None
+    __device = None
+    __fiscal_number = None
+    __is_company = None
+    __is_previous_customer = None
+    __locale = None
+    __personal_information = None
+    __shipping_address = None
+
+    @property
+    def account(self):
+        """
+        | Object containing data related to the account the customer has with you
+
+        Type: :class:`worldline.connect.sdk.v1.domain.customer_account.CustomerAccount`
+        """
+        return self.__account
+
+    @account.setter
+    def account(self, value):
+        self.__account = value
+
+    @property
+    def account_type(self):
+        """
+        | 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 with 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):
+        self.__account_type = value
+
+    @property
+    def billing_address(self):
+        """
+        | Object containing billing address details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
+        """
+        return self.__billing_address
+
+    @billing_address.setter
+    def billing_address(self, value):
+        self.__billing_address = value
+
+    @property
+    def contact_details(self):
+        """
+        | Object containing contact details like email address and phone number
+
+        Type: :class:`worldline.connect.sdk.v1.domain.contact_details.ContactDetails`
+        """
+        return self.__contact_details
+
+    @contact_details.setter
+    def contact_details(self, value):
+        self.__contact_details = value
+
+    @property
+    def device(self):
+        """
+        | Object containing information on the device and browser of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.customer_device.CustomerDevice`
+        """
+        return self.__device
+
+    @device.setter
+    def device(self, value):
+        self.__device = value
+
+    @property
+    def fiscal_number(self):
+        """
+        | The fiscal registration number of the customer or the tax registration number of the company in case of a business customer. Please find below specifics per country:
+        
+        * Argentina - Consumer (DNI) with a length of 7 or 8 digits
+        * Argentina - Company (CUIT) with a length of 11 digits
+        * Brazil - Consumer (CPF) with a length of 11 digits
+        * Brazil - Company (CNPJ) with a length of 14 digits
+        * Chile - Consumer (RUT) with a length of 9 digits
+        * Colombia - Consumer (NIT) with a length of 8, 9 or 10 digits
+        * Denmark - Consumer (CPR-nummer or personnummer) with a length of 10 digits
+        * Dominican Republic - Consumer (RNC) with a length of 11 digits
+        * Finland - Consumer (Finnish: henkilötunnus (abbreviated as HETU)) with a length of 11 characters
+        * India - Consumer (PAN) with a length of 10 characters
+        * Mexico - Consumer (RFC) with a length of 13 digits
+        * Mexico - Company (RFC) with a length of 12 digits
+        * Norway - Consumer (fødselsnummer) with a length of 11 digits
+        * Peru - Consumer (RUC) with a length of 11 digits
+        * Sweden - Consumer (personnummer) with a length of 10 or 12 digits
+        * Uruguay - Consumer (CI) with a length of 8 digits
+        * Uruguay - Consumer (NIE) with a length of 9 digits
+        * Uruguay - Company (RUT) with a length of 12 digits
+
+        Type: str
+        """
+        return self.__fiscal_number
+
+    @fiscal_number.setter
+    def fiscal_number(self, value):
+        self.__fiscal_number = value
+
+    @property
+    def is_company(self):
+        """
+        | Indicates if the payer is a company or an individual
+        
+        * true =  This is a company
+        * false = This is an individual
+
+        Type: bool
+        """
+        return self.__is_company
+
+    @is_company.setter
+    def is_company(self, value):
+        self.__is_company = value
+
+    @property
+    def is_previous_customer(self):
+        """
+        | Specifies if the customer has a history of online shopping with the merchant
+        
+        * true - The customer is a known returning customer
+        * false - The customer is new/unknown customer
+
+        Type: bool
+        """
+        return self.__is_previous_customer
+
+    @is_previous_customer.setter
+    def is_previous_customer(self, value):
+        self.__is_previous_customer = value
+
+    @property
+    def locale(self):
+        """
+        | The locale that the customer should be addressed in (for 3rd parties). Note that some 3rd party providers only support the languageCode part of the locale, in those cases we will only use part of the locale provided.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value):
+        self.__locale = value
+
+    @property
+    def personal_information(self):
+        """
+        | Object containing personal information like name, date of birth and gender.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.personal_information.PersonalInformation`
+        """
+        return self.__personal_information
+
+    @personal_information.setter
+    def personal_information(self, value):
+        self.__personal_information = value
+
+    @property
+    def shipping_address(self):
+        """
+        | Object containing shipping address details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address_personal.AddressPersonal`
+
+        Deprecated; Use Order.shipping.address instead
+        """
+        return self.__shipping_address
+
+    @shipping_address.setter
+    def shipping_address(self, value):
+        self.__shipping_address = value
+
+    def to_dictionary(self):
+        dictionary = super(Customer, self).to_dictionary()
+        if self.account is not None:
+            dictionary['account'] = self.account.to_dictionary()
+        if self.account_type is not None:
+            dictionary['accountType'] = self.account_type
+        if self.billing_address is not None:
+            dictionary['billingAddress'] = self.billing_address.to_dictionary()
+        if self.contact_details is not None:
+            dictionary['contactDetails'] = self.contact_details.to_dictionary()
+        if self.device is not None:
+            dictionary['device'] = self.device.to_dictionary()
+        if self.fiscal_number is not None:
+            dictionary['fiscalNumber'] = self.fiscal_number
+        if self.is_company is not None:
+            dictionary['isCompany'] = self.is_company
+        if self.is_previous_customer is not None:
+            dictionary['isPreviousCustomer'] = self.is_previous_customer
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.personal_information is not None:
+            dictionary['personalInformation'] = self.personal_information.to_dictionary()
+        if self.shipping_address is not None:
+            dictionary['shippingAddress'] = self.shipping_address.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(Customer, self).from_dictionary(dictionary)
+        if 'account' in dictionary:
+            if not isinstance(dictionary['account'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['account']))
+            value = CustomerAccount()
+            self.account = value.from_dictionary(dictionary['account'])
+        if 'accountType' in dictionary:
+            self.account_type = dictionary['accountType']
+        if 'billingAddress' in dictionary:
+            if not isinstance(dictionary['billingAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['billingAddress']))
+            value = Address()
+            self.billing_address = value.from_dictionary(dictionary['billingAddress'])
+        if 'contactDetails' in dictionary:
+            if not isinstance(dictionary['contactDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
+            value = ContactDetails()
+            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
+        if 'device' in dictionary:
+            if not isinstance(dictionary['device'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['device']))
+            value = CustomerDevice()
+            self.device = value.from_dictionary(dictionary['device'])
+        if 'fiscalNumber' in dictionary:
+            self.fiscal_number = dictionary['fiscalNumber']
+        if 'isCompany' in dictionary:
+            self.is_company = dictionary['isCompany']
+        if 'isPreviousCustomer' in dictionary:
+            self.is_previous_customer = dictionary['isPreviousCustomer']
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'personalInformation' in dictionary:
+            if not isinstance(dictionary['personalInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['personalInformation']))
+            value = PersonalInformation()
+            self.personal_information = value.from_dictionary(dictionary['personalInformation'])
+        if 'shippingAddress' in dictionary:
+            if not isinstance(dictionary['shippingAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shippingAddress']))
+            value = AddressPersonal()
+            self.shipping_address = value.from_dictionary(dictionary['shippingAddress'])
+        return self

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

@@ -0,0 +1,271 @@
+# -*- 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.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 = None
+    __change_date = None
+    __changed_during_checkout = None
+    __create_date = None
+    __had_suspicious_activity = None
+    __has_forgotten_password = None
+    __has_password = None
+    __password_change_date = None
+    __password_changed_during_checkout = None
+    __payment_account_on_file = None
+    __payment_account_on_file_type = None
+    __payment_activity = None
+
+    @property
+    def authentication(self):
+        """
+        | 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):
+        self.__authentication = value
+
+    @property
+    def change_date(self):
+        """
+        | 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):
+        self.__change_date = value
+
+    @property
+    def changed_during_checkout(self):
+        """
+        | 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):
+        self.__changed_during_checkout = value
+
+    @property
+    def create_date(self):
+        """
+        | 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):
+        self.__create_date = value
+
+    @property
+    def had_suspicious_activity(self):
+        """
+        | 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):
+        self.__had_suspicious_activity = value
+
+    @property
+    def has_forgotten_password(self):
+        """
+        | 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):
+        self.__has_forgotten_password = value
+
+    @property
+    def has_password(self):
+        """
+        | 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):
+        self.__has_password = value
+
+    @property
+    def password_change_date(self):
+        """
+        | 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):
+        self.__password_change_date = value
+
+    @property
+    def password_changed_during_checkout(self):
+        """
+        | 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):
+        self.__password_changed_during_checkout = value
+
+    @property
+    def payment_account_on_file(self):
+        """
+        | 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):
+        self.__payment_account_on_file = value
+
+    @property
+    def payment_account_on_file_type(self):
+        """
+        | 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):
+        self.__payment_account_on_file_type = value
+
+    @property
+    def payment_activity(self):
+        """
+        | 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):
+        self.__payment_activity = value
+
+    def to_dictionary(self):
+        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):
+        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-python2-4.1.0/worldline/connect/sdk/v1/domain/customer_account_authentication.py

@@ -0,0 +1,91 @@
+# -*- 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 CustomerAccountAuthentication(DataObject):
+    """
+    | Object containing data on the authentication used by the customer to access their account
+    """
+
+    __data = None
+    __method = None
+    __utc_timestamp = None
+
+    @property
+    def data(self):
+        """
+        | 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):
+        self.__data = value
+
+    @property
+    def method(self):
+        """
+        | 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):
+        self.__method = value
+
+    @property
+    def utc_timestamp(self):
+        """
+        | 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):
+        self.__utc_timestamp = value
+
+    def to_dictionary(self):
+        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):
+        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