onlinepayments-sdk-python3 7.4.1__py3-none-any.whl

onlinepayments/sdk/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#

onlinepayments/sdk/api_exception.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional, Sequence
+
+from onlinepayments.sdk.domain.api_error import APIError
+
+
+class ApiException(RuntimeError):
+    """
+    Represents an error response from the payment platform which contains an ID and a list of errors.
+    """
+
+    def __init__(self, status_code: int, response_body: str, error_id: Optional[str], errors: Optional[List[APIError]],
+                 message: str = "the payment platform returned an error response"):
+        super(ApiException, self).__init__(message)
+        self.__status_code = status_code
+        self.__response_body = response_body
+        self.__error_id = error_id
+        if errors is None:
+            self.__errors = ()
+        else:
+            self.__errors = errors
+
+    @property
+    def status_code(self) -> int:
+        """
+        :return: The HTTP status code that was returned by the Payment platform.
+        """
+        return self.__status_code
+
+    @property
+    def response_body(self) -> str:
+        """
+        :return: The raw response body that was returned by the Payment platform.
+        """
+        return self.__response_body
+
+    @property
+    def error_id(self) -> Optional[str]:
+        """
+        :return: The errorId received from the Payment platform if available.
+        """
+        return self.__error_id
+
+    @property
+    def errors(self) -> Sequence[APIError]:
+        """
+        :return: The errors received from the Payment platform if available. Never None.
+        """
+        return self.__errors
+
+    def __str__(self):
+        string = super(ApiException, self).__str__()
+        if self.__status_code > 0:
+            string += "; status_code=" + str(self.__status_code)
+        if self.__response_body:
+            string += "; response_body='" + self.__response_body + "'"
+        return str(string)

onlinepayments/sdk/api_resource.py

@@ -0,0 +1,57 @@
+from typing import Mapping, Sequence, Optional
+
+from .i_communicator import ICommunicator
+
+from onlinepayments.sdk.communication.request_header import RequestHeader
+
+
+class ApiResource(object):
+    """
+    Base class of all Online Payments platform API resources.
+    """
+
+    def __init__(self, parent: Optional['ApiResource'] = None, communicator: Optional[ICommunicator] = None,
+                 path_context: Optional[Mapping[str, str]] = None, client_meta_info: Optional[str] = None):
+        """
+        The parent and/or communicator must be given.
+        """
+        if not parent and not communicator:
+            raise ValueError("parent and/or communicator is required")
+        self.__parent = parent
+        self.__communicator = communicator if communicator else parent._communicator
+        self.__path_context = path_context
+        self.__client_meta_info = client_meta_info if client_meta_info or not parent else parent._client_meta_info
+
+    @property
+    def _communicator(self) -> ICommunicator:
+        return self.__communicator
+
+    @property
+    def _client_meta_info(self) -> str:
+        return self.__client_meta_info
+
+    @property
+    def _client_headers(self) -> Optional[Sequence[RequestHeader]]:
+        if self._client_meta_info is not None:
+            client_headers = [RequestHeader("X-GCS-ClientMetaInfo", self._client_meta_info)]
+            return client_headers
+        else:
+            return None
+
+    def _instantiate_uri(self, uri: str, path_context: Optional[Mapping[str, str]]) -> str:
+        uri = self.__replace_all(uri, path_context)
+        uri = self.__instantiate_uri(uri)
+        return uri
+
+    def __instantiate_uri(self, uri: str) -> str:
+        uri = self.__replace_all(uri, self.__path_context)
+        if self.__parent is not None:
+            uri = self.__parent.__instantiate_uri(uri)
+        return uri
+
+    @staticmethod
+    def __replace_all(uri: str, path_context: Optional[Mapping[str, str]]) -> str:
+        if path_context:
+            for key, value in path_context.items():
+                uri = uri.replace("{" + key + "}", value)
+        return uri

onlinepayments/sdk/authentication/authenticator.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Sequence
+from urllib.parse import ParseResult
+
+from onlinepayments.sdk.communication.request_header import RequestHeader
+
+
+class Authenticator(ABC):
+    """
+    Used to authenticate requests to the Online Payments platform.
+    """
+
+    @abstractmethod
+    def get_authorization(self, http_method: str, resource_uri: ParseResult,
+                          request_headers: Optional[Sequence[RequestHeader]]) -> str:
+        """
+        Returns a value that can be used for the "Authorization" header.
+
+        :param http_method: The HTTP method.
+        :param resource_uri: The URI of the resource.
+        :param request_headers: A sequence of RequestHeaders.
+         This sequence may not be modified and may not contain headers with the same name.
+        """
+        raise NotImplementedError

onlinepayments/sdk/authentication/authorization_type.py

