connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_product_filters_client_session.py

@@ -1,63 +0,0 @@
-# -*- 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.payment_product_filter import PaymentProductFilter
-
-
-class PaymentProductFiltersClientSession(DataObject):
-
-    __exclude: Optional[PaymentProductFilter] = None
-    __restrict_to: Optional[PaymentProductFilter] = None
-
-    @property
-    def exclude(self) -> Optional[PaymentProductFilter]:
-        """
-        | Contains the payment product ids and payment product groups that should be excluded from the payment products available for the payment. Note that excluding a payment product will ensure exclusion, even if the payment product is also present in the restrictTo filter, and that excluding a payment product group will exclude all payment products that are a part of that group, even if one or more of them are present in the restrictTo filters.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
-        """
-        return self.__exclude
-
-    @exclude.setter
-    def exclude(self, value: Optional[PaymentProductFilter]) -> None:
-        self.__exclude = value
-
-    @property
-    def restrict_to(self) -> Optional[PaymentProductFilter]:
-        """
-        | Contains the payment product ids and payment product groups that should be at most contained in the payment products available for completing the payment. Note that the list of payment products available for completing the payment will only contain payment products present in these filters, but not all payment products in these filters might be present in the list. Some of them might not be allowed in context or they might be present in the exclude filters.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
-        """
-        return self.__restrict_to
-
-    @restrict_to.setter
-    def restrict_to(self, value: Optional[PaymentProductFilter]) -> None:
-        self.__restrict_to = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductFiltersClientSession, self).to_dictionary()
-        if self.exclude is not None:
-            dictionary['exclude'] = self.exclude.to_dictionary()
-        if self.restrict_to is not None:
-            dictionary['restrictTo'] = self.restrict_to.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFiltersClientSession':
-        super(PaymentProductFiltersClientSession, self).from_dictionary(dictionary)
-        if 'exclude' in dictionary:
-            if not isinstance(dictionary['exclude'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exclude']))
-            value = PaymentProductFilter()
-            self.exclude = value.from_dictionary(dictionary['exclude'])
-        if 'restrictTo' in dictionary:
-            if not isinstance(dictionary['restrictTo'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['restrictTo']))
-            value = PaymentProductFilter()
-            self.restrict_to = value.from_dictionary(dictionary['restrictTo'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_product_filters_hosted_checkout.py

@@ -1,84 +0,0 @@
-# -*- 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.payment_product_filter import PaymentProductFilter
-
-
-class PaymentProductFiltersHostedCheckout(DataObject):
-
-    __exclude: Optional[PaymentProductFilter] = None
-    __restrict_to: Optional[PaymentProductFilter] = None
-    __tokens_only: Optional[bool] = None
-
-    @property
-    def exclude(self) -> Optional[PaymentProductFilter]:
-        """
-        | Contains the payment product ids and payment product groups that should be excluded from the payment products available for the payment. Note that excluding a payment product will ensure exclusion, even if the payment product is also present in the restrictTo filter, and that excluding a payment product group will exclude all payment products that are a part of that group, even if one or more of them are present in the restrictTo filters.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
-        """
-        return self.__exclude
-
-    @exclude.setter
-    def exclude(self, value: Optional[PaymentProductFilter]) -> None:
-        self.__exclude = value
-
-    @property
-    def restrict_to(self) -> Optional[PaymentProductFilter]:
-        """
-        | Contains the payment product ids and payment product groups that should be at most contained in the payment products available for completing the payment. Note that the list of payment products available for completing the payment will only contain payment products present in these filters, but not all payment products in these filters might be present in the list. Some of them might not be allowed in context or they might be present in the exclude filters.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filter.PaymentProductFilter`
-        """
-        return self.__restrict_to
-
-    @restrict_to.setter
-    def restrict_to(self, value: Optional[PaymentProductFilter]) -> None:
-        self.__restrict_to = value
-
-    @property
-    def tokens_only(self) -> Optional[bool]:
-        """
-        * true - The customer may only complete the payment using one of the provided accounts on file.
-        * false -The customer can complete the payment using any way they like, as long as it is allowed in the payment context. Default.
-        
-        | Note that the request must contain at least one valid account on file with an allowed payment product (not excluded and allowed in context) if this property is set to true, else the request will fail.
-        
-        Type: bool
-        """
-        return self.__tokens_only
-
-    @tokens_only.setter
-    def tokens_only(self, value: Optional[bool]) -> None:
-        self.__tokens_only = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductFiltersHostedCheckout, self).to_dictionary()
-        if self.exclude is not None:
-            dictionary['exclude'] = self.exclude.to_dictionary()
-        if self.restrict_to is not None:
-            dictionary['restrictTo'] = self.restrict_to.to_dictionary()
-        if self.tokens_only is not None:
-            dictionary['tokensOnly'] = self.tokens_only
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFiltersHostedCheckout':
-        super(PaymentProductFiltersHostedCheckout, self).from_dictionary(dictionary)
-        if 'exclude' in dictionary:
-            if not isinstance(dictionary['exclude'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exclude']))
-            value = PaymentProductFilter()
-            self.exclude = value.from_dictionary(dictionary['exclude'])
-        if 'restrictTo' in dictionary:
-            if not isinstance(dictionary['restrictTo'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['restrictTo']))
-            value = PaymentProductFilter()
-            self.restrict_to = value.from_dictionary(dictionary['restrictTo'])
-        if 'tokensOnly' in dictionary:
-            self.tokens_only = dictionary['tokensOnly']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_product_group.py

@@ -1,159 +0,0 @@
-# -*- 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.account_on_file import AccountOnFile
-from worldline.connect.sdk.v1.domain.payment_product_display_hints import PaymentProductDisplayHints
-from worldline.connect.sdk.v1.domain.payment_product_field import PaymentProductField
-
-
-class PaymentProductGroup(DataObject):
-    """
-    | Definition of the details of a single payment product group
-    """
-
-    __accounts_on_file: Optional[List[AccountOnFile]] = None
-    __allows_installments: Optional[bool] = None
-    __device_fingerprint_enabled: Optional[bool] = None
-    __display_hints: Optional[PaymentProductDisplayHints] = None
-    __fields: Optional[List[PaymentProductField]] = None
-    __id: Optional[str] = None
-
-    @property
-    def accounts_on_file(self) -> Optional[List[AccountOnFile]]:
-        """
-        | Only populated in the Client API
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.account_on_file.AccountOnFile`]
-        """
-        return self.__accounts_on_file
-
-    @accounts_on_file.setter
-    def accounts_on_file(self, value: Optional[List[AccountOnFile]]) -> None:
-        self.__accounts_on_file = value
-
-    @property
-    def allows_installments(self) -> Optional[bool]:
-        """
-        | Indicates if the product supports installments
-        
-        * true - This payment supports installments
-        * false - This payment does not support installments
-        
-        Type: bool
-        """
-        return self.__allows_installments
-
-    @allows_installments.setter
-    def allows_installments(self, value: Optional[bool]) -> None:
-        self.__allows_installments = value
-
-    @property
-    def device_fingerprint_enabled(self) -> Optional[bool]:
-        """
-        | Indicates if device fingerprint is enabled for the product group
-        
-        * true
-        * false
-        
-        Type: bool
-        """
-        return self.__device_fingerprint_enabled
-
-    @device_fingerprint_enabled.setter
-    def device_fingerprint_enabled(self, value: Optional[bool]) -> None:
-        self.__device_fingerprint_enabled = value
-
-    @property
-    def display_hints(self) -> Optional[PaymentProductDisplayHints]:
-        """
-        | Object containing display hints like the order of the group when shown in a list, the name of the group and the logo. Note that the order of the group is the lowest order among the payment products that belong to the group.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_display_hints.PaymentProductDisplayHints`
-        """
-        return self.__display_hints
-
-    @display_hints.setter
-    def display_hints(self, value: Optional[PaymentProductDisplayHints]) -> None:
-        self.__display_hints = value
-
-    @property
-    def fields(self) -> Optional[List[PaymentProductField]]:
-        """
-        | Object containing all the fields and their details that are associated with this payment product group. If you are not interested in the these fields you can have us filter them out (using hide=fields in the query-string)
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_product_field.PaymentProductField`]
-        """
-        return self.__fields
-
-    @fields.setter
-    def fields(self, value: Optional[List[PaymentProductField]]) -> None:
-        self.__fields = value
-
-    @property
-    def id(self) -> Optional[str]:
-        """
-        | The ID of the payment product group in our system
-        
-        Type: str
-        """
-        return self.__id
-
-    @id.setter
-    def id(self, value: Optional[str]) -> None:
-        self.__id = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductGroup, self).to_dictionary()
-        if self.accounts_on_file is not None:
-            dictionary['accountsOnFile'] = []
-            for element in self.accounts_on_file:
-                if element is not None:
-                    dictionary['accountsOnFile'].append(element.to_dictionary())
-        if self.allows_installments is not None:
-            dictionary['allowsInstallments'] = self.allows_installments
-        if self.device_fingerprint_enabled is not None:
-            dictionary['deviceFingerprintEnabled'] = self.device_fingerprint_enabled
-        if self.display_hints is not None:
-            dictionary['displayHints'] = self.display_hints.to_dictionary()
-        if self.fields is not None:
-            dictionary['fields'] = []
-            for element in self.fields:
-                if element is not None:
-                    dictionary['fields'].append(element.to_dictionary())
-        if self.id is not None:
-            dictionary['id'] = self.id
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductGroup':
-        super(PaymentProductGroup, self).from_dictionary(dictionary)
-        if 'accountsOnFile' in dictionary:
-            if not isinstance(dictionary['accountsOnFile'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['accountsOnFile']))
-            self.accounts_on_file = []
-            for element in dictionary['accountsOnFile']:
-                value = AccountOnFile()
-                self.accounts_on_file.append(value.from_dictionary(element))
-        if 'allowsInstallments' in dictionary:
-            self.allows_installments = dictionary['allowsInstallments']
-        if 'deviceFingerprintEnabled' in dictionary:
-            self.device_fingerprint_enabled = dictionary['deviceFingerprintEnabled']
-        if 'displayHints' in dictionary:
-            if not isinstance(dictionary['displayHints'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
-            value = PaymentProductDisplayHints()
-            self.display_hints = value.from_dictionary(dictionary['displayHints'])
-        if 'fields' in dictionary:
-            if not isinstance(dictionary['fields'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['fields']))
-            self.fields = []
-            for element in dictionary['fields']:
-                value = PaymentProductField()
-                self.fields.append(value.from_dictionary(element))
-        if 'id' in dictionary:
-            self.id = dictionary['id']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_product_groups.py

@@ -1,47 +0,0 @@
-# -*- 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.payment_product_group import PaymentProductGroup
-
-
-class PaymentProductGroups(DataObject):
-
-    __payment_product_groups: Optional[List[PaymentProductGroup]] = None
-
-    @property
-    def payment_product_groups(self) -> Optional[List[PaymentProductGroup]]:
-        """
-        | Array containing payment product groups and their characteristics
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_product_group.PaymentProductGroup`]
-        """
-        return self.__payment_product_groups
-
-    @payment_product_groups.setter
-    def payment_product_groups(self, value: Optional[List[PaymentProductGroup]]) -> None:
-        self.__payment_product_groups = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductGroups, self).to_dictionary()
-        if self.payment_product_groups is not None:
-            dictionary['paymentProductGroups'] = []
-            for element in self.payment_product_groups:
-                if element is not None:
-                    dictionary['paymentProductGroups'].append(element.to_dictionary())
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductGroups':
-        super(PaymentProductGroups, self).from_dictionary(dictionary)
-        if 'paymentProductGroups' in dictionary:
-            if not isinstance(dictionary['paymentProductGroups'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['paymentProductGroups']))
-            self.payment_product_groups = []
-            for element in dictionary['paymentProductGroups']:
-                value = PaymentProductGroup()
-                self.payment_product_groups.append(value.from_dictionary(element))
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_product_networks_response.py

@@ -1,45 +0,0 @@
-# -*- 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 PaymentProductNetworksResponse(DataObject):
-
-    __networks: Optional[List[str]] = None
-
-    @property
-    def networks(self) -> Optional[List[str]]:
-        """
-        | Array containing network entries for a payment product. The strings that represent the networks in the array are identical to the strings that the payment product vendors use in their documentation.For instance: "Visa" for Google Pay <https://developer.apple.com/reference/passkit/pkpaymentnetwork>.
-        
-        Type: list[str]
-        """
-        return self.__networks
-
-    @networks.setter
-    def networks(self, value: Optional[List[str]]) -> None:
-        self.__networks = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductNetworksResponse, self).to_dictionary()
-        if self.networks is not None:
-            dictionary['networks'] = []
-            for element in self.networks:
-                if element is not None:
-                    dictionary['networks'].append(element)
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductNetworksResponse':
-        super(PaymentProductNetworksResponse, self).from_dictionary(dictionary)
-        if 'networks' in dictionary:
-            if not isinstance(dictionary['networks'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['networks']))
-            self.networks = []
-            for element in dictionary['networks']:
-                self.networks.append(element)
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_products.py

@@ -1,47 +0,0 @@
-# -*- 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.payment_product import PaymentProduct
-
-
-class PaymentProducts(DataObject):
-
-    __payment_products: Optional[List[PaymentProduct]] = None
-
-    @property
-    def payment_products(self) -> Optional[List[PaymentProduct]]:
-        """
-        | Array containing payment products and their characteristics
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_product.PaymentProduct`]
-        """
-        return self.__payment_products
-
-    @payment_products.setter
-    def payment_products(self, value: Optional[List[PaymentProduct]]) -> None:
-        self.__payment_products = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProducts, self).to_dictionary()
-        if self.payment_products is not None:
-            dictionary['paymentProducts'] = []
-            for element in self.payment_products:
-                if element is not None:
-                    dictionary['paymentProducts'].append(element.to_dictionary())
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProducts':
-        super(PaymentProducts, self).from_dictionary(dictionary)
-        if 'paymentProducts' in dictionary:
-            if not isinstance(dictionary['paymentProducts'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['paymentProducts']))
-            self.payment_products = []
-            for element in dictionary['paymentProducts']:
-                value = PaymentProduct()
-                self.payment_products.append(value.from_dictionary(element))
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_references.py

@@ -1,146 +0,0 @@
-# -*- 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 PaymentReferences(DataObject):
-
-    __merchant_order_id: Optional[int] = None
-    __merchant_reference: Optional[str] = None
-    __payment_reference: Optional[str] = None
-    __provider_id: Optional[str] = None
-    __provider_merchant_id: Optional[str] = None
-    __provider_reference: Optional[str] = None
-    __reference_orig_payment: Optional[str] = None
-
-    @property
-    def merchant_order_id(self) -> Optional[int]:
-        """
-        | Your order ID for this transaction that is also returned in our report files
-        
-        Type: int
-        """
-        return self.__merchant_order_id
-
-    @merchant_order_id.setter
-    def merchant_order_id(self, value: Optional[int]) -> None:
-        self.__merchant_order_id = value
-
-    @property
-    def merchant_reference(self) -> Optional[str]:
-        """
-        | Your unique reference of the transaction that is also returned in our report files. This is almost always used for your reconciliation of our report files.
-        
-        Type: str
-        """
-        return self.__merchant_reference
-
-    @merchant_reference.setter
-    def merchant_reference(self, value: Optional[str]) -> None:
-        self.__merchant_reference = value
-
-    @property
-    def payment_reference(self) -> Optional[str]:
-        """
-        | Payment Reference generated by WebCollect
-        
-        Type: str
-        """
-        return self.__payment_reference
-
-    @payment_reference.setter
-    def payment_reference(self, value: Optional[str]) -> None:
-        self.__payment_reference = value
-
-    @property
-    def provider_id(self) -> Optional[str]:
-        """
-        | Provides an additional means of reconciliation for Gateway merchants
-        
-        Type: str
-        """
-        return self.__provider_id
-
-    @provider_id.setter
-    def provider_id(self, value: Optional[str]) -> None:
-        self.__provider_id = value
-
-    @property
-    def provider_merchant_id(self) -> Optional[str]:
-        """
-        | Provides an additional means of reconciliation, this is the MerchantId used at the provider
-        
-        Type: str
-        """
-        return self.__provider_merchant_id
-
-    @provider_merchant_id.setter
-    def provider_merchant_id(self, value: Optional[str]) -> None:
-        self.__provider_merchant_id = value
-
-    @property
-    def provider_reference(self) -> Optional[str]:
-        """
-        | Provides an additional means of reconciliation for Gateway merchants
-        
-        Type: str
-        """
-        return self.__provider_reference
-
-    @provider_reference.setter
-    def provider_reference(self, value: Optional[str]) -> None:
-        self.__provider_reference = value
-
-    @property
-    def reference_orig_payment(self) -> Optional[str]:
-        """
-        | When you did not supply a merchantReference for your payment, you need to fill this property with the reference of the original payment when you want to refund it
-        
-        Type: str
-        """
-        return self.__reference_orig_payment
-
-    @reference_orig_payment.setter
-    def reference_orig_payment(self, value: Optional[str]) -> None:
-        self.__reference_orig_payment = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentReferences, self).to_dictionary()
-        if self.merchant_order_id is not None:
-            dictionary['merchantOrderId'] = self.merchant_order_id
-        if self.merchant_reference is not None:
-            dictionary['merchantReference'] = self.merchant_reference
-        if self.payment_reference is not None:
-            dictionary['paymentReference'] = self.payment_reference
-        if self.provider_id is not None:
-            dictionary['providerId'] = self.provider_id
-        if self.provider_merchant_id is not None:
-            dictionary['providerMerchantId'] = self.provider_merchant_id
-        if self.provider_reference is not None:
-            dictionary['providerReference'] = self.provider_reference
-        if self.reference_orig_payment is not None:
-            dictionary['referenceOrigPayment'] = self.reference_orig_payment
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentReferences':
-        super(PaymentReferences, self).from_dictionary(dictionary)
-        if 'merchantOrderId' in dictionary:
-            self.merchant_order_id = dictionary['merchantOrderId']
-        if 'merchantReference' in dictionary:
-            self.merchant_reference = dictionary['merchantReference']
-        if 'paymentReference' in dictionary:
-            self.payment_reference = dictionary['paymentReference']
-        if 'providerId' in dictionary:
-            self.provider_id = dictionary['providerId']
-        if 'providerMerchantId' in dictionary:
-            self.provider_merchant_id = dictionary['providerMerchantId']
-        if 'providerReference' in dictionary:
-            self.provider_reference = dictionary['providerReference']
-        if 'referenceOrigPayment' in dictionary:
-            self.reference_orig_payment = dictionary['referenceOrigPayment']
-        return self