connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.directory_entry import DirectoryEntry
+
+
+class Directory(DataObject):
+
+    __entries: Optional[List[DirectoryEntry]] = None
+
+    @property
+    def entries(self) -> Optional[List[DirectoryEntry]]:
+        """
+        | List of entries in the directory
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.directory_entry.DirectoryEntry`]
+        """
+        return self.__entries
+
+    @entries.setter
+    def entries(self, value: Optional[List[DirectoryEntry]]) -> None:
+        self.__entries = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Directory, self).to_dictionary()
+        if self.entries is not None:
+            dictionary['entries'] = []
+            for element in self.entries:
+                if element is not None:
+                    dictionary['entries'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Directory':
+        super(Directory, self).from_dictionary(dictionary)
+        if 'entries' in dictionary:
+            if not isinstance(dictionary['entries'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['entries']))
+            self.entries = []
+            for element in dictionary['entries']:
+                value = DirectoryEntry()
+                self.entries.append(value.from_dictionary(element))
+        return self

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

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class DirectoryEntry(DataObject):
+
+    __country_names: Optional[List[str]] = None
+    __issuer_id: Optional[str] = None
+    __issuer_list: Optional[str] = None
+    __issuer_name: Optional[str] = None
+
+    @property
+    def country_names(self) -> Optional[List[str]]:
+        """
+        | Country name of the issuer, used to group issuers per country
+        | Note: this is only filled if supported by the payment product.
+
+        Type: list[str]
+        """
+        return self.__country_names
+
+    @country_names.setter
+    def country_names(self, value: Optional[List[str]]) -> None:
+        self.__country_names = value
+
+    @property
+    def issuer_id(self) -> Optional[str]:
+        """
+        | Unique ID of the issuing bank of the customer
+
+        Type: str
+        """
+        return self.__issuer_id
+
+    @issuer_id.setter
+    def issuer_id(self, value: Optional[str]) -> None:
+        self.__issuer_id = value
+
+    @property
+    def issuer_list(self) -> Optional[str]:
+        """
+        | To be used to sort the issuers.
+        
+        * short - These issuers should be presented at the top of the list
+        * long - These issuers should be presented after the issuers marked as short
+        
+        | Note: this is only filled if supported by the payment product. Currently only iDeal (809) support this. Sorting within the groups should be done alphabetically.
+
+        Type: str
+        """
+        return self.__issuer_list
+
+    @issuer_list.setter
+    def issuer_list(self, value: Optional[str]) -> None:
+        self.__issuer_list = value
+
+    @property
+    def issuer_name(self) -> Optional[str]:
+        """
+        | Name of the issuing bank, as it should be presented to the customer
+
+        Type: str
+        """
+        return self.__issuer_name
+
+    @issuer_name.setter
+    def issuer_name(self, value: Optional[str]) -> None:
+        self.__issuer_name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DirectoryEntry, self).to_dictionary()
+        if self.country_names is not None:
+            dictionary['countryNames'] = []
+            for element in self.country_names:
+                if element is not None:
+                    dictionary['countryNames'].append(element)
+        if self.issuer_id is not None:
+            dictionary['issuerId'] = self.issuer_id
+        if self.issuer_list is not None:
+            dictionary['issuerList'] = self.issuer_list
+        if self.issuer_name is not None:
+            dictionary['issuerName'] = self.issuer_name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DirectoryEntry':
+        super(DirectoryEntry, self).from_dictionary(dictionary)
+        if 'countryNames' in dictionary:
+            if not isinstance(dictionary['countryNames'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['countryNames']))
+            self.country_names = []
+            for element in dictionary['countryNames']:
+                self.country_names.append(element)
+        if 'issuerId' in dictionary:
+            self.issuer_id = dictionary['issuerId']
+        if 'issuerList' in dictionary:
+            self.issuer_list = dictionary['issuerList']
+        if 'issuerName' in dictionary:
+            self.issuer_name = dictionary['issuerName']
+        return self

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

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.key_value_pair import KeyValuePair
+
+
+class DisplayedData(DataObject):
+
+    __displayed_data_type: Optional[str] = None
+    __rendering_data: Optional[str] = None
+    __show_data: Optional[List[KeyValuePair]] = None
+
+    @property
+    def displayed_data_type(self) -> Optional[str]:
+        """
+        | Action merchants needs to take in the online payment process. Possible values are:
+        
+        * SHOW_INSTRUCTIONS - The customer needs to be shown payment instruction using the details found in showData. Alternatively the instructions can be rendered by us using the renderingData
+        * SHOW_TRANSACTION_RESULTS - The customer needs to be shown the transaction results using the details found in showData. Alternatively the instructions can be rendered by us using the renderingData
+
+        Type: str
+        """
+        return self.__displayed_data_type
+
+    @displayed_data_type.setter
+    def displayed_data_type(self, value: Optional[str]) -> None:
+        self.__displayed_data_type = value
+
+    @property
+    def rendering_data(self) -> Optional[str]:
+        """
+        | This property contains the blob with data for the instructions rendering service.
+        
+        | This service will be available at the following endpoint:http(s)://{{merchant specific subdomain}}.{{base MyCheckout hosted payment pages domain}}/instructions/{{merchantId}}/{{clientSessionId}}
+        
+        | This instructions page rendering service accepts the following parameters:
+        
+        * instructionsRenderingData (required, the content of this property)
+        * locale (optional, if present overrides default locale, e.g. "en_GB")
+        * variant (optional, code of a variant, if present overrides default variant, e.g. "100")
+        * customerId (required for Pix, otherwise optional, the customerId from a client session)
+        
+        | You can offer a link to a customer to see an instructions page for a payment done earlier. Because of the size of the instructionsRenderingData this will need to be set in a web form as a value of a hidden field. Before presenting the link you need to obtain a clientSessionId by creating a session using the S2S API. You will need to use the MyCheckout hosted payment pages domain hosted in the same region as the API domain used for the createClientSession call.
+        
+        | The instructionsRenderingData is a String blob that is presented to you via the Server API as part of the merchantAction (if available, and non-redirect) in the JSON return values for the createPayment call or the getHostedCheckoutStatus call (merchantAction inside createdPaymentOutput when available).You are responsible to store the instructionsRenderingData blob in order to be able to present the instructions page at a later time, when this information might no longer be available through Server API calls.
+
+        Type: str
+        """
+        return self.__rendering_data
+
+    @rendering_data.setter
+    def rendering_data(self, value: Optional[str]) -> None:
+        self.__rendering_data = value
+
+    @property
+    def show_data(self) -> Optional[List[KeyValuePair]]:
+        """
+        | Array of key value pairs of data that needs to be shown to the customer. This is returned for both the SHOW_INSTRUCTION as well as the SHOW_TRANSACTION_RESULTS actionType.
+        | Note: The returned value for the key BARCODE is a base64 encoded gif image. By prepending 'data:image/gif;base64,' this value can be used as the source of an HTML inline image.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.key_value_pair.KeyValuePair`]
+        """
+        return self.__show_data
+
+    @show_data.setter
+    def show_data(self, value: Optional[List[KeyValuePair]]) -> None:
+        self.__show_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DisplayedData, self).to_dictionary()
+        if self.displayed_data_type is not None:
+            dictionary['displayedDataType'] = self.displayed_data_type
+        if self.rendering_data is not None:
+            dictionary['renderingData'] = self.rendering_data
+        if self.show_data is not None:
+            dictionary['showData'] = []
+            for element in self.show_data:
+                if element is not None:
+                    dictionary['showData'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DisplayedData':
+        super(DisplayedData, self).from_dictionary(dictionary)
+        if 'displayedDataType' in dictionary:
+            self.displayed_data_type = dictionary['displayedDataType']
+        if 'renderingData' in dictionary:
+            self.rendering_data = dictionary['renderingData']
+        if 'showData' in dictionary:
+            if not isinstance(dictionary['showData'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['showData']))
+            self.show_data = []
+            for element in dictionary['showData']:
+                value = KeyValuePair()
+                self.show_data.append(value.from_dictionary(element))
+        return self

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

@@ -0,0 +1,118 @@
+# -*- 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.dispute_output import DisputeOutput
+from worldline.connect.sdk.v1.domain.dispute_status_output import DisputeStatusOutput
+
+
+class Dispute(DataObject):
+
+    __dispute_output: Optional[DisputeOutput] = None
+    __id: Optional[str] = None
+    __payment_id: Optional[str] = None
+    __status: Optional[str] = None
+    __status_output: Optional[DisputeStatusOutput] = None
+
+    @property
+    def dispute_output(self) -> Optional[DisputeOutput]:
+        """
+        | This property contains the creationDetails and default information regarding a dispute.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.dispute_output.DisputeOutput`
+        """
+        return self.__dispute_output
+
+    @dispute_output.setter
+    def dispute_output(self, value: Optional[DisputeOutput]) -> None:
+        self.__dispute_output = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | Dispute ID for a given merchant.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def payment_id(self) -> Optional[str]:
+        """
+        | The ID of the payment that is being disputed.
+
+        Type: str
+        """
+        return self.__payment_id
+
+    @payment_id.setter
+    def payment_id(self, value: Optional[str]) -> None:
+        self.__payment_id = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Current dispute status.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def status_output(self) -> Optional[DisputeStatusOutput]:
+        """
+        | This property contains the output for a dispute regarding the status of the dispute.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.dispute_status_output.DisputeStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[DisputeStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Dispute, self).to_dictionary()
+        if self.dispute_output is not None:
+            dictionary['disputeOutput'] = self.dispute_output.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payment_id is not None:
+            dictionary['paymentId'] = self.payment_id
+        if self.status is not None:
+            dictionary['status'] = self.status
+        if self.status_output is not None:
+            dictionary['statusOutput'] = self.status_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Dispute':
+        super(Dispute, self).from_dictionary(dictionary)
+        if 'disputeOutput' in dictionary:
+            if not isinstance(dictionary['disputeOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['disputeOutput']))
+            value = DisputeOutput()
+            self.dispute_output = value.from_dictionary(dictionary['disputeOutput'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'paymentId' in dictionary:
+            self.payment_id = dictionary['paymentId']
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'statusOutput' in dictionary:
+            if not isinstance(dictionary['statusOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['statusOutput']))
+            value = DisputeStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/dispute_creation_detail.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 DisputeCreationDetail(DataObject):
+
+    __dispute_creation_date: Optional[str] = None
+    __dispute_originator: Optional[str] = None
+    __user_name: Optional[str] = None
+
+    @property
+    def dispute_creation_date(self) -> Optional[str]:
+        """
+        | The date and time of creation of this dispute, in yyyyMMddHHmmss format.
+
+        Type: str
+        """
+        return self.__dispute_creation_date
+
+    @dispute_creation_date.setter
+    def dispute_creation_date(self, value: Optional[str]) -> None:
+        self.__dispute_creation_date = value
+
+    @property
+    def dispute_originator(self) -> Optional[str]:
+        """
+        | The originator of this dispute, which is either Worldline or you as our client.
+
+        Type: str
+        """
+        return self.__dispute_originator
+
+    @dispute_originator.setter
+    def dispute_originator(self, value: Optional[str]) -> None:
+        self.__dispute_originator = value
+
+    @property
+    def user_name(self) -> Optional[str]:
+        """
+        | The user account name of the dispute creator.
+
+        Type: str
+        """
+        return self.__user_name
+
+    @user_name.setter
+    def user_name(self, value: Optional[str]) -> None:
+        self.__user_name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DisputeCreationDetail, self).to_dictionary()
+        if self.dispute_creation_date is not None:
+            dictionary['disputeCreationDate'] = self.dispute_creation_date
+        if self.dispute_originator is not None:
+            dictionary['disputeOriginator'] = self.dispute_originator
+        if self.user_name is not None:
+            dictionary['userName'] = self.user_name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DisputeCreationDetail':
+        super(DisputeCreationDetail, self).from_dictionary(dictionary)
+        if 'disputeCreationDate' in dictionary:
+            self.dispute_creation_date = dictionary['disputeCreationDate']
+        if 'disputeOriginator' in dictionary:
+            self.dispute_originator = dictionary['disputeOriginator']
+        if 'userName' in dictionary:
+            self.user_name = dictionary['userName']
+        return self

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

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
+from worldline.connect.sdk.v1.domain.dispute_creation_detail import DisputeCreationDetail
+from worldline.connect.sdk.v1.domain.dispute_reference import DisputeReference
+from worldline.connect.sdk.v1.domain.hosted_file import HostedFile
+
+
+class DisputeOutput(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __contact_person: Optional[str] = None
+    __creation_details: Optional[DisputeCreationDetail] = None
+    __email_address: Optional[str] = None
+    __files: Optional[List[HostedFile]] = None
+    __reference: Optional[DisputeReference] = None
+    __reply_to: Optional[str] = None
+    __request_message: Optional[str] = None
+    __response_message: Optional[str] = None
+
+    @property
+    def amount_of_money(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount_of_money
+
+    @amount_of_money.setter
+    def amount_of_money(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount_of_money = value
+
+    @property
+    def contact_person(self) -> Optional[str]:
+        """
+        | The name of the person on your side who can be contacted regarding this dispute.
+
+        Type: str
+        """
+        return self.__contact_person
+
+    @contact_person.setter
+    def contact_person(self, value: Optional[str]) -> None:
+        self.__contact_person = value
+
+    @property
+    def creation_details(self) -> Optional[DisputeCreationDetail]:
+        """
+        | Object containing various details related to this dispute’s creation.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.dispute_creation_detail.DisputeCreationDetail`
+        """
+        return self.__creation_details
+
+    @creation_details.setter
+    def creation_details(self, value: Optional[DisputeCreationDetail]) -> None:
+        self.__creation_details = value
+
+    @property
+    def email_address(self) -> Optional[str]:
+        """
+        | The email address of the contact person.
+
+        Type: str
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value: Optional[str]) -> None:
+        self.__email_address = value
+
+    @property
+    def files(self) -> Optional[List[HostedFile]]:
+        """
+        | An array containing all files related to this dispute.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.hosted_file.HostedFile`]
+        """
+        return self.__files
+
+    @files.setter
+    def files(self, value: Optional[List[HostedFile]]) -> None:
+        self.__files = value
+
+    @property
+    def reference(self) -> Optional[DisputeReference]:
+        """
+        | A collection of reference information related to this dispute.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.dispute_reference.DisputeReference`
+        """
+        return self.__reference
+
+    @reference.setter
+    def reference(self, value: Optional[DisputeReference]) -> None:
+        self.__reference = value
+
+    @property
+    def reply_to(self) -> Optional[str]:
+        """
+        | The email address to which the reply message will be sent.
+
+        Type: str
+        """
+        return self.__reply_to
+
+    @reply_to.setter
+    def reply_to(self, value: Optional[str]) -> None:
+        self.__reply_to = value
+
+    @property
+    def request_message(self) -> Optional[str]:
+        """
+        | The message sent from you to Worldline.
+
+        Type: str
+        """
+        return self.__request_message
+
+    @request_message.setter
+    def request_message(self, value: Optional[str]) -> None:
+        self.__request_message = value
+
+    @property
+    def response_message(self) -> Optional[str]:
+        """
+        | The return message sent from the GlobalCollect platform to you.
+
+        Type: str
+        """
+        return self.__response_message
+
+    @response_message.setter
+    def response_message(self, value: Optional[str]) -> None:
+        self.__response_message = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DisputeOutput, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.contact_person is not None:
+            dictionary['contactPerson'] = self.contact_person
+        if self.creation_details is not None:
+            dictionary['creationDetails'] = self.creation_details.to_dictionary()
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        if self.files is not None:
+            dictionary['files'] = []
+            for element in self.files:
+                if element is not None:
+                    dictionary['files'].append(element.to_dictionary())
+        if self.reference is not None:
+            dictionary['reference'] = self.reference.to_dictionary()
+        if self.reply_to is not None:
+            dictionary['replyTo'] = self.reply_to
+        if self.request_message is not None:
+            dictionary['requestMessage'] = self.request_message
+        if self.response_message is not None:
+            dictionary['responseMessage'] = self.response_message
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DisputeOutput':
+        super(DisputeOutput, self).from_dictionary(dictionary)
+        if 'amountOfMoney' in dictionary:
+            if not isinstance(dictionary['amountOfMoney'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoney']))
+            value = AmountOfMoney()
+            self.amount_of_money = value.from_dictionary(dictionary['amountOfMoney'])
+        if 'contactPerson' in dictionary:
+            self.contact_person = dictionary['contactPerson']
+        if 'creationDetails' in dictionary:
+            if not isinstance(dictionary['creationDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['creationDetails']))
+            value = DisputeCreationDetail()
+            self.creation_details = value.from_dictionary(dictionary['creationDetails'])
+        if 'emailAddress' in dictionary:
+            self.email_address = dictionary['emailAddress']
+        if 'files' in dictionary:
+            if not isinstance(dictionary['files'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['files']))
+            self.files = []
+            for element in dictionary['files']:
+                value = HostedFile()
+                self.files.append(value.from_dictionary(element))
+        if 'reference' in dictionary:
+            if not isinstance(dictionary['reference'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['reference']))
+            value = DisputeReference()
+            self.reference = value.from_dictionary(dictionary['reference'])
+        if 'replyTo' in dictionary:
+            self.reply_to = dictionary['replyTo']
+        if 'requestMessage' in dictionary:
+            self.request_message = dictionary['requestMessage']
+        if 'responseMessage' in dictionary:
+            self.response_message = dictionary['responseMessage']
+        return self