connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -0,0 +1,95 @@
+#
+# 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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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.1/worldline/connect/sdk/v1/merchant/services/convert_amount_params.py

@@ -0,0 +1,73 @@
+# -*- 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.1/worldline/connect/sdk/v1/merchant/services/privacypolicy_params.py

@@ -0,0 +1,57 @@
+# -*- 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.1/worldline/connect/sdk/v1/merchant/services/services_client.py

@@ -0,0 +1,199 @@
+#
+# 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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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.1/worldline/connect/sdk/v1/merchant/sessions/sessions_client.py

@@ -0,0 +1,60 @@
+#
+# 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 IdempotenceException: if an idempotent request caused a conflict (HTTP status code 409)
+        :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.1/worldline/connect/sdk/v1/merchant/tokens/delete_token_params.py

@@ -0,0 +1,42 @@
+# -*- 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