@@ -0,0 +1,10 @@
+class AuthorizationType:
+    V1HMAC = "v1HMAC"
+    AUTHORIZATION_TYPES = [V1HMAC]
+
+    @staticmethod
+    def get_authorization(name: str) -> str:
+        if name in AuthorizationType.AUTHORIZATION_TYPES:
+            return name
+        else:
+            raise ValueError("Authorization '{}' not found".format(name))

onlinepayments/sdk/authentication/v1hmac_authenticator.py

@@ -0,0 +1,122 @@
+import hashlib
+import hmac
+from base64 import b64encode
+from operator import attrgetter
+from re import sub
+from typing import Optional, Sequence
+from urllib.parse import ParseResult
+
+from .authenticator import Authenticator
+
+from onlinepayments.sdk.authentication.authorization_type import AuthorizationType
+from onlinepayments.sdk.communicator_configuration import CommunicatorConfiguration
+from onlinepayments.sdk.communication.request_header import RequestHeader
+
+
+class V1HmacAuthenticator(Authenticator):
+    """
+    V1Hmac Authenticator implementation.
+    """
+
+    def __init__(self, communicator_configuration: CommunicatorConfiguration):
+        """
+        Constructs a new V1HmacAuthenticator instance using the provided CommunicatorConfiguration.
+
+        :param communicator_configuration: The configuration object containing the v1Hmac api key and api key secret
+         , connection timeout, and socket timeout. None of these can be None or empty,
+         and the timeout values must be positive.
+        """
+        Authenticator.__init__(self)
+
+        if not communicator_configuration.api_key_id:
+            raise ValueError("api_key_id is required")
+        if not communicator_configuration.secret_api_key:
+            raise ValueError("secret_api_key is required")
+        if communicator_configuration.authorization_type is None:
+            raise ValueError("authorization_type is required")
+        if communicator_configuration.connect_timeout <= 0:
+            raise ValueError("connect_timeout must be positive")
+        if communicator_configuration.socket_timeout <= 0:
+            raise ValueError("socket_timeout must be positive")
+
+        self.__api_id_key = communicator_configuration.api_key_id
+        self.__secret_api_key = communicator_configuration.secret_api_key
+        self.__authorization_type = AuthorizationType.get_authorization(communicator_configuration.authorization_type)
+        self.__connect_timeout = communicator_configuration.connect_timeout
+        self.__socket_timeout = communicator_configuration.socket_timeout
+        self.__proxy_configuration = communicator_configuration.proxy_configuration
+
+    def get_authorization(self, http_method: Optional[str], resource_uri: Optional[ParseResult],
+                          request_headers: Optional[Sequence[RequestHeader]]) -> str:
+        """Returns a v1HMAC authentication signature header"""
+        if http_method is None or not http_method.strip():
+            raise ValueError("http_method is required")
+        if resource_uri is None:
+            raise ValueError("resource_uri is required")
+        data_to_sign = self.to_data_to_sign(http_method, resource_uri, request_headers)
+        return "GCS " + self.__authorization_type + ":" + self.__api_id_key + \
+               ":" + self.create_authentication_signature(data_to_sign)
+
+    def to_data_to_sign(self, http_method, resource_uri, http_headers):
+        content_type = None
+        date = None
+        canonicalized_headers = ""
+        canonicalized_resource = self.__to_canonicalized_resource(resource_uri)
+        xgcs_http_headers = []
+        if http_headers is not None:
+            for http_header in http_headers:
+                if "Content-Type".lower() == http_header.name.lower():
+                    content_type = http_header.value
+                elif "Date".lower() == http_header.name.lower():
+                    date = http_header.value
+                else:
+                    name = self.__to_canonicalize_header_name(http_header.name)
+                    if name.startswith("x-gcs"):
+                        value = self.to_canonicalize_header_value(
+                            http_header.value)
+                        xgcs_http_header = RequestHeader(name, value)
+                        xgcs_http_headers.append(xgcs_http_header)
+        xgcs_http_headers.sort(key=attrgetter('name'))
+        for xgcs_http_header in xgcs_http_headers:
+            canonicalized_headers += xgcs_http_header.name + ":" + xgcs_http_header.value + "\n"
+        string = http_method.upper() + "\n"
+        if content_type is not None:
+            string += content_type + "\n"
+        else:
+            string += "\n"
+        string += date + "\n"
+        string += str(canonicalized_headers)
+        string += canonicalized_resource + "\n"
+        return str(string)
+
+    @staticmethod
+    def __to_canonicalized_resource(resource_uri):
+        """
+        Returns the URI path without the HTTP method and including all
+        decoded query parameters.
+        """
+        string = ""
+        string += resource_uri.path
+        if resource_uri.query:
+            string += "?" + resource_uri.query
+        return str(string)
+
+    @staticmethod
+    def __to_canonicalize_header_name(original_name):
+        if original_name is None:
+            return None
+        else:
+            return original_name.lower()
+
+    @staticmethod
+    def to_canonicalize_header_value(original_value):
+        # For now V1HMAC is the only supported AuthorizationType so always use
+        # the same logic.
+        if original_value is None:
+            return ""
+        return sub(r"\r?\n(?:(?![\r\n])\s)*", " ", original_value).strip()
+
+    def create_authentication_signature(self, data_to_sign):
+        sig = hmac.new(self.__secret_api_key.encode("utf-8"), data_to_sign.encode("utf-8"),
+                       hashlib.sha256)
+        return b64encode(sig.digest()).decode("utf-8").rstrip('\n')

