connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/productgroups/productgroups_client.py

@@ -1,135 +0,0 @@
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Mapping, Optional
-
-from worldline.connect.sdk.api_resource import ApiResource
-from worldline.connect.sdk.call_context import CallContext
-from worldline.connect.sdk.communication.response_exception import ResponseException
-from worldline.connect.sdk.v1.domain.device_fingerprint_request import DeviceFingerprintRequest
-from worldline.connect.sdk.v1.domain.device_fingerprint_response import DeviceFingerprintResponse
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.payment_product_group_response import PaymentProductGroupResponse
-from worldline.connect.sdk.v1.domain.payment_product_groups import PaymentProductGroups
-from worldline.connect.sdk.v1.merchant.productgroups.find_productgroups_params import FindProductgroupsParams
-from worldline.connect.sdk.v1.merchant.productgroups.get_productgroup_params import GetProductgroupParams
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class ProductgroupsClient(ApiResource):
-    """
-    Productgroups client. Thread-safe.
-    """
-
-    def __init__(self, parent: ApiResource, path_context: Optional[Mapping[str, str]]):
-        """
-        :param parent:       :class:`worldline.connect.sdk.api_resource.ApiResource`
-        :param path_context: Mapping[str, str]
-        """
-        super(ProductgroupsClient, self).__init__(parent=parent, path_context=path_context)
-
-    def find(self, query: FindProductgroupsParams, context: Optional[CallContext] = None) -> PaymentProductGroups:
-        """
-        Resource /{merchantId}/productgroups - Get payment product groups
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/productgroups/find.html
-
-        :param query:    :class:`worldline.connect.sdk.v1.merchant.productgroups.find_productgroups_params.FindProductgroupsParams`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.payment_product_groups.PaymentProductGroups`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        uri = self._instantiate_uri("/v1/{merchantId}/productgroups", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    query,
-                    PaymentProductGroups,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)
-
-    def get(self, payment_product_group_id: str, query: GetProductgroupParams, context: Optional[CallContext] = None) -> PaymentProductGroupResponse:
-        """
-        Resource /{merchantId}/productgroups/{paymentProductGroupId} - Get payment product group
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/productgroups/get.html
-
-        :param payment_product_group_id:  str
-        :param query:                     :class:`worldline.connect.sdk.v1.merchant.productgroups.get_productgroup_params.GetProductgroupParams`
-        :param context:                   :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.payment_product_group_response.PaymentProductGroupResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "paymentProductGroupId": payment_product_group_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/productgroups/{paymentProductGroupId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    query,
-                    PaymentProductGroupResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)
-
-    def device_fingerprint(self, payment_product_group_id: str, body: DeviceFingerprintRequest, context: Optional[CallContext] = None) -> DeviceFingerprintResponse:
-        """
-        Resource /{merchantId}/productgroups/{paymentProductGroupId}/deviceFingerprint - Get device fingerprint
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/productgroups/deviceFingerprint.html
-
-        :param payment_product_group_id:  str
-        :param body:                      :class:`worldline.connect.sdk.v1.domain.device_fingerprint_request.DeviceFingerprintRequest`
-        :param context:                   :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.device_fingerprint_response.DeviceFingerprintResponse`
-        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
-        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
-        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
-                   or there was a conflict (HTTP status code 404, 409 or 410)
-        :raise: PlatformException if something went wrong at the Worldline Global Collect platform,
-                   the Worldline Global Collect platform was unable to process a message from a downstream partner/acquirer,
-                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
-        :raise: ApiException if the Worldline Global Collect platform returned any other error
-        """
-        path_context = {
-            "paymentProductGroupId": payment_product_group_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/productgroups/{paymentProductGroupId}/deviceFingerprint", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    DeviceFingerprintResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/products/directory_params.py

@@ -1,57 +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.communication.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class DirectoryParams(ParamRequest):
-    """
-    Query parameters for Get payment product directory
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/products/directory.html
-    """
-
-    __country_code: Optional[str] = None
-    __currency_code: Optional[str] = None
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | ISO 3166-1 alpha-2 country code
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = value
-
-    @property
-    def currency_code(self) -> Optional[str]:
-        """
-        | Three-letter ISO currency code representing the currency of the transaction
-        
-        Type: str
-        """
-        return self.__currency_code
-
-    @currency_code.setter
-    def currency_code(self, value: Optional[str]) -> None:
-        self.__currency_code = value
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.country_code is not None:
-            result.append(RequestParam("countryCode", self.country_code))
-        if self.currency_code is not None:
-            result.append(RequestParam("currencyCode", self.currency_code))
-        return result

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/products/find_products_params.py

@@ -1,164 +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.communication.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class FindProductsParams(ParamRequest):
-    """
-    Query parameters for Get payment products
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/products/find.html
-    """
-
-    __country_code: Optional[str] = None
-    __currency_code: Optional[str] = None
-    __locale: Optional[str] = None
-    __amount: Optional[int] = None
-    __is_recurring: Optional[bool] = None
-    __is_installments: Optional[bool] = None
-    __hide: Optional[List[str]] = None
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | ISO 3166-1 alpha-2 country code
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = value
-
-    @property
-    def currency_code(self) -> Optional[str]:
-        """
-        | Three-letter ISO currency code representing the currency for the amount
-        
-        Type: str
-        """
-        return self.__currency_code
-
-    @currency_code.setter
-    def currency_code(self, value: Optional[str]) -> None:
-        self.__currency_code = value
-
-    @property
-    def locale(self) -> Optional[str]:
-        """
-        | Locale used in the GUI towards the consumer. Please make sure that a language pack is configured for the locale you are submitting. If you submit a locale that is not setup on your account we will use the default language pack for your account. You can easily upload additional language packs and set the default language pack in the Configuration Center.
-        
-        Type: str
-        """
-        return self.__locale
-
-    @locale.setter
-    def locale(self, value: Optional[str]) -> None:
-        self.__locale = value
-
-    @property
-    def amount(self) -> Optional[int]:
-        """
-        | Amount in cents and always having 2 decimals
-        
-        Type: int
-        """
-        return self.__amount
-
-    @amount.setter
-    def amount(self, value: Optional[int]) -> None:
-        self.__amount = value
-
-    @property
-    def is_recurring(self) -> Optional[bool]:
-        """
-        | This allows you to filter payment products based on their support for recurring or not
-        
-        * true
-        * false
-        
-        | If this is omitted all payment products are returned.
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value: Optional[bool]) -> None:
-        self.__is_recurring = value
-
-    @property
-    def is_installments(self) -> Optional[bool]:
-        """
-        | This allows you to filter payment products based on their support for installments or not
-        
-        * true
-        * false
-        
-        | If this is omitted all payment products are returned.
-        
-        Type: bool
-        """
-        return self.__is_installments
-
-    @is_installments.setter
-    def is_installments(self, value: Optional[bool]) -> None:
-        self.__is_installments = value
-
-    @property
-    def hide(self) -> Optional[List[str]]:
-        """
-        | Allows you to hide elements from the response, reducing the amount of data that needs to be returned to your client. Possible options are:
-        
-        * fields - Don't return any data on fields of the payment product
-        * accountsOnFile - Don't return any accounts on file data
-        * translations - Don't return any label texts associated with the payment products
-        * productsWithoutFields - Don't return products that require any additional data to be captured
-        * productsWithoutInstructions - Don't return products that show instructions
-        * productsWithRedirects - Don't return products that require a redirect to a 3rd party. Note that products that involve potential redirects related to 3D Secure authentication are not hidden
-        
-        Type: list[str]
-        """
-        return self.__hide
-
-    @hide.setter
-    def hide(self, value: Optional[List[str]]) -> None:
-        self.__hide = value
-
-    def add_hide(self, value: str) -> None:
-        """
-        :param value: str
-        """
-        if self.hide is None:
-            self.hide = []
-        self.hide.append(value)
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.country_code is not None:
-            result.append(RequestParam("countryCode", self.country_code))
-        if self.currency_code is not None:
-            result.append(RequestParam("currencyCode", self.currency_code))
-        if self.locale is not None:
-            result.append(RequestParam("locale", self.locale))
-        if self.amount is not None:
-            result.append(RequestParam("amount", str(self.amount)))
-        if self.is_recurring is not None:
-            result.append(RequestParam("isRecurring", str(self.is_recurring)))
-        if self.is_installments is not None:
-            result.append(RequestParam("isInstallments", str(self.is_installments)))
-        if self.hide is not None:
-            for hide_element in self.hide:
-                if hide_element is not None:
-                    result.append(RequestParam("hide", hide_element))
-        return result

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/products/get_product_params.py

@@ -1,177 +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.communication.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class GetProductParams(ParamRequest):
-    """
-    Query parameters for Get payment product
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/products/get.html
-    """
-
-    __country_code: Optional[str] = None
-    __currency_code: Optional[str] = None
-    __locale: Optional[str] = None
-    __amount: Optional[int] = None
-    __is_recurring: Optional[bool] = None
-    __is_installments: Optional[bool] = None
-    __hide: Optional[List[str]] = None
-    __force_basic_flow: Optional[bool] = None
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | ISO 3166-1 alpha-2 country code
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = value
-
-    @property
-    def currency_code(self) -> Optional[str]:
-        """
-        | Three-letter ISO currency code representing the currency for the amount
-        
-        Type: str
-        """
-        return self.__currency_code
-
-    @currency_code.setter
-    def currency_code(self, value: Optional[str]) -> None:
-        self.__currency_code = value
-
-    @property
-    def locale(self) -> Optional[str]:
-        """
-        | Locale used in the GUI towards the consumer. Please make sure that a language pack is configured for the locale you are submitting. If you submit a locale that is not setup on your account we will use the default language pack for your account. You can easily upload additional language packs and set the default language pack in the Configuration Center.
-        
-        Type: str
-        """
-        return self.__locale
-
-    @locale.setter
-    def locale(self, value: Optional[str]) -> None:
-        self.__locale = value
-
-    @property
-    def amount(self) -> Optional[int]:
-        """
-        | Amount in cents and always having 2 decimals
-        
-        Type: int
-        """
-        return self.__amount
-
-    @amount.setter
-    def amount(self, value: Optional[int]) -> None:
-        self.__amount = value
-
-    @property
-    def is_recurring(self) -> Optional[bool]:
-        """
-        | This allows you to filter payment products based on their support for recurring or not
-        
-        * true
-        * false
-        
-        | If this is omitted all payment products are returned.
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value: Optional[bool]) -> None:
-        self.__is_recurring = value
-
-    @property
-    def is_installments(self) -> Optional[bool]:
-        """
-        | This allows you to filter payment products based on their support for installments or not
-        
-        * true
-        * false
-        
-        | If this is omitted all payment products are returned.
-        
-        Type: bool
-        """
-        return self.__is_installments
-
-    @is_installments.setter
-    def is_installments(self, value: Optional[bool]) -> None:
-        self.__is_installments = value
-
-    @property
-    def hide(self) -> Optional[List[str]]:
-        """
-        | Allows you to hide elements from the response, reducing the amount of data that needs to be returned to your client. Possible options are:
-        
-        * fields - Don't return any data on fields of the payment product
-        * accountsOnFile - Don't return any accounts on file data
-        * translations - Don't return any label texts associated with the payment products
-        
-        Type: list[str]
-        """
-        return self.__hide
-
-    @hide.setter
-    def hide(self, value: Optional[List[str]]) -> None:
-        self.__hide = value
-
-    def add_hide(self, value: str) -> None:
-        """
-        :param value: str
-        """
-        if self.hide is None:
-            self.hide = []
-        self.hide.append(value)
-
-    @property
-    def force_basic_flow(self) -> Optional[bool]:
-        """
-        | Relevant only for payment product 3012 (Bancontact). A boolean that indicates if you want to force the response to return the fields of the basic flow. This can be useful in corner cases where you have enabled the enhanced flow which supports payment with the Bancontact app, but need access to the product fields without creating a payment first.
-        
-        Type: bool
-        """
-        return self.__force_basic_flow
-
-    @force_basic_flow.setter
-    def force_basic_flow(self, value: Optional[bool]) -> None:
-        self.__force_basic_flow = value
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.country_code is not None:
-            result.append(RequestParam("countryCode", self.country_code))
-        if self.currency_code is not None:
-            result.append(RequestParam("currencyCode", self.currency_code))
-        if self.locale is not None:
-            result.append(RequestParam("locale", self.locale))
-        if self.amount is not None:
-            result.append(RequestParam("amount", str(self.amount)))
-        if self.is_recurring is not None:
-            result.append(RequestParam("isRecurring", str(self.is_recurring)))
-        if self.is_installments is not None:
-            result.append(RequestParam("isInstallments", str(self.is_installments)))
-        if self.hide is not None:
-            for hide_element in self.hide:
-                if hide_element is not None:
-                    result.append(RequestParam("hide", hide_element))
-        if self.force_basic_flow is not None:
-            result.append(RequestParam("forceBasicFlow", str(self.force_basic_flow)))
-        return result

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/products/networks_params.py

