connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -0,0 +1,64 @@
+# -*- 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.hosted_mandate_info import HostedMandateInfo
+from worldline.connect.sdk.v1.domain.hosted_mandate_management_specific_input import HostedMandateManagementSpecificInput
+
+
+class CreateHostedMandateManagementRequest(DataObject):
+
+    __create_mandate_info: Optional[HostedMandateInfo] = None
+    __hosted_mandate_management_specific_input: Optional[HostedMandateManagementSpecificInput] = None
+
+    @property
+    def create_mandate_info(self) -> Optional[HostedMandateInfo]:
+        """
+        | Object containing partial information needed for the creation of the mandate. The recurrencetype, signature type of the mandate and reference to the customer are mandatory. You can also supply any personal information you already know about the customer so they have to fill in less details.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.hosted_mandate_info.HostedMandateInfo`
+        """
+        return self.__create_mandate_info
+
+    @create_mandate_info.setter
+    def create_mandate_info(self, value: Optional[HostedMandateInfo]) -> None:
+        self.__create_mandate_info = value
+
+    @property
+    def hosted_mandate_management_specific_input(self) -> Optional[HostedMandateManagementSpecificInput]:
+        """
+        | Object containing hosted mandate management specific data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.hosted_mandate_management_specific_input.HostedMandateManagementSpecificInput`
+        """
+        return self.__hosted_mandate_management_specific_input
+
+    @hosted_mandate_management_specific_input.setter
+    def hosted_mandate_management_specific_input(self, value: Optional[HostedMandateManagementSpecificInput]) -> None:
+        self.__hosted_mandate_management_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedMandateManagementRequest, self).to_dictionary()
+        if self.create_mandate_info is not None:
+            dictionary['createMandateInfo'] = self.create_mandate_info.to_dictionary()
+        if self.hosted_mandate_management_specific_input is not None:
+            dictionary['hostedMandateManagementSpecificInput'] = self.hosted_mandate_management_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedMandateManagementRequest':
+        super(CreateHostedMandateManagementRequest, self).from_dictionary(dictionary)
+        if 'createMandateInfo' in dictionary:
+            if not isinstance(dictionary['createMandateInfo'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['createMandateInfo']))
+            value = HostedMandateInfo()
+            self.create_mandate_info = value.from_dictionary(dictionary['createMandateInfo'])
+        if 'hostedMandateManagementSpecificInput' in dictionary:
+            if not isinstance(dictionary['hostedMandateManagementSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedMandateManagementSpecificInput']))
+            value = HostedMandateManagementSpecificInput()
+            self.hosted_mandate_management_specific_input = value.from_dictionary(dictionary['hostedMandateManagementSpecificInput'])
+        return self

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

@@ -0,0 +1,74 @@
+# -*- 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 CreateHostedMandateManagementResponse(DataObject):
+
+    __returnmac: Optional[str] = None
+    __hosted_mandate_management_id: Optional[str] = None
+    __partial_redirect_url: Optional[str] = None
+
+    @property
+    def returnmac(self) -> Optional[str]:
+        """
+        | When the customer is returned to your site we will append this property and value to the query-string. You should store this data, so you can identify the returning customer.
+
+        Type: str
+        """
+        return self.__returnmac
+
+    @returnmac.setter
+    def returnmac(self, value: Optional[str]) -> None:
+        self.__returnmac = value
+
+    @property
+    def hosted_mandate_management_id(self) -> Optional[str]:
+        """
+        | This is the ID under which the data for this mandate management can be retrieved.
+
+        Type: str
+        """
+        return self.__hosted_mandate_management_id
+
+    @hosted_mandate_management_id.setter
+    def hosted_mandate_management_id(self, value: Optional[str]) -> None:
+        self.__hosted_mandate_management_id = value
+
+    @property
+    def partial_redirect_url(self) -> Optional[str]:
+        """
+        | The partial URL as generated by our system. You will need to add the protocol and the relevant subdomain to this URL, before redirecting your customer to this URL. A special 'payment' subdomain will always work so you can always add 'https://payment.' at the beginning of this response value to view your hosted mandate management pages.
+
+        Type: str
+        """
+        return self.__partial_redirect_url
+
+    @partial_redirect_url.setter
+    def partial_redirect_url(self, value: Optional[str]) -> None:
+        self.__partial_redirect_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedMandateManagementResponse, self).to_dictionary()
+        if self.returnmac is not None:
+            dictionary['RETURNMAC'] = self.returnmac
+        if self.hosted_mandate_management_id is not None:
+            dictionary['hostedMandateManagementId'] = self.hosted_mandate_management_id
+        if self.partial_redirect_url is not None:
+            dictionary['partialRedirectUrl'] = self.partial_redirect_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedMandateManagementResponse':
+        super(CreateHostedMandateManagementResponse, self).from_dictionary(dictionary)
+        if 'RETURNMAC' in dictionary:
+            self.returnmac = dictionary['RETURNMAC']
+        if 'hostedMandateManagementId' in dictionary:
+            self.hosted_mandate_management_id = dictionary['hostedMandateManagementId']
+        if 'partialRedirectUrl' in dictionary:
+            self.partial_redirect_url = dictionary['partialRedirectUrl']
+        return self

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