onlinepayments/sdk/authorization_exception.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_exception import ApiException
+
+from onlinepayments.sdk.domain.api_error import APIError
+
+
+class AuthorizationException(ApiException):
+    """
+    Represents an error response from the payment platform when authorization failed.
+    """
+
+    def __init__(self, status_code: int, response_body: str, error_id: Optional[str], errors: Optional[List[APIError]],
+                 message: str = "the payment platform returned an authorization error response"):
+        super(AuthorizationException, self).__init__(status_code, response_body, error_id, errors, message)

onlinepayments/sdk/call_context.py

@@ -0,0 +1,72 @@
+from typing import Optional
+from datetime import datetime
+
+class CallContext(object):
+    """
+    A call context can be used to send extra information with a request, and to receive extra information from a response.
+
+    Please note that this class is not thread-safe. Each request should get its own call context instance.
+    """
+    __idempotence_key: Optional[str] = None
+    __idempotence_request_timestamp: Optional[int] = None
+    __idempotence_response_date_time: Optional[datetime] = None
+    __gzip: Optional[bool] = None
+
+    def __init__(self, idempotence_key: Optional[str] = None, gzip: Optional[bool] = None):
+        self.__idempotence_key = idempotence_key
+        self.__gzip = gzip
+
+    @property
+    def idempotence_key(self) -> Optional[str]:
+        """
+        :return: The idempotence key.
+        """
+        return self.__idempotence_key
+
+    @property
+    def idempotence_request_timestamp(self) -> Optional[int]:
+        """
+        :return: The idempotence request timestamp from the response to the last
+         request for which this call context was used, or None if no idempotence
+         request timestamp was present.
+        """
+        return self.__idempotence_request_timestamp
+
+    @idempotence_request_timestamp.setter
+    def idempotence_request_timestamp(self, idempotence_request_timestamp: int) -> None:
+        """
+        Sets the idempotence request timestamp.
+        This method should only be called by Communicator objects based on the
+        response to the request for which this call context was used.
+        """
+        self.__idempotence_request_timestamp = idempotence_request_timestamp
+
+    @property
+    def idempotence_response_date_time(self) -> Optional[datetime]:
+        """
+        :return: The idempotence response date/time from the response to the
+         last request for which this call context was used, or None if no idempotence
+         response date/time was present.
+        """
+        return self.__idempotence_response_date_time
+
+    @idempotence_response_date_time.setter
+    def idempotence_response_date_time(self, idempotence_response_date_time: datetime) -> None:
+        """
+        Sets the idempotence response date/time.
+        This method should only be called by Communicator objects based on the
+        response to the request for which this call context was used.
+        """
+        self.__idempotence_response_date_time = idempotence_response_date_time
+
+    @property
+    def gzip(self) -> Optional[bool]:
+        """Per-request gzip toggle."""
+        return self.__gzip
+
+    @gzip.setter
+    def gzip(self, enabled: Optional[bool]) -> None:
+        """
+        Sets the gzip field true/false.
+        """
+        self.__gzip = enabled

