connect-sdk-python2 4.0.0__zip → 4.0.1__zip

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

@@ -1,74 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class MandateApproval(DataObject):
-
-    __mandate_signature_date = None
-    __mandate_signature_place = None
-    __mandate_signed = None
-
-    @property
-    def mandate_signature_date(self):
-        """
-        | The date when the mandate was signed
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__mandate_signature_date
-
-    @mandate_signature_date.setter
-    def mandate_signature_date(self, value):
-        self.__mandate_signature_date = value
-
-    @property
-    def mandate_signature_place(self):
-        """
-        | The city where the mandate was signed
-        
-        Type: str
-        """
-        return self.__mandate_signature_place
-
-    @mandate_signature_place.setter
-    def mandate_signature_place(self, value):
-        self.__mandate_signature_place = value
-
-    @property
-    def mandate_signed(self):
-        """
-        * true = Mandate is signed
-        * false = Mandate is not signed
-        
-        Type: bool
-        """
-        return self.__mandate_signed
-
-    @mandate_signed.setter
-    def mandate_signed(self, value):
-        self.__mandate_signed = value
-
-    def to_dictionary(self):
-        dictionary = super(MandateApproval, self).to_dictionary()
-        if self.mandate_signature_date is not None:
-            dictionary['mandateSignatureDate'] = self.mandate_signature_date
-        if self.mandate_signature_place is not None:
-            dictionary['mandateSignaturePlace'] = self.mandate_signature_place
-        if self.mandate_signed is not None:
-            dictionary['mandateSigned'] = self.mandate_signed
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandateApproval, self).from_dictionary(dictionary)
-        if 'mandateSignatureDate' in dictionary:
-            self.mandate_signature_date = dictionary['mandateSignatureDate']
-        if 'mandateSignaturePlace' in dictionary:
-            self.mandate_signature_place = dictionary['mandateSignaturePlace']
-        if 'mandateSigned' in dictionary:
-            self.mandate_signed = dictionary['mandateSigned']
-        return self

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

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class MandateContactDetails(DataObject):
-    """
-    | Contact details of the consumer
-    """
-
-    __email_address = None
-
-    @property
-    def email_address(self):
-        """
-        | Email address of the customer
-        
-        Type: str
-        """
-        return self.__email_address
-
-    @email_address.setter
-    def email_address(self, value):
-        self.__email_address = value
-
-    def to_dictionary(self):
-        dictionary = super(MandateContactDetails, self).to_dictionary()
-        if self.email_address is not None:
-            dictionary['emailAddress'] = self.email_address
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandateContactDetails, self).from_dictionary(dictionary)
-        if 'emailAddress' in dictionary:
-            self.email_address = dictionary['emailAddress']
-        return self

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

@@ -1,124 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.bank_account_iban import BankAccountIban
-from worldline.connect.sdk.v1.domain.mandate_address import MandateAddress
-from worldline.connect.sdk.v1.domain.mandate_contact_details import MandateContactDetails
-from worldline.connect.sdk.v1.domain.mandate_personal_information import MandatePersonalInformation
-
-
-class MandateCustomer(DataObject):
-
-    __bank_account_iban = None
-    __company_name = None
-    __contact_details = None
-    __mandate_address = None
-    __personal_information = None
-
-    @property
-    def bank_account_iban(self):
-        """
-        | Object containing IBAN information
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_iban.BankAccountIban`
-        """
-        return self.__bank_account_iban
-
-    @bank_account_iban.setter
-    def bank_account_iban(self, value):
-        self.__bank_account_iban = value
-
-    @property
-    def company_name(self):
-        """
-        | Name of company, as a customer
-        
-        Type: str
-        """
-        return self.__company_name
-
-    @company_name.setter
-    def company_name(self, value):
-        self.__company_name = value
-
-    @property
-    def contact_details(self):
-        """
-        | Object containing contact details like email address and phone number
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.mandate_contact_details.MandateContactDetails`
-        """
-        return self.__contact_details
-
-    @contact_details.setter
-    def contact_details(self, value):
-        self.__contact_details = value
-
-    @property
-    def mandate_address(self):
-        """
-        | Object containing billing address details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.mandate_address.MandateAddress`
-        """
-        return self.__mandate_address
-
-    @mandate_address.setter
-    def mandate_address(self, value):
-        self.__mandate_address = value
-
-    @property
-    def personal_information(self):
-        """
-        | Object containing personal information of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.mandate_personal_information.MandatePersonalInformation`
-        """
-        return self.__personal_information
-
-    @personal_information.setter
-    def personal_information(self, value):
-        self.__personal_information = value
-
-    def to_dictionary(self):
-        dictionary = super(MandateCustomer, self).to_dictionary()
-        if self.bank_account_iban is not None:
-            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
-        if self.company_name is not None:
-            dictionary['companyName'] = self.company_name
-        if self.contact_details is not None:
-            dictionary['contactDetails'] = self.contact_details.to_dictionary()
-        if self.mandate_address is not None:
-            dictionary['mandateAddress'] = self.mandate_address.to_dictionary()
-        if self.personal_information is not None:
-            dictionary['personalInformation'] = self.personal_information.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandateCustomer, self).from_dictionary(dictionary)
-        if 'bankAccountIban' in dictionary:
-            if not isinstance(dictionary['bankAccountIban'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountIban']))
-            value = BankAccountIban()
-            self.bank_account_iban = value.from_dictionary(dictionary['bankAccountIban'])
-        if 'companyName' in dictionary:
-            self.company_name = dictionary['companyName']
-        if 'contactDetails' in dictionary:
-            if not isinstance(dictionary['contactDetails'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
-            value = MandateContactDetails()
-            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
-        if 'mandateAddress' in dictionary:
-            if not isinstance(dictionary['mandateAddress'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandateAddress']))
-            value = MandateAddress()
-            self.mandate_address = value.from_dictionary(dictionary['mandateAddress'])
-        if 'personalInformation' in dictionary:
-            if not isinstance(dictionary['personalInformation'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['personalInformation']))
-            value = MandatePersonalInformation()
-            self.personal_information = value.from_dictionary(dictionary['personalInformation'])
-        return self

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

@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.mandate_redirect_data import MandateRedirectData
-
-
-class MandateMerchantAction(DataObject):
-
-    __action_type = None
-    __redirect_data = None
-
-    @property
-    def action_type(self):
-        """
-        | Action merchants needs to take in the online mandate process. Possible values are:
-        
-        * REDIRECT - The customer needs to be redirected using the details found in redirectData
-        
-        Type: str
-        """
-        return self.__action_type
-
-    @action_type.setter
-    def action_type(self, value):
-        self.__action_type = value
-
-    @property
-    def redirect_data(self):
-        """
-        | Object containing all data needed to redirect the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.mandate_redirect_data.MandateRedirectData`
-        """
-        return self.__redirect_data
-
-    @redirect_data.setter
-    def redirect_data(self, value):
-        self.__redirect_data = value
-
-    def to_dictionary(self):
-        dictionary = super(MandateMerchantAction, self).to_dictionary()
-        if self.action_type is not None:
-            dictionary['actionType'] = self.action_type
-        if self.redirect_data is not None:
-            dictionary['redirectData'] = self.redirect_data.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandateMerchantAction, self).from_dictionary(dictionary)
-        if 'actionType' in dictionary:
-            self.action_type = dictionary['actionType']
-        if 'redirectData' in dictionary:
-            if not isinstance(dictionary['redirectData'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectData']))
-            value = MandateRedirectData()
-            self.redirect_data = value.from_dictionary(dictionary['redirectData'])
-        return self

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

@@ -1,62 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product705_specific_data import TokenNonSepaDirectDebitPaymentProduct705SpecificData
-from worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product730_specific_data import TokenNonSepaDirectDebitPaymentProduct730SpecificData
-
-
-class MandateNonSepaDirectDebit(DataObject):
-
-    __payment_product705_specific_data = None
-    __payment_product730_specific_data = None
-
-    @property
-    def payment_product705_specific_data(self):
-        """
-        | Object containing specific data for Direct Debit UK
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product705_specific_data.TokenNonSepaDirectDebitPaymentProduct705SpecificData`
-        """
-        return self.__payment_product705_specific_data
-
-    @payment_product705_specific_data.setter
-    def payment_product705_specific_data(self, value):
-        self.__payment_product705_specific_data = value
-
-    @property
-    def payment_product730_specific_data(self):
-        """
-        | Object containing specific data for ACH
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product730_specific_data.TokenNonSepaDirectDebitPaymentProduct730SpecificData`
-        """
-        return self.__payment_product730_specific_data
-
-    @payment_product730_specific_data.setter
-    def payment_product730_specific_data(self, value):
-        self.__payment_product730_specific_data = value
-
-    def to_dictionary(self):
-        dictionary = super(MandateNonSepaDirectDebit, self).to_dictionary()
-        if self.payment_product705_specific_data is not None:
-            dictionary['paymentProduct705SpecificData'] = self.payment_product705_specific_data.to_dictionary()
-        if self.payment_product730_specific_data is not None:
-            dictionary['paymentProduct730SpecificData'] = self.payment_product730_specific_data.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandateNonSepaDirectDebit, self).from_dictionary(dictionary)
-        if 'paymentProduct705SpecificData' in dictionary:
-            if not isinstance(dictionary['paymentProduct705SpecificData'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct705SpecificData']))
-            value = TokenNonSepaDirectDebitPaymentProduct705SpecificData()
-            self.payment_product705_specific_data = value.from_dictionary(dictionary['paymentProduct705SpecificData'])
-        if 'paymentProduct730SpecificData' in dictionary:
-            if not isinstance(dictionary['paymentProduct730SpecificData'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct730SpecificData']))
-            value = TokenNonSepaDirectDebitPaymentProduct730SpecificData()
-            self.payment_product730_specific_data = value.from_dictionary(dictionary['paymentProduct730SpecificData'])
-        return self

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

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.mandate_personal_name import MandatePersonalName
-
-
-class MandatePersonalInformation(DataObject):
-
-    __name = None
-    __title = None
-
-    @property
-    def name(self):
-        """
-        | Object containing the name details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.mandate_personal_name.MandatePersonalName`
-        """
-        return self.__name
-
-    @name.setter
-    def name(self, value):
-        self.__name = value
-
-    @property
-    def title(self):
-        """
-        | Object containing the title of the customer (Mr, Miss or Mrs)
-        
-        Type: str
-        """
-        return self.__title
-
-    @title.setter
-    def title(self, value):
-        self.__title = value
-
-    def to_dictionary(self):
-        dictionary = super(MandatePersonalInformation, self).to_dictionary()
-        if self.name is not None:
-            dictionary['name'] = self.name.to_dictionary()
-        if self.title is not None:
-            dictionary['title'] = self.title
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandatePersonalInformation, self).from_dictionary(dictionary)
-        if 'name' in dictionary:
-            if not isinstance(dictionary['name'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['name']))
-            value = MandatePersonalName()
-            self.name = value.from_dictionary(dictionary['name'])
-        if 'title' in dictionary:
-            self.title = dictionary['title']
-        return self

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

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class MandatePersonalName(DataObject):
-
-    __first_name = None
-    __surname = None
-
-    @property
-    def first_name(self):
-        """
-        | Given name(s) or first name(s) of the customer
-        
-        Type: str
-        """
-        return self.__first_name
-
-    @first_name.setter
-    def first_name(self, value):
-        self.__first_name = value
-
-    @property
-    def surname(self):
-        """
-        | Surname(s) or last name(s) of the customer
-        
-        Type: str
-        """
-        return self.__surname
-
-    @surname.setter
-    def surname(self, value):
-        self.__surname = value
-
-    def to_dictionary(self):
-        dictionary = super(MandatePersonalName, self).to_dictionary()
-        if self.first_name is not None:
-            dictionary['firstName'] = self.first_name
-        if self.surname is not None:
-            dictionary['surname'] = self.surname
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandatePersonalName, self).from_dictionary(dictionary)
-        if 'firstName' in dictionary:
-            self.first_name = dictionary['firstName']
-        if 'surname' in dictionary:
-            self.surname = dictionary['surname']
-        return self

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

@@ -1,140 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.mandate_customer import MandateCustomer
-
-
-class MandateResponse(DataObject):
-
-    __alias = None
-    __customer = None
-    __customer_reference = None
-    __recurrence_type = None
-    __status = None
-    __unique_mandate_reference = None
-
-    @property
-    def alias(self):
-        """
-        | An alias for the mandate. This can be used to visually represent the mandate.
-        | Do not include any unobfuscated sensitive data in the alias.
-        | Default value if not provided is the obfuscated IBAN of the customer.
-        
-        Type: str
-        """
-        return self.__alias
-
-    @alias.setter
-    def alias(self, value):
-        self.__alias = value
-
-    @property
-    def customer(self):
-        """
-        | Customer object containing customer specific inputs
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.mandate_customer.MandateCustomer`
-        """
-        return self.__customer
-
-    @customer.setter
-    def customer(self, value):
-        self.__customer = value
-
-    @property
-    def customer_reference(self):
-        """
-        | The unique identifier of the customer to which this mandate is applicable
-        
-        Type: str
-        """
-        return self.__customer_reference
-
-    @customer_reference.setter
-    def customer_reference(self, value):
-        self.__customer_reference = value
-
-    @property
-    def recurrence_type(self):
-        """
-        | Specifieds whether the mandate is for one-off or recurring payments.
-        
-        Type: str
-        """
-        return self.__recurrence_type
-
-    @recurrence_type.setter
-    def recurrence_type(self, value):
-        self.__recurrence_type = value
-
-    @property
-    def status(self):
-        """
-        | The status of the mandate. Possible values are:
-        
-        * ACTIVE
-        * EXPIRED
-        * CREATED
-        * REVOKED
-        * WAITING_FOR_REFERENCE
-        * BLOCKED
-        * USED
-        
-        Type: str
-        """
-        return self.__status
-
-    @status.setter
-    def status(self, value):
-        self.__status = value
-
-    @property
-    def unique_mandate_reference(self):
-        """
-        | The unique identifier of the mandate
-        
-        Type: str
-        """
-        return self.__unique_mandate_reference
-
-    @unique_mandate_reference.setter
-    def unique_mandate_reference(self, value):
-        self.__unique_mandate_reference = value
-
-    def to_dictionary(self):
-        dictionary = super(MandateResponse, self).to_dictionary()
-        if self.alias is not None:
-            dictionary['alias'] = self.alias
-        if self.customer is not None:
-            dictionary['customer'] = self.customer.to_dictionary()
-        if self.customer_reference is not None:
-            dictionary['customerReference'] = self.customer_reference
-        if self.recurrence_type is not None:
-            dictionary['recurrenceType'] = self.recurrence_type
-        if self.status is not None:
-            dictionary['status'] = self.status
-        if self.unique_mandate_reference is not None:
-            dictionary['uniqueMandateReference'] = self.unique_mandate_reference
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandateResponse, self).from_dictionary(dictionary)
-        if 'alias' in dictionary:
-            self.alias = dictionary['alias']
-        if 'customer' in dictionary:
-            if not isinstance(dictionary['customer'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
-            value = MandateCustomer()
-            self.customer = value.from_dictionary(dictionary['customer'])
-        if 'customerReference' in dictionary:
-            self.customer_reference = dictionary['customerReference']
-        if 'recurrenceType' in dictionary:
-            self.recurrence_type = dictionary['recurrenceType']
-        if 'status' in dictionary:
-            self.status = dictionary['status']
-        if 'uniqueMandateReference' in dictionary:
-            self.unique_mandate_reference = dictionary['uniqueMandateReference']
-        return self

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

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from worldline.connect.sdk.v1.domain.creditor import Creditor
-from worldline.connect.sdk.v1.domain.mandate_sepa_direct_debit_with_mandate_id import MandateSepaDirectDebitWithMandateId
-
-
-class MandateSepaDirectDebit(MandateSepaDirectDebitWithMandateId):
-
-    __creditor = None
-
-    @property
-    def creditor(self):
-        """
-        | Object containing information on the creditor
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.creditor.Creditor`
-        """
-        return self.__creditor
-
-    @creditor.setter
-    def creditor(self, value):
-        self.__creditor = value
-
-    def to_dictionary(self):
-        dictionary = super(MandateSepaDirectDebit, self).to_dictionary()
-        if self.creditor is not None:
-            dictionary['creditor'] = self.creditor.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(MandateSepaDirectDebit, self).from_dictionary(dictionary)
-        if 'creditor' in dictionary:
-            if not isinstance(dictionary['creditor'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['creditor']))
-            value = Creditor()
-            self.creditor = value.from_dictionary(dictionary['creditor'])
-        return self