connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/riskassessments/riskassessments_client.py

@@ -1,93 +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.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.risk_assessment_bank_account import RiskAssessmentBankAccount
-from worldline.connect.sdk.v1.domain.risk_assessment_card import RiskAssessmentCard
-from worldline.connect.sdk.v1.domain.risk_assessment_response import RiskAssessmentResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class RiskassessmentsClient(ApiResource):
-    """
-    Riskassessments 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(RiskassessmentsClient, self).__init__(parent=parent, path_context=path_context)
-
-    def bankaccounts(self, body: RiskAssessmentBankAccount, context: Optional[CallContext] = None) -> RiskAssessmentResponse:
-        """
-        Resource /{merchantId}/riskassessments/bankaccounts - Risk-assess bankaccount
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/riskassessments/bankaccounts.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.risk_assessment_bank_account.RiskAssessmentBankAccount`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.risk_assessment_response.RiskAssessmentResponse`
-        :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}/riskassessments/bankaccounts", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    RiskAssessmentResponse,
-                    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 cards(self, body: RiskAssessmentCard, context: Optional[CallContext] = None) -> RiskAssessmentResponse:
-        """
-        Resource /{merchantId}/riskassessments/cards - Risk-assess card
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/riskassessments/cards.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.risk_assessment_card.RiskAssessmentCard`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.risk_assessment_response.RiskAssessmentResponse`
-        :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}/riskassessments/cards", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    RiskAssessmentResponse,
-                    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/services/convert_amount_params.py

@@ -1,73 +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 ConvertAmountParams(ParamRequest):
-    """
-    Query parameters for Convert amount
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/convertAmount.html
-    """
-
-    __source: Optional[str] = None
-    __target: Optional[str] = None
-    __amount: Optional[int] = None
-
-    @property
-    def source(self) -> Optional[str]:
-        """
-        | Three-letter ISO currency code representing the source currency
-        
-        Type: str
-        """
-        return self.__source
-
-    @source.setter
-    def source(self, value: Optional[str]) -> None:
-        self.__source = value
-
-    @property
-    def target(self) -> Optional[str]:
-        """
-        | Three-letter ISO currency code representing the target currency
-        
-        Type: str
-        """
-        return self.__target
-
-    @target.setter
-    def target(self, value: Optional[str]) -> None:
-        self.__target = value
-
-    @property
-    def amount(self) -> Optional[int]:
-        """
-        | Amount to be converted in cents and always having 2 decimals
-        
-        Type: int
-        """
-        return self.__amount
-
-    @amount.setter
-    def amount(self, value: Optional[int]) -> None:
-        self.__amount = value
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.source is not None:
-            result.append(RequestParam("source", self.source))
-        if self.target is not None:
-            result.append(RequestParam("target", self.target))
-        if self.amount is not None:
-            result.append(RequestParam("amount", str(self.amount)))
-        return result

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/services/privacypolicy_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 PrivacypolicyParams(ParamRequest):
-    """
-    Query parameters for Get privacy policy
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/privacypolicy.html
-    """
-
-    __locale: Optional[str] = None
-    __payment_product_id: Optional[int] = None
-
-    @property
-    def locale(self) -> Optional[str]:
-        """
-        | Locale in which the privacy policy should be returned. Uses your default locale when none is provided.
-        
-        Type: str
-        """
-        return self.__locale
-
-    @locale.setter
-    def locale(self, value: Optional[str]) -> None:
-        self.__locale = value
-
-    @property
-    def payment_product_id(self) -> Optional[int]:
-        """
-        | ID of the payment product for which you wish to retrieve the privacy policy. When no ID is provided you will receive all privacy policies for your payment products.
-        
-        Type: int
-        """
-        return self.__payment_product_id
-
-    @payment_product_id.setter
-    def payment_product_id(self, value: Optional[int]) -> None:
-        self.__payment_product_id = value
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.locale is not None:
-            result.append(RequestParam("locale", self.locale))
-        if self.payment_product_id is not None:
-            result.append(RequestParam("paymentProductId", str(self.payment_product_id)))
-        return result

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/merchant/services/services_client.py

@@ -1,194 +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.bank_details_request import BankDetailsRequest
-from worldline.connect.sdk.v1.domain.bank_details_response import BankDetailsResponse
-from worldline.connect.sdk.v1.domain.convert_amount import ConvertAmount
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.get_iin_details_request import GetIINDetailsRequest
-from worldline.connect.sdk.v1.domain.get_iin_details_response import GetIINDetailsResponse
-from worldline.connect.sdk.v1.domain.get_privacy_policy_response import GetPrivacyPolicyResponse
-from worldline.connect.sdk.v1.domain.test_connection import TestConnection
-from worldline.connect.sdk.v1.merchant.services.convert_amount_params import ConvertAmountParams
-from worldline.connect.sdk.v1.merchant.services.privacypolicy_params import PrivacypolicyParams
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class ServicesClient(ApiResource):
-    """
-    Services 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(ServicesClient, self).__init__(parent=parent, path_context=path_context)
-
-    def convert_amount(self, query: ConvertAmountParams, context: Optional[CallContext] = None) -> ConvertAmount:
-        """
-        Resource /{merchantId}/services/convert/amount - Convert amount
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/convertAmount.html
-
-        :param query:    :class:`worldline.connect.sdk.v1.merchant.services.convert_amount_params.ConvertAmountParams`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.convert_amount.ConvertAmount`
-        :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}/services/convert/amount", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    query,
-                    ConvertAmount,
-                    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 bankaccount(self, body: BankDetailsRequest, context: Optional[CallContext] = None) -> BankDetailsResponse:
-        """
-        Resource /{merchantId}/services/convert/bankaccount - Convert bankaccount
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/bankaccount.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.bank_details_request.BankDetailsRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.bank_details_response.BankDetailsResponse`
-        :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}/services/convert/bankaccount", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    BankDetailsResponse,
-                    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_iin_details(self, body: GetIINDetailsRequest, context: Optional[CallContext] = None) -> GetIINDetailsResponse:
-        """
-        Resource /{merchantId}/services/getIINdetails - Get IIN details
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/getIINdetails.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.get_iin_details_request.GetIINDetailsRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.get_iin_details_response.GetIINDetailsResponse`
-        :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}/services/getIINdetails", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    GetIINDetailsResponse,
-                    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 privacypolicy(self, query: PrivacypolicyParams, context: Optional[CallContext] = None) -> GetPrivacyPolicyResponse:
-        """
-        Resource /{merchantId}/services/privacypolicy - Get privacy policy
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/privacypolicy.html
-
-        :param query:    :class:`worldline.connect.sdk.v1.merchant.services.privacypolicy_params.PrivacypolicyParams`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.get_privacy_policy_response.GetPrivacyPolicyResponse`
-        :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}/services/privacypolicy", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    query,
-                    GetPrivacyPolicyResponse,
-                    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 testconnection(self, context: Optional[CallContext] = None) -> TestConnection:
-        """
-        Resource /{merchantId}/services/testconnection - Test connection
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/services/testconnection.html
-
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.test_connection.TestConnection`
-        :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}/services/testconnection", None)
-        try:
-            return self._communicator.get(
-                    uri,
-                    self._client_headers,
-                    None,
-                    TestConnection,
-                    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/sessions/sessions_client.py

@@ -1,59 +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.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.session_request import SessionRequest
-from worldline.connect.sdk.v1.domain.session_response import SessionResponse
-from worldline.connect.sdk.v1.exception_factory import create_exception
-
-
-class SessionsClient(ApiResource):
-    """
-    Sessions 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(SessionsClient, self).__init__(parent=parent, path_context=path_context)
-
-    def create(self, body: SessionRequest, context: Optional[CallContext] = None) -> SessionResponse:
-        """
-        Resource /{merchantId}/sessions - Create session
-        
-        See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/sessions/create.html
-
-        :param body:     :class:`worldline.connect.sdk.v1.domain.session_request.SessionRequest`
-        :param context:  :class:`worldline.connect.sdk.call_context.CallContext`
-        :return: :class:`worldline.connect.sdk.v1.domain.session_response.SessionResponse`
-        :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}/sessions", None)
-        try:
-            return self._communicator.post(
-                    uri,
-                    self._client_headers,
-                    None,
-                    body,
-                    SessionResponse,
-                    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/tokens/delete_token_params.py

@@ -1,42 +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 DeleteTokenParams(ParamRequest):
-    """
-    Query parameters for Delete token
-    
-    See also https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/tokens/delete.html
-    """
-
-    __mandate_cancel_date: Optional[str] = None
-
-    @property
-    def mandate_cancel_date(self) -> Optional[str]:
-        """
-        | Date of the mandate cancellation
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__mandate_cancel_date
-
-    @mandate_cancel_date.setter
-    def mandate_cancel_date(self, value: Optional[str]) -> None:
-        self.__mandate_cancel_date = value
-
-    def to_request_parameters(self) -> List[RequestParam]:
-        """
-        :return: list[RequestParam]
-        """
-        result = []
-        if self.mandate_cancel_date is not None:
-            result.append(RequestParam("mandateCancelDate", self.mandate_cancel_date))
-        return result