onlinepayments-sdk-python3 4.22.0__zip → 5.0.0__zip

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/merchant/services/services_client.py

@@ -1,187 +0,0 @@
-#
-# This class was auto-generated.
-#
-from onlinepayments.sdk.api_resource import ApiResource
-from onlinepayments.sdk.call_context import CallContext
-from onlinepayments.sdk.response_exception import ResponseException
-from onlinepayments.sdk.domain.calculate_surcharge_request import CalculateSurchargeRequest
-from onlinepayments.sdk.domain.calculate_surcharge_response import CalculateSurchargeResponse
-from onlinepayments.sdk.domain.currency_conversion_request import CurrencyConversionRequest
-from onlinepayments.sdk.domain.currency_conversion_response import CurrencyConversionResponse
-from onlinepayments.sdk.domain.error_response import ErrorResponse
-from onlinepayments.sdk.domain.get_iin_details_request import GetIINDetailsRequest
-from onlinepayments.sdk.domain.get_iin_details_response import GetIINDetailsResponse
-from onlinepayments.sdk.domain.get_privacy_policy_response import GetPrivacyPolicyResponse
-from onlinepayments.sdk.domain.test_connection import TestConnection
-from onlinepayments.sdk.merchant.services.get_privacy_policy_params import GetPrivacyPolicyParams
-from onlinepayments.sdk.merchant.services.i_services_client import IServicesClient
-
-
-class ServicesClient(ApiResource, IServicesClient):
-    """
-    Services client. Thread-safe.
-    """
-
-    def __init__(self, parent, path_context):
-        """
-        :param parent:       :class:`onlinepayments.sdk.api_resource.ApiResource`
-        :param path_context: dict[str, str]
-        """
-        super(ServicesClient, self).__init__(parent, path_context)
-
-    def surcharge_calculation(self, body: CalculateSurchargeRequest, context: CallContext = None) -> CalculateSurchargeResponse:
-        """
-        Resource /v2/{merchantId}/services/surchargecalculation - Surcharge Calculation
-
-
-        :param body: :class:`onlinepayments.sdk.domain.calculate_surcharge_request.CalculateSurchargeRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.calculate_surcharge_response.CalculateSurchargeResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        uri = self._instantiate_uri("/v2/{merchantId}/services/surchargecalculation", None)
-        try:
-            return self._communicator.post(
-                uri,
-                self._client_headers,
-                None,
-                body,
-                CalculateSurchargeResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get_dcc_rate_inquiry(self, body: CurrencyConversionRequest, context: CallContext = None) -> CurrencyConversionResponse:
-        """
-        Resource /v2/{merchantId}/services/dccrate - Get Dcc Rate Inquiry Api
-
-
-        :param body: :class:`onlinepayments.sdk.domain.currency_conversion_request.CurrencyConversionRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.domain.currency_conversion_response.CurrencyConversionResponse`
-        :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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        uri = self._instantiate_uri("/v2/{merchantId}/services/dccrate", None)
-        try:
-            return self._communicator.post(
-                uri,
-                self._client_headers,
-                None,
-                body,
-                CurrencyConversionResponse,
-                context)
-
-        except ResponseException as e:
-            error_type = ErrorResponse
-            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
-            raise self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get_privacy_policy(self, query: GetPrivacyPolicyParams, context: CallContext = None) -> GetPrivacyPolicyResponse:
-        """
-        Resource /v2/{merchantId}/services/privacypolicy - Get Privacy Policy
-
-
-        :param query: :class:`onlinepayments.sdk.merchant.services.get_privacy_policy_params.GetPrivacyPolicyParams`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        uri = self._instantiate_uri("/v2/{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 self._create_exception(e.status_code, e.body, error_object, context)
-
-    def test_connection(self, context: CallContext = None) -> TestConnection:
-        """
-        Resource /v2/{merchantId}/services/testconnection - Test connection
-
-
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        uri = self._instantiate_uri("/v2/{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 self._create_exception(e.status_code, e.body, error_object, context)
-
-    def get_iin_details(self, body: GetIINDetailsRequest, context: CallContext = None) -> GetIINDetailsResponse:
-        """
-        Resource /v2/{merchantId}/services/getIINdetails - Get IIN details
-
-
-        :param body: :class:`onlinepayments.sdk.domain.get_iin_details_request.GetIINDetailsRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        uri = self._instantiate_uri("/v2/{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 self._create_exception(e.status_code, e.body, error_object, context)

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/merchant/sessions/sessions_client.py

@@ -1,55 +0,0 @@
-#
-# This class was auto-generated.
-#
-from onlinepayments.sdk.api_resource import ApiResource
-from onlinepayments.sdk.call_context import CallContext
-from onlinepayments.sdk.response_exception import ResponseException
-from onlinepayments.sdk.domain.error_response import ErrorResponse
-from onlinepayments.sdk.domain.session_request import SessionRequest
-from onlinepayments.sdk.domain.session_response import SessionResponse
-from onlinepayments.sdk.merchant.sessions.i_sessions_client import ISessionsClient
-
-
-class SessionsClient(ApiResource, ISessionsClient):
-    """
-    Sessions client. Thread-safe.
-    """
-
-    def __init__(self, parent, path_context):
-        """
-        :param parent:       :class:`onlinepayments.sdk.api_resource.ApiResource`
-        :param path_context: dict[str, str]
-        """
-        super(SessionsClient, self).__init__(parent, path_context)
-
-    def create_session(self, body: SessionRequest, context: CallContext = None) -> SessionResponse:
-        """
-        Resource /v2/{merchantId}/sessions - Create session
-
-
-        :param body: :class:`onlinepayments.sdk.domain.session_request.SessionRequest`
-        :param context: :class:`onlinepayments.sdk.call_context.CallContext`
-        :return: :class:`onlinepayments.sdk.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: PaymentPlatformException if something went wrong at the payment platform,
-                   the payment 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 payment platform returned any other error
-        """
-        uri = self._instantiate_uri("/v2/{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 self._create_exception(e.status_code, e.body, error_object, context)

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/multipart_form_data_request.py

@@ -1,10 +0,0 @@
-class MultipartFormDataRequest:
-    """
-    A representation of a multipart/form-data request.
-    """
-
-    def to_multipart_form_data_object(self):
-        """
-        :return: :class:`ingenico.connect.sdk.MultipartFormDataObject`
-        """
-        raise NotImplementedError

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/param_request.py

@@ -1,13 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class ParamRequest(ABC):
-    """
-    Represents a set of request parameters.
-    """
-
-    @abstractmethod
-    def to_request_parameters(self):
-        """
-        :return: list[:class:`onlinepayments.sdk.RequestParam`] representing the HTTP request parameters
-        """

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/payment_platform_exception.py

@@ -1,11 +0,0 @@
-from onlinepayments.sdk.api_exception import ApiException
-
-
-class PaymentPlatformException(ApiException):
-    """
-    Represents an error response from the payment platform when something
-    went wrong at the payment platform or further downstream.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors, message="the Online Payments platform returned an error response"):
-        super(PaymentPlatformException, self).__init__(status_code, response_body, error_id, errors, message)

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/reference_exception.py

@@ -1,12 +0,0 @@
-from onlinepayments.sdk.api_exception import ApiException
-
-
-class ReferenceException(ApiException):
-    """
-    Represents an error response from the Online Payments platform when a
-    non-existing or removed object is trying to be accessed.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors,
-                 message="the Online Payments platform returned a reference error response"):
-        super(ReferenceException, self).__init__(status_code, response_body, error_id, errors, message)

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/response_header.py

@@ -1,25 +0,0 @@
-from typing import Dict, Optional, Tuple
-
-
-def get_header_value(headers: Dict[str, str], header_name: str) -> Optional[str]:
-    """
-    :return: The value of the header with the given name, or None if there was no such header.
-    """
-    if headers is None:
-        return None
-    for name, value in headers.items():
-        if name.lower() == header_name.lower():
-            return value
-    return None
-
-
-def get_header(headers: Dict[str, str], header_name: str) -> Optional[Tuple[str, str]]:
-    """
-    :return: The header with the given name as a tuple with the name and value, or None if there was no such header.
-    """
-    if headers is None:
-        return None
-    for name, value in headers.items():
-        if name.lower() == header_name.lower():
-            return name, value
-    return None

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/validation_exception.py

@@ -1,11 +0,0 @@
-from onlinepayments.sdk.api_exception import ApiException
-
-
-class ValidationException(ApiException):
-    """
-    Represents an error response from the Online Payments platform when validation of requests failed.
-    """
-
-    def __init__(self, status_code, response_body, error_id, errors,
-                 message="the Online Payments platform returned an incorrect request error response"):
-        super(ValidationException, self).__init__(status_code, response_body, error_id, errors, message)

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/webhooks/secret_key_not_available_exception.py

@@ -1,23 +0,0 @@
-from onlinepayments.sdk.webhooks.signature_validation_exception import SignatureValidationException
-
-
-class SecretKeyNotAvailableException(SignatureValidationException):
-    """
-    Represents an error that causes a secret key to not be available.
-    """
-
-    def __init__(self, param1, param2, cause=False):
-        if cause is False:
-            if isinstance(param2, str):
-                super(SecretKeyNotAvailableException, self).__init__(param1)
-                self.__key_id = param2
-            else:
-                super(SecretKeyNotAvailableException, self).__init__(param2)
-                self.__key_id = param1
-        else:
-            super(SecretKeyNotAvailableException, self).__init__(param1, cause)
-            self.__key_id = param2
-
-    @property
-    def key_id(self):
-        return self.__key_id

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/webhooks/signature_validation_exception.py

@@ -1,10 +0,0 @@
-class SignatureValidationException(RuntimeError):
-    """
-    Represents an error while validating webhooks signatures.
-    """
-
-    def __init__(self, param, cause=False):
-        if not cause:
-            super(SignatureValidationException, self).__init__(param)
-        else:
-            super(SignatureValidationException, self).__init__(param, cause)

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/webhooks/web_hooks.py

@@ -1,22 +0,0 @@
-from onlinepayments.sdk.defaultimpl.default_marshaller import DefaultMarshaller
-from onlinepayments.sdk.webhooks.web_hooks_helper_builder import WebhooksHelperBuilder
-
-
-class Webhooks:
-    """
-    Online Payments platform factory for several webhooks components.
-    """
-
-    @staticmethod
-    def create_helper_builder(secret_key_store):
-        """
-        Creates a WebhooksHelperBuilder that will use the given SecretKeyStore.
-        """
-        return WebhooksHelperBuilder().with_marshaller(
-            DefaultMarshaller.INSTANCE()).with_secret_key_store(
-            secret_key_store)
-
-    @staticmethod
-    def create_helper(secret_key_store):
-        web_hooks_helper_builder = Webhooks.create_helper_builder(secret_key_store)
-        return web_hooks_helper_builder.build()

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/webhooks/web_hooks_helper.py

@@ -1,124 +0,0 @@
-import hashlib
-import hmac
-from base64 import b64encode
-from typing import List
-
-from onlinepayments.sdk.domain.web_hooks_event import WebhooksEvent
-from onlinepayments.sdk.marshaller import Marshaller
-from onlinepayments.sdk.request_header import RequestHeader
-from onlinepayments.sdk.webhooks.api_version_mismatch_exception import ApiVersionMismatchException
-from onlinepayments.sdk.webhooks.secret_key_store import SecretKeyStore
-from onlinepayments.sdk.webhooks.signature_validation_exception import SignatureValidationException
-
-
-class WebhooksHelper:
-    """
-    Online Payments platform webhooks helper.
-    """
-
-    def __init__(self, marshaller: Marshaller, secret_key_store: SecretKeyStore):
-        if marshaller is None:
-            raise ValueError("marshaller is requried")
-        if secret_key_store is None:
-            raise ValueError("secret_key_store is required")
-        self.__marshaller = marshaller
-        self.__secret_key_store = secret_key_store
-
-    # body as InputStream
-
-    def unmarshal(self, body, request_headers: List[RequestHeader]):
-        """
-        Unmarshals the given body, while also validating it using the given request headers.
-
-        :raise: SignatureValidationException: If the body could not be validated successfully.
-        :raise: ApiVersionMismatchException: If the resulting event has an API
-         version that this version of the SDK does not support.
-        :return: The body unmarshalled as a WebhooksEvent.
-        """
-        self._validate(body, request_headers)
-        event = self.__marshaller.unmarshal(body.decode("utf-8"), WebhooksEvent)
-        self.__validate_api_version(event)
-        return event
-
-    def _validate(self, body, request_headers):
-        """
-        Validates the given body using the given request headers.
-
-        :raise: SignatureValidationException: If the body could not be validated successfully.
-        """
-        self.__validate_body(body, request_headers)
-
-    # validation utility methods
-
-    def __validate_body(self, body, request_headers):
-        signature = self.__get_header_value(request_headers, "X-GCS-Signature")
-        key_id = self.__get_header_value(request_headers, "X-GCS-KeyId")
-        secret_key = self.__secret_key_store.get_secret_key(key_id)
-        unencoded_result = hmac.new(secret_key.encode("utf-8"), body, hashlib.sha256)
-        expected_signature = b64encode(unencoded_result.digest()).decode(
-            "utf-8").rstrip('\n')
-        is_valid = self.are_equal_signatures(signature, expected_signature)
-        if is_valid is False:
-            raise SignatureValidationException("failed to validate signature: '"
-                                               + signature + "' (" + str(len(signature)) + "), expected: '"
-                                               + expected_signature + "' (" + str(len(expected_signature)) + ").")
-
-    @staticmethod
-    def are_equal_signatures(signature, expected_signature):
-        # don't use a simple equals call, as that may leak timing information
-        # (it fails fast)
-        length = len(signature)
-        expected_length = len(expected_signature)
-
-        # always check at least 256 characters, to also not leak timing
-        # information about the length of the expected signature
-        limit = max(max(length, expected_length), 256)
-
-        result = True
-
-        # the loop below uses result &= false instead of result = false and
-        # result &= true instead of nothing because those might leak timing
-        # information
-        for i in range(0, limit):
-            if i < length and i < expected_length:
-                # both within string boundaries
-                result = result and (signature[i] == expected_signature[i])
-            elif i >= length and i >= expected_length:
-                # past both string boundaries
-                result = result and True
-            else:
-                # i >= length || i >= expected_length but not both
-                result = result and False
-
-        return result
-
-    # general utility methods
-
-    @staticmethod
-    def __validate_api_version(event):
-        if not "v1" == event.api_version:
-            raise ApiVersionMismatchException(event.api_version, "v1")
-
-    @staticmethod
-    def __get_header_value(request_headers, header_name: str):
-        value = None
-        for header in request_headers:
-            if header_name.lower() == header.name.lower():
-                if value is None:
-                    value = header.value
-                else:
-                    raise SignatureValidationException(
-                        "encountered multiple occurrences of header '" + header_name + "'")
-        if value is None:
-            raise SignatureValidationException(
-                "could not find header '" + header_name + "'")
-        return value
-
-    # Used for unit tests
-    @property
-    def marshaller(self) -> Marshaller:
-        return self.__marshaller
-
-    @property
-    def secret_key_store(self) -> SecretKeyStore:
-        return self.__secret_key_store

onlinepayments-sdk-python3-4.22.0/onlinepayments/sdk/webhooks/web_hooks_helper_builder.py

@@ -1,33 +0,0 @@
-from onlinepayments.sdk.marshaller import Marshaller
-from onlinepayments.sdk.webhooks.secret_key_store import SecretKeyStore
-from onlinepayments.sdk.webhooks.web_hooks_helper import WebhooksHelper
-
-
-class WebhooksHelperBuilder:
-    """
-    Builder for a WebhooksHelper object.
-    """
-    __marshaller = None
-    __secret_key_store = None
-
-    def with_marshaller(self, marshaller: Marshaller):
-        """
-        Sets the Marshaller to use.
-        """
-        self.__marshaller = marshaller
-        return self
-
-    def with_secret_key_store(self, secret_key_store: SecretKeyStore):
-        """
-        Sets the SecretKeyStore to use.
-        """
-        self.__secret_key_store = secret_key_store
-        return self
-
-    def build(self):
-        """
-        Creates a fully initialized WebhooksHelper object.
-
-        :raise: ValueError: if not all required components are set
-        """
-        return WebhooksHelper(self.__marshaller, self.__secret_key_store)