onlinepayments/sdk/client.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from base64 import b64encode
+from datetime import timedelta
+from typing import Optional
+
+from .api_resource import ApiResource
+from .i_client import IClient
+from .i_communicator import ICommunicator
+
+from onlinepayments.sdk.log.body_obfuscator import BodyObfuscator
+from onlinepayments.sdk.log.communicator_logger import CommunicatorLogger
+from onlinepayments.sdk.log.header_obfuscator import HeaderObfuscator
+from onlinepayments.sdk.merchant.i_merchant_client import IMerchantClient
+from onlinepayments.sdk.merchant.merchant_client import MerchantClient
+
+
+class Client(ApiResource, IClient):
+    """
+    Payment platform client.
+
+    This client and all its child clients are bound to one specific value for the X-GCS-ClientMetaInfo header.
+    To get a new client with a different header value, use with_client_meta_info.
+
+    Thread-safe.
+    """
+
+    def __init__(self, communicator: ICommunicator, client_meta_info: Optional[str] = None):
+        """
+        :param communicator:      :class:`onlinepayments.sdk.i_communicator.ICommunicator`
+        :param client_meta_info:  str
+        """
+        super(Client, self).__init__(communicator=communicator,
+                                     client_meta_info=client_meta_info)
+
+    def with_client_meta_info(self, client_meta_info: Optional[str]) -> 'Client':
+        """
+        :param client_meta_info: JSON string containing the metadata for the client
+        :return: a new Client which uses the passed metadata for the X-GCS-ClientMetaInfo header.
+        :raise MarshallerSyntaxException: if the given clientMetaInfo is not a valid JSON string
+        """
+        if self._client_meta_info is None and client_meta_info is None:
+            return self
+        if client_meta_info is None:
+            return Client(self._communicator, None)
+        # Checking to see if this is valid JSON (no JSON parse exceptions)
+        self._communicator.marshaller.unmarshal(client_meta_info, object)
+        client_meta_info = b64encode(client_meta_info.encode('utf-8')).decode('utf-8')
+        if client_meta_info == self._client_meta_info:
+            return self
+        return Client(self._communicator, client_meta_info)
+
+    def close_idle_connections(self, idle_time: timedelta) -> None:
+        """
+        Utility method that delegates the call to this client's communicator.
+
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+        self._communicator.close_idle_connections(idle_time)
+
+    def close_expired_connections(self) -> None:
+        """
+        Utility method that delegates the call to this client's communicator.
+        """
+        self._communicator.close_expired_connections()
+
+    def set_body_obfuscator(self, body_obfuscator: BodyObfuscator) -> None:
+        # delegate to the communicator
+        self._communicator.set_body_obfuscator(body_obfuscator)
+
+    def set_header_obfuscator(self, header_obfuscator: HeaderObfuscator) -> None:
+        # delegate to the communicator
+        self._communicator.set_header_obfuscator(header_obfuscator)
+
+    def enable_logging(self, communicator_logger: CommunicatorLogger) -> None:
+        # delegate to the communicator
+        self._communicator.enable_logging(communicator_logger)
+
+    def disable_logging(self) -> None:
+        # delegate to the communicator
+        self._communicator.disable_logging()
+
+    def close(self) -> None:
+        """
+        Releases any system resources associated with this object.
+        """
+        self._communicator.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def merchant(self, merchant_id: str) -> IMerchantClient:
+        """
+        Resource /v2/{merchantId}
+
+        :param merchant_id:  str
+        :return: :class:`onlinepayments.sdk.merchant.i_merchant_client.IMerchantClient`
+        """
+        sub_context = {
+            "merchantId": merchant_id,
+        }
+        return MerchantClient(self, sub_context)

onlinepayments/sdk/communication/communication_exception.py

@@ -0,0 +1,8 @@
+class CommunicationException(RuntimeError):
+    """
+    Indicates an exception regarding the communication with the Online Payments platform such as a connection exception.
+    """
+
+    def __init__(self, exception: Exception):
+        super(CommunicationException, self).__init__(exception)
+        self.cause = exception

onlinepayments/sdk/communication/connection.py

@@ -0,0 +1,84 @@
+from abc import ABC, abstractmethod
+from typing import Iterable, Mapping, Sequence, Tuple, Union
+from urllib.parse import ParseResult
+
+from .multipart_form_data_object import MultipartFormDataObject
+from .request_header import RequestHeader
+
+from onlinepayments.sdk.log.logging_capable import LoggingCapable
+from onlinepayments.sdk.log.obfuscation_capable import ObfuscationCapable
+
+
+URI = Union[str, ParseResult]
+RequestBody = Union[str, bytes, MultipartFormDataObject, None]
+Response = Tuple[int, Mapping[str, str], Iterable[bytes]]
+
+
+class Connection(LoggingCapable, ObfuscationCapable, ABC):
+    """
+    Represents a connection to the Online Payments platform server.
+    """
+
+    @abstractmethod
+    def get(self, url: URI, request_headers: Sequence[RequestHeader]) -> Response:
+        """
+        Send a GET request to the Online Payments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :return: The response from the Online Payments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Online Payments platform
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, url: URI, request_headers: Sequence[RequestHeader]) -> Response:
+        """
+        Send a DELETE request to the Online Payments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :return: The response from the Online Payments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Online Payments platform
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def post(self, url: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
+        """
+        Send a POST request to the Online Payments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :param body: The optional body to send.
+        :return: The response from the Online Payments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Online Payments platform
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def put(self, url: URI, request_headers: Sequence[RequestHeader], body: RequestBody) -> Response:
+        """
+        Send a PUT request to the Online Payments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :param body: The optional body to send.
+        :return: The response from the Online Payments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise CommunicationException: when an exception occurred communicating
+         with the Online Payments platform
+        """
+        raise NotImplementedError
+
+    def close(self) -> None:
+        """
+        Releases any system resources associated with this object.
+        """
+        pass