connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/created_payment_output.py

@@ -0,0 +1,201 @@
+# -*- 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.displayed_data import DisplayedData
+from worldline.connect.sdk.v1.domain.payment import Payment
+from worldline.connect.sdk.v1.domain.payment_creation_references import PaymentCreationReferences
+
+
+class CreatedPaymentOutput(DataObject):
+    """
+    | This object is used when a payment was created during a HostedCheckout. It is part of the response of a GET HostedCheckout object and contains the details of the created payment object.
+    """
+
+    __displayed_data: Optional[DisplayedData] = None
+    __is_checked_remember_me: Optional[bool] = None
+    __payment: Optional[Payment] = None
+    __payment_creation_references: Optional[PaymentCreationReferences] = None
+    __payment_status_category: Optional[str] = None
+    __tokenization_succeeded: Optional[bool] = None
+    __tokens: Optional[str] = None
+
+    @property
+    def displayed_data(self) -> Optional[DisplayedData]:
+        """
+        | Object that contains the action, including the needed data, that you should perform next, like showing instruction, showing the transaction results or redirect to a third party to complete the payment
+
+        Type: :class:`worldline.connect.sdk.v1.domain.displayed_data.DisplayedData`
+        """
+        return self.__displayed_data
+
+    @displayed_data.setter
+    def displayed_data(self, value: Optional[DisplayedData]) -> None:
+        self.__displayed_data = value
+
+    @property
+    def is_checked_remember_me(self) -> Optional[bool]:
+        """
+        | Indicates whether the customer ticked the "Remember my details for future purchases" checkbox on the MyCheckout hosted payment pages
+
+        Type: bool
+        """
+        return self.__is_checked_remember_me
+
+    @is_checked_remember_me.setter
+    def is_checked_remember_me(self, value: Optional[bool]) -> None:
+        self.__is_checked_remember_me = value
+
+    @property
+    def payment(self) -> Optional[Payment]:
+        """
+        | Object that holds the payment data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment.Payment`
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value: Optional[Payment]) -> None:
+        self.__payment = value
+
+    @property
+    def payment_creation_references(self) -> Optional[PaymentCreationReferences]:
+        """
+        | Object containing the created references
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_creation_references.PaymentCreationReferences`
+        """
+        return self.__payment_creation_references
+
+    @payment_creation_references.setter
+    def payment_creation_references(self, value: Optional[PaymentCreationReferences]) -> None:
+        self.__payment_creation_references = value
+
+    @property
+    def payment_status_category(self) -> Optional[str]:
+        """
+        | Highlevel indication of the payment status with the following possible values:
+        
+        * REJECTED - The payment has been rejected or is in such a state that it will never become successful. This category groups the following statuses:
+        
+        * CREATED
+        * REJECTED
+        * REJECTED CAPTURE
+        * REJECTED REFUND
+        * REJECTED PAYOUT
+        * CANCELLED
+        
+        
+        * SUCCESSFUL - The payment was not (yet) rejected. Use the payment statuses to determine if it was completed, see Statuses <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/statuses.html>. This category groups the following statuses:
+        
+        * PENDING PAYMENT
+        * ACCOUNT VERIFIED
+        * PENDING FRAUD APPROVAL
+        * PENDING APPROVAL
+        * AUTHORIZATION REQUESTED
+        * CAPTURE REQUESTED
+        * REFUND REQUESTED
+        * PAYOUT REQUESTED
+        * CAPTURED
+        * PAID
+        * ACCOUNT CREDITED
+        * REVERSED
+        * CHARGEBACK_NOTIFICATION
+        * CHARGEBACKED
+        * REFUNDED
+        
+        
+        * STATUS_UNKNOWN - The status of the payment is unknown at this moment. This category groups the following statuses:
+        
+        * REDIRECTED
+        
+        
+        
+        
+        | Please see Statuses <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/statuses.html> for a full overview of possible values.
+
+        Type: str
+
+        Deprecated; Use Payment.statusOutput.statusCategory instead
+        """
+        return self.__payment_status_category
+
+    @payment_status_category.setter
+    def payment_status_category(self, value: Optional[str]) -> None:
+        self.__payment_status_category = value
+
+    @property
+    def tokenization_succeeded(self) -> Optional[bool]:
+        """
+        | If the payment was attempted to be tokenized, indicates if tokenization was successful or not.
+
+        Type: bool
+        """
+        return self.__tokenization_succeeded
+
+    @tokenization_succeeded.setter
+    def tokenization_succeeded(self, value: Optional[bool]) -> None:
+        self.__tokenization_succeeded = value
+
+    @property
+    def tokens(self) -> Optional[str]:
+        """
+        | This property contains the tokens that are associated with the hosted checkout session/customer. You can use the tokens listed in this list for a future checkout of the same customer.
+
+        Type: str
+        """
+        return self.__tokens
+
+    @tokens.setter
+    def tokens(self, value: Optional[str]) -> None:
+        self.__tokens = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreatedPaymentOutput, self).to_dictionary()
+        if self.displayed_data is not None:
+            dictionary['displayedData'] = self.displayed_data.to_dictionary()
+        if self.is_checked_remember_me is not None:
+            dictionary['isCheckedRememberMe'] = self.is_checked_remember_me
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        if self.payment_creation_references is not None:
+            dictionary['paymentCreationReferences'] = self.payment_creation_references.to_dictionary()
+        if self.payment_status_category is not None:
+            dictionary['paymentStatusCategory'] = self.payment_status_category
+        if self.tokenization_succeeded is not None:
+            dictionary['tokenizationSucceeded'] = self.tokenization_succeeded
+        if self.tokens is not None:
+            dictionary['tokens'] = self.tokens
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreatedPaymentOutput':
+        super(CreatedPaymentOutput, self).from_dictionary(dictionary)
+        if 'displayedData' in dictionary:
+            if not isinstance(dictionary['displayedData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayedData']))
+            value = DisplayedData()
+            self.displayed_data = value.from_dictionary(dictionary['displayedData'])
+        if 'isCheckedRememberMe' in dictionary:
+            self.is_checked_remember_me = dictionary['isCheckedRememberMe']
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = Payment()
+            self.payment = value.from_dictionary(dictionary['payment'])
+        if 'paymentCreationReferences' in dictionary:
+            if not isinstance(dictionary['paymentCreationReferences'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentCreationReferences']))
+            value = PaymentCreationReferences()
+            self.payment_creation_references = value.from_dictionary(dictionary['paymentCreationReferences'])
+        if 'paymentStatusCategory' in dictionary:
+            self.payment_status_category = dictionary['paymentStatusCategory']
+        if 'tokenizationSucceeded' in dictionary:
+            self.tokenization_succeeded = dictionary['tokenizationSucceeded']
+        if 'tokens' in dictionary:
+            self.tokens = dictionary['tokens']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/creditor.py

@@ -0,0 +1,219 @@
+# -*- 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 Creditor(DataObject):
+
+    __additional_address_info: Optional[str] = None
+    __city: Optional[str] = None
+    __country_code: Optional[str] = None
+    __house_number: Optional[str] = None
+    __iban: Optional[str] = None
+    __id: Optional[str] = None
+    __name: Optional[str] = None
+    __reference_party: Optional[str] = None
+    __reference_party_id: Optional[str] = None
+    __street: Optional[str] = None
+    __zip: Optional[str] = None
+
+    @property
+    def additional_address_info(self) -> Optional[str]:
+        """
+        | Additional information about the creditor's address, like Suite II, Apartment 2a
+
+        Type: str
+        """
+        return self.__additional_address_info
+
+    @additional_address_info.setter
+    def additional_address_info(self, value: Optional[str]) -> None:
+        self.__additional_address_info = value
+
+    @property
+    def city(self) -> Optional[str]:
+        """
+        | City of the creditor address
+
+        Type: str
+        """
+        return self.__city
+
+    @city.setter
+    def city(self, value: Optional[str]) -> None:
+        self.__city = value
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def house_number(self) -> Optional[str]:
+        """
+        | House number of the creditor address
+
+        Type: str
+        """
+        return self.__house_number
+
+    @house_number.setter
+    def house_number(self, value: Optional[str]) -> None:
+        self.__house_number = value
+
+    @property
+    def iban(self) -> Optional[str]:
+        """
+        | Creditor IBAN number
+        | The IBAN is the International Bank Account Number. It is an internationally agreed format for the bank account number and includes the ISO country code and two check digits.
+
+        Type: str
+        """
+        return self.__iban
+
+    @iban.setter
+    def iban(self, value: Optional[str]) -> None:
+        self.__iban = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | Creditor identifier
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        | Name of the collecting creditor
+
+        Type: str
+        """
+        return self.__name
+
+    @name.setter
+    def name(self, value: Optional[str]) -> None:
+        self.__name = value
+
+    @property
+    def reference_party(self) -> Optional[str]:
+        """
+        | Creditor type of the legal reference of the collecting entity
+
+        Type: str
+        """
+        return self.__reference_party
+
+    @reference_party.setter
+    def reference_party(self, value: Optional[str]) -> None:
+        self.__reference_party = value
+
+    @property
+    def reference_party_id(self) -> Optional[str]:
+        """
+        | Legal reference of the collecting creditor
+
+        Type: str
+        """
+        return self.__reference_party_id
+
+    @reference_party_id.setter
+    def reference_party_id(self, value: Optional[str]) -> None:
+        self.__reference_party_id = value
+
+    @property
+    def street(self) -> Optional[str]:
+        """
+        | Street of the creditor address
+
+        Type: str
+        """
+        return self.__street
+
+    @street.setter
+    def street(self, value: Optional[str]) -> None:
+        self.__street = value
+
+    @property
+    def zip(self) -> Optional[str]:
+        """
+        | ZIP code of the creditor address
+
+        Type: str
+        """
+        return self.__zip
+
+    @zip.setter
+    def zip(self, value: Optional[str]) -> None:
+        self.__zip = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Creditor, self).to_dictionary()
+        if self.additional_address_info is not None:
+            dictionary['additionalAddressInfo'] = self.additional_address_info
+        if self.city is not None:
+            dictionary['city'] = self.city
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.house_number is not None:
+            dictionary['houseNumber'] = self.house_number
+        if self.iban is not None:
+            dictionary['iban'] = self.iban
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.name is not None:
+            dictionary['name'] = self.name
+        if self.reference_party is not None:
+            dictionary['referenceParty'] = self.reference_party
+        if self.reference_party_id is not None:
+            dictionary['referencePartyId'] = self.reference_party_id
+        if self.street is not None:
+            dictionary['street'] = self.street
+        if self.zip is not None:
+            dictionary['zip'] = self.zip
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Creditor':
+        super(Creditor, self).from_dictionary(dictionary)
+        if 'additionalAddressInfo' in dictionary:
+            self.additional_address_info = dictionary['additionalAddressInfo']
+        if 'city' in dictionary:
+            self.city = dictionary['city']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'houseNumber' in dictionary:
+            self.house_number = dictionary['houseNumber']
+        if 'iban' in dictionary:
+            self.iban = dictionary['iban']
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'name' in dictionary:
+            self.name = dictionary['name']
+        if 'referenceParty' in dictionary:
+            self.reference_party = dictionary['referenceParty']
+        if 'referencePartyId' in dictionary:
+            self.reference_party_id = dictionary['referencePartyId']
+        if 'street' in dictionary:
+            self.street = dictionary['street']
+        if 'zip' in dictionary:
+            self.zip = dictionary['zip']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/customer.py

@@ -0,0 +1,276 @@
+# -*- 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.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: Optional[CustomerAccount] = None
+    __account_type: Optional[str] = None
+    __billing_address: Optional[Address] = None
+    __contact_details: Optional[ContactDetails] = None
+    __device: Optional[CustomerDevice] = None
+    __fiscal_number: Optional[str] = None
+    __is_company: Optional[bool] = None
+    __is_previous_customer: Optional[bool] = None
+    __locale: Optional[str] = None
+    __personal_information: Optional[PersonalInformation] = None
+    __shipping_address: Optional[AddressPersonal] = None
+
+    @property
+    def account(self) -> Optional[CustomerAccount]:
+        """
+        | 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: Optional[CustomerAccount]) -> None:
+        self.__account = value
+
+    @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 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: Optional[str]) -> None:
+        self.__account_type = value
+
+    @property
+    def billing_address(self) -> Optional[Address]:
+        """
+        | 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: Optional[Address]) -> None:
+        self.__billing_address = value
+
+    @property
+    def contact_details(self) -> Optional[ContactDetails]:
+        """
+        | 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: Optional[ContactDetails]) -> None:
+        self.__contact_details = value
+
+    @property
+    def device(self) -> Optional[CustomerDevice]:
+        """
+        | 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: Optional[CustomerDevice]) -> None:
+        self.__device = value
+
+    @property
+    def fiscal_number(self) -> Optional[str]:
+        """
+        | 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: Optional[str]) -> None:
+        self.__fiscal_number = value
+
+    @property
+    def is_company(self) -> Optional[bool]:
+        """
+        | 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: Optional[bool]) -> None:
+        self.__is_company = value
+
+    @property
+    def is_previous_customer(self) -> Optional[bool]:
+        """
+        | 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: Optional[bool]) -> None:
+        self.__is_previous_customer = value
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | 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: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def personal_information(self) -> Optional[PersonalInformation]:
+        """
+        | 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: Optional[PersonalInformation]) -> None:
+        self.__personal_information = value
+
+    @property
+    def shipping_address(self) -> Optional[AddressPersonal]:
+        """
+        | 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: Optional[AddressPersonal]) -> None:
+        self.__shipping_address = value
+
+    def to_dictionary(self) -> dict:
+        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: dict) -> 'Customer':
+        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