@@ -0,0 +1,158 @@
+# -*- 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.mandate_customer import MandateCustomer
+
+
+class CreateMandateBase(DataObject):
+
+    __alias: Optional[str] = None
+    __customer: Optional[MandateCustomer] = None
+    __customer_reference: Optional[str] = None
+    __language: Optional[str] = None
+    __recurrence_type: Optional[str] = None
+    __signature_type: Optional[str] = None
+    __unique_mandate_reference: Optional[str] = None
+
+    @property
+    def alias(self) -> Optional[str]:
+        """
+        | 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: Optional[str]) -> None:
+        self.__alias = value
+
+    @property
+    def customer(self) -> Optional[MandateCustomer]:
+        """
+        | 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: Optional[MandateCustomer]) -> None:
+        self.__customer = value
+
+    @property
+    def customer_reference(self) -> Optional[str]:
+        """
+        | The unique identifier of a customer
+
+        Type: str
+        """
+        return self.__customer_reference
+
+    @customer_reference.setter
+    def customer_reference(self, value: Optional[str]) -> None:
+        self.__customer_reference = value
+
+    @property
+    def language(self) -> Optional[str]:
+        """
+        | The language code of the customer, one of de, en, es, fr, it, nl, si, sk, sv.
+
+        Type: str
+        """
+        return self.__language
+
+    @language.setter
+    def language(self, value: Optional[str]) -> None:
+        self.__language = value
+
+    @property
+    def recurrence_type(self) -> Optional[str]:
+        """
+        | Specifies whether the mandate is for one-off or recurring payments. Possible values are:
+        |  
+        * UNIQUE
+        * RECURRING
+
+        Type: str
+        """
+        return self.__recurrence_type
+
+    @recurrence_type.setter
+    def recurrence_type(self, value: Optional[str]) -> None:
+        self.__recurrence_type = value
+
+    @property
+    def signature_type(self) -> Optional[str]:
+        """
+        | Specifies whether the mandate is unsigned or singed by SMS. Possible values are:
+        |  
+        * UNSIGNED
+        * SMS
+
+        Type: str
+        """
+        return self.__signature_type
+
+    @signature_type.setter
+    def signature_type(self, value: Optional[str]) -> None:
+        self.__signature_type = value
+
+    @property
+    def unique_mandate_reference(self) -> Optional[str]:
+        """
+        | The unique identifier of the mandate. If you do not provide one, we will generate one for you.
+
+        Type: str
+        """
+        return self.__unique_mandate_reference
+
+    @unique_mandate_reference.setter
+    def unique_mandate_reference(self, value: Optional[str]) -> None:
+        self.__unique_mandate_reference = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateMandateBase, 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.language is not None:
+            dictionary['language'] = self.language
+        if self.recurrence_type is not None:
+            dictionary['recurrenceType'] = self.recurrence_type
+        if self.signature_type is not None:
+            dictionary['signatureType'] = self.signature_type
+        if self.unique_mandate_reference is not None:
+            dictionary['uniqueMandateReference'] = self.unique_mandate_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateMandateBase':
+        super(CreateMandateBase, 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 'language' in dictionary:
+            self.language = dictionary['language']
+        if 'recurrenceType' in dictionary:
+            self.recurrence_type = dictionary['recurrenceType']
+        if 'signatureType' in dictionary:
+            self.signature_type = dictionary['signatureType']
+        if 'uniqueMandateReference' in dictionary:
+            self.unique_mandate_reference = dictionary['uniqueMandateReference']
+        return self

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

@@ -0,0 +1,64 @@
+# -*- 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.mandate_merchant_action import MandateMerchantAction
+from worldline.connect.sdk.v1.domain.mandate_response import MandateResponse
+
+
+class CreateMandateResponse(DataObject):
+
+    __mandate: Optional[MandateResponse] = None
+    __merchant_action: Optional[MandateMerchantAction] = None
+
+    @property
+    def mandate(self) -> Optional[MandateResponse]:
+        """
+        | Object containing information on a mandate
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_response.MandateResponse`
+        """
+        return self.__mandate
+
+    @mandate.setter
+    def mandate(self, value: Optional[MandateResponse]) -> None:
+        self.__mandate = value
+
+    @property
+    def merchant_action(self) -> Optional[MandateMerchantAction]:
+        """
+        | Object that contains the action, including the needed data, that you should perform next, showing the redirect to a third party to complete the payment or like showing instructions
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_merchant_action.MandateMerchantAction`
+        """
+        return self.__merchant_action
+
+    @merchant_action.setter
+    def merchant_action(self, value: Optional[MandateMerchantAction]) -> None:
+        self.__merchant_action = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateMandateResponse, self).to_dictionary()
+        if self.mandate is not None:
+            dictionary['mandate'] = self.mandate.to_dictionary()
+        if self.merchant_action is not None:
+            dictionary['merchantAction'] = self.merchant_action.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateMandateResponse':
+        super(CreateMandateResponse, self).from_dictionary(dictionary)
+        if 'mandate' in dictionary:
+            if not isinstance(dictionary['mandate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandate']))
+            value = MandateResponse()
+            self.mandate = value.from_dictionary(dictionary['mandate'])
+        if 'merchantAction' in dictionary:
+            if not isinstance(dictionary['merchantAction'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchantAction']))
+            value = MandateMerchantAction()
+            self.merchant_action = value.from_dictionary(dictionary['merchantAction'])
+        return self

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

@@ -0,0 +1,38 @@
+# -*- 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.create_mandate_base import CreateMandateBase
+
+
+class CreateMandateWithReturnUrl(CreateMandateBase):
+
+    __return_url: Optional[str] = None
+
+    @property
+    def return_url(self) -> Optional[str]:
+        """
+        | Return URL to use if the mandate signing requires redirection.
+
+        Type: str
+        """
+        return self.__return_url
+
+    @return_url.setter
+    def return_url(self, value: Optional[str]) -> None:
+        self.__return_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateMandateWithReturnUrl, self).to_dictionary()
+        if self.return_url is not None:
+            dictionary['returnUrl'] = self.return_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateMandateWithReturnUrl':
+        super(CreateMandateWithReturnUrl, self).from_dictionary(dictionary)
+        if 'returnUrl' in dictionary:
+            self.return_url = dictionary['returnUrl']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/create_payment_product_session_request.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
+from worldline.connect.sdk.v1.domain.mobile_payment_product_session302_specific_input import MobilePaymentProductSession302SpecificInput
+
+
+class CreatePaymentProductSessionRequest(DataObject):
+
+    __payment_product_session302_specific_input: Optional[MobilePaymentProductSession302SpecificInput] = None
+
+    @property
+    def payment_product_session302_specific_input(self) -> Optional[MobilePaymentProductSession302SpecificInput]:
+        """
+        | Object containing details for creating an Apple Pay session.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mobile_payment_product_session302_specific_input.MobilePaymentProductSession302SpecificInput`
+        """
+        return self.__payment_product_session302_specific_input
+
+    @payment_product_session302_specific_input.setter
+    def payment_product_session302_specific_input(self, value: Optional[MobilePaymentProductSession302SpecificInput]) -> None:
+        self.__payment_product_session302_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreatePaymentProductSessionRequest, self).to_dictionary()
+        if self.payment_product_session302_specific_input is not None:
+            dictionary['paymentProductSession302SpecificInput'] = self.payment_product_session302_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreatePaymentProductSessionRequest':
+        super(CreatePaymentProductSessionRequest, self).from_dictionary(dictionary)
+        if 'paymentProductSession302SpecificInput' in dictionary:
+            if not isinstance(dictionary['paymentProductSession302SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProductSession302SpecificInput']))
+            value = MobilePaymentProductSession302SpecificInput()
+            self.payment_product_session302_specific_input = value.from_dictionary(dictionary['paymentProductSession302SpecificInput'])
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/create_payment_product_session_response.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
+from worldline.connect.sdk.v1.domain.mobile_payment_product_session302_specific_output import MobilePaymentProductSession302SpecificOutput
+
+
+class CreatePaymentProductSessionResponse(DataObject):
+
+    __payment_product_session302_specific_output: Optional[MobilePaymentProductSession302SpecificOutput] = None
+
+    @property
+    def payment_product_session302_specific_output(self) -> Optional[MobilePaymentProductSession302SpecificOutput]:
+        """
+        | Object containing the Apple Pay session object.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mobile_payment_product_session302_specific_output.MobilePaymentProductSession302SpecificOutput`
+        """
+        return self.__payment_product_session302_specific_output
+
+    @payment_product_session302_specific_output.setter
+    def payment_product_session302_specific_output(self, value: Optional[MobilePaymentProductSession302SpecificOutput]) -> None:
+        self.__payment_product_session302_specific_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreatePaymentProductSessionResponse, self).to_dictionary()
+        if self.payment_product_session302_specific_output is not None:
+            dictionary['paymentProductSession302SpecificOutput'] = self.payment_product_session302_specific_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreatePaymentProductSessionResponse':
+        super(CreatePaymentProductSessionResponse, self).from_dictionary(dictionary)
+        if 'paymentProductSession302SpecificOutput' in dictionary:
+            if not isinstance(dictionary['paymentProductSession302SpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProductSession302SpecificOutput']))
+            value = MobilePaymentProductSession302SpecificOutput()
+            self.payment_product_session302_specific_output = value.from_dictionary(dictionary['paymentProductSession302SpecificOutput'])
+        return self