connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/payouts/find_payouts_params.py

@@ -1,89 +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 FindPayoutsParams(ParamRequest):
-    """
-    Query parameters for Find payouts
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payouts/find.html
-    """
-
-    __merchant_reference: Optional[str] = None
-    __merchant_order_id: Optional[int] = None
-    __offset: Optional[int] = None
-    __limit: Optional[int] = None
-
-    @property
-    def merchant_reference(self) -> Optional[str]:
-        """
-        | Your unique transaction reference to filter on.
-        
-        Type: str
-        """
-        return self.__merchant_reference
-
-    @merchant_reference.setter
-    def merchant_reference(self, value: Optional[str]) -> None:
-        self.__merchant_reference = value
-
-    @property
-    def merchant_order_id(self) -> Optional[int]:
-        """
-        | Your order identifier to filter on.
-        
-        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 offset(self) -> Optional[int]:
-        """
-        | The zero-based index of the first payout in the result. If omitted, the offset will be 0.
-        
-        Type: int
-        """
-        return self.__offset
-
-    @offset.setter
-    def offset(self, value: Optional[int]) -> None:
-        self.__offset = value
-
-    @property
-    def limit(self) -> Optional[int]:
-        """
-        | The maximum number of payouts to return, with a maximum of 100. If omitted, the limit will be 10.
-        
-        Type: int
-        """
-        return self.__limit
-
-    @limit.setter
-    def limit(self, value: Optional[int]) -> None:
-        self.__limit = value
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.merchant_reference is not None:
-            result.append(RequestParam("merchantReference", self.merchant_reference))
-        if self.merchant_order_id is not None:
-            result.append(RequestParam("merchantOrderId", str(self.merchant_order_id)))
-        if self.offset is not None:
-            result.append(RequestParam("offset", str(self.offset)))
-        if self.limit is not None:
-            result.append(RequestParam("limit", str(self.limit)))
-        return result

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/payouts/payouts_client.py

@@ -1,240 +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.approve_payout_request import ApprovePayoutRequest
-from worldline.connect.sdk.v1.domain.create_payout_request import CreatePayoutRequest
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.find_payouts_response import FindPayoutsResponse
-from worldline.connect.sdk.v1.domain.payout_error_response import PayoutErrorResponse
-from worldline.connect.sdk.v1.domain.payout_response import PayoutResponse
-from worldline.connect.sdk.v1.merchant.payouts.find_payouts_params import FindPayoutsParams
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class PayoutsClient(ApiResource):
-    """
-    Payouts 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(PayoutsClient, self).__init__(parent=parent, path_context=path_context)
-
-    def create(self, body: CreatePayoutRequest, context: Optional[CallContext] = None) -> PayoutResponse:
-        """
-        Resource /{merchantId}/payouts - Create payout
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payouts/create.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.create_payout_request.CreatePayoutRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.payout_response.PayoutResponse`
-        :raise: DeclinedPayoutException if the Worldline Global Collect platform declined / rejected the payout. The payout result will be available from the exception.
-        :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}/payouts", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    PayoutResponse,
-                    context)
-
-        except ResponseException as e:
-            error_type = PayoutErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise create_exception(e.status_code, e.body, error_object, context)
-
-    def find(self, query: FindPayoutsParams, context: Optional[CallContext] = None) -> FindPayoutsResponse:
-        """
-        Resource /{merchantId}/payouts - Find payouts
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payouts/find.html
-
-        :param query:    :class:`worldline.connect.sdk.v1.merchant.payouts.find_payouts_params.FindPayoutsParams`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.find_payouts_response.FindPayoutsResponse`
-        :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}/payouts", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    query,
-                    FindPayoutsResponse,
-                    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, payout_id: str, context: Optional[CallContext] = None) -> PayoutResponse:
-        """
-        Resource /{merchantId}/payouts/{payoutId} - Get payout
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payouts/get.html
-
-        :param payout_id:  str
-        :param context:    :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.payout_response.PayoutResponse`
-        :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 = {
-            "payoutId": payout_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/payouts/{payoutId}", path_context)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    PayoutResponse,
-                    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 approve(self, payout_id: str, body: ApprovePayoutRequest, context: Optional[CallContext] = None) -> PayoutResponse:
-        """
-        Resource /{merchantId}/payouts/{payoutId}/approve - Approve payout
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payouts/approve.html
-
-        :param payout_id:  str
-        :param body:       :class:`worldline.connect.sdk.v1.domain.approve_payout_request.ApprovePayoutRequest`
-        :param context:    :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.payout_response.PayoutResponse`
-        :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 = {
-            "payoutId": payout_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/payouts/{payoutId}/approve", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    PayoutResponse,
-                    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 cancel(self, payout_id: str, context: Optional[CallContext] = None) -> None:
-        """
-        Resource /{merchantId}/payouts/{payoutId}/cancel - Cancel payout
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payouts/cancel.html
-
-        :param payout_id:  str
-        :param context:    :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: None
-        :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 = {
-            "payoutId": payout_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/payouts/{payoutId}/cancel", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    None,
-                    None,
-                    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 cancelapproval(self, payout_id: str, context: Optional[CallContext] = None) -> None:
-        """
-        Resource /{merchantId}/payouts/{payoutId}/cancelapproval - Undo approve payout
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payouts/cancelapproval.html
-
-        :param payout_id:  str
-        :param context:    :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: None
-        :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 = {
-            "payoutId": payout_id,
-        }
-        uri = self._instantiate_uri("/v1/{merchantId}/payouts/{payoutId}/cancelapproval", path_context)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    None,
-                    None,
-                    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/productgroups/find_productgroups_params.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.communication.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class FindProductgroupsParams(ParamRequest):
-    """
-    Query parameters for Get payment product groups
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/productgroups/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 of the transaction
-        
-        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 set up 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 of the transaction 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 groups based on their support for recurring, where a group supports recurring if it has at least one payment product that supports recurring
-        
-        * true
-        * false
-        
-        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)
-
-    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/productgroups/get_productgroup_params.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.communication.param_request import ParamRequest
-from worldline.connect.sdk.communication.request_param import RequestParam
-
-
-class GetProductgroupParams(ParamRequest):
-    """
-    Query parameters for Get payment product group
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/productgroups/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
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | ISO 3166-1 alpha-2 country code of the transaction
-        
-        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  of the transaction 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]:
-        """
-        | Toggles filtering on support for recurring payments. Default value is false.
-        
-        * true - filter out groups that do not support recurring payments, where a group supports recurring payments if it has at least one payment product that supports recurring.
-        * false - do not filter
-        
-        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)
-
-    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