@@ -1,92 +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.communication.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class NetworksParams(ParamRequest):
-    """
-    Query parameters for Get payment product networks
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/products/networks.html
-    """
-
-    __country_code: Optional[str] = None
-    __currency_code: Optional[str] = None
-    __amount: Optional[int] = None
-    __is_recurring: Optional[bool] = None
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | ISO 3166-1 alpha-2 country code
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = value
-
-    @property
-    def currency_code(self) -> Optional[str]:
-        """
-        | Three-letter ISO currency code representing the currency for the amount
-        
-        Type: str
-        """
-        return self.__currency_code
-
-    @currency_code.setter
-    def currency_code(self, value: Optional[str]) -> None:
-        self.__currency_code = value
-
-    @property
-    def amount(self) -> Optional[int]:
-        """
-        | Amount in cents and always having 2 decimals
-        
-        Type: int
-        """
-        return self.__amount
-
-    @amount.setter
-    def amount(self, value: Optional[int]) -> None:
-        self.__amount = value
-
-    @property
-    def is_recurring(self) -> Optional[bool]:
-        """
-        | This allows you to filter networks based on their support for recurring or not
-        
-        * true
-        * false
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value: Optional[bool]) -> None:
-        self.__is_recurring = value
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.country_code is not None:
-            result.append(RequestParam("countryCode", self.country_code))
-        if self.currency_code is not None:
-            result.append(RequestParam("currencyCode", self.currency_code))
-        if self.amount is not None:
-            result.append(RequestParam("amount", str(self.amount)))
-        if self.is_recurring is not None:
-            result.append(RequestParam("isRecurring", str(self.is_recurring)))
-        return result