csobpg 0.0.1__py3-none-any.whl

csobpg/__init__.py

@@ -0,0 +1 @@
+"""The library package."""

csobpg/http/__init__.py

@@ -0,0 +1,17 @@
+"""Package for dealing with HTTP."""
+
+from .base import (
+    HTTPClient,
+    HTTPConnectionError,
+    HTTPRequestError,
+    HTTPResponse,
+    HTTPTimeoutError,
+)
+
+__all__ = [
+    "HTTPClient",
+    "HTTPConnectionError",
+    "HTTPRequestError",
+    "HTTPResponse",
+    "HTTPTimeoutError",
+]

csobpg/http/base.py

@@ -0,0 +1,104 @@
+"""Base client."""
+
+import json as jsonlib
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class HTTPRequestError(Exception):
+    """Base HTTP request error."""
+
+
+class HTTPConnectionError(HTTPRequestError):
+    """Any error related to connection."""
+
+
+class HTTPTimeoutError(HTTPRequestError):
+    """HTTP request timed out."""
+
+
+class HTTPInvalidResponseError(HTTPRequestError):
+    """HTTP response is invalid."""
+
+
+class HTTPResponse:
+    """HTTP response wrapper."""
+
+    def __init__(
+        self, status_code: int, body: Optional[bytes], headers: dict
+    ) -> None:
+        self.status_code = status_code
+        self.body = body or b""
+        self._headers = headers
+
+        self._json = None
+
+    @property
+    # TODO: return dict
+    def json(self) -> Optional[dict]:
+        """Return body as JSON."""
+        if self._json is not None:
+            return self._json
+
+        headers = {key.lower(): val for key, val in self._headers.items()}
+        if "application/json" in headers.get("content-type", ""):
+            try:
+                self._json = jsonlib.loads(self.body)
+            except Exception as exc:
+                raise HTTPInvalidResponseError(
+                    f"Invalid JSON in response: {exc}"
+                ) from exc
+
+        return self._json
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(status={self.status_code})"
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"status={self.status_code}, "
+            f"body={self.body}, "
+            f"headers={self._headers}"
+            ")"
+        )
+
+
+class HTTPClient(ABC):
+    """Base HTTP client."""
+
+    def __init__(self, request_timeout: float = 5) -> None:
+        self.request_timeout = request_timeout
+
+    # pylint: disable=too-many-arguments
+    @abstractmethod
+    def _request(
+        self,
+        method: str,
+        url: str,
+        json: Optional[dict] = None,
+        headers: Optional[dict] = None,
+    ) -> HTTPResponse:
+        """Perform request.
+
+        This method must handle all possible HTTP exceptions and raise them
+        as `HTTPRequestError`.
+
+        Headers may be extended if necessary.
+        """
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        json: Optional[dict] = None,
+        headers: Optional[dict] = None,
+    ) -> HTTPResponse:
+        """Perform HTTP request with a given HTTP method.
+
+        :param method: HTTP method to use
+        :param url: API URL
+        :param json: JSON data to post
+        :param headers: headers
+        """
+        return self._request(method, url, json, headers=headers)

csobpg/http/requests_client.py

@@ -0,0 +1,46 @@
+"""HTTP client which uses `requests` under the hood."""
+
+from typing import Optional
+
+import requests
+
+from .base import (
+    HTTPClient,
+    HTTPConnectionError,
+    HTTPRequestError,
+    HTTPResponse,
+    HTTPTimeoutError,
+)
+
+
+class RequestsHTTPClient(HTTPClient):
+    """`requests` HTTP client."""
+
+    def __init__(self, request_timeout: float = 5) -> None:
+        super().__init__(request_timeout)
+        self._session = requests.Session()
+
+    def _request(
+        self,
+        method: str,
+        url: str,
+        json: Optional[dict] = None,
+        headers: Optional[dict] = None,
+    ) -> HTTPResponse:
+        try:
+            response: requests.Response = getattr(
+                self._session, method.lower()
+            )(url, json=json, timeout=self.request_timeout, headers=headers)
+        except ConnectionError as exc:
+            raise HTTPConnectionError(exc) from exc
+        except requests.Timeout as exc:
+            raise HTTPTimeoutError(exc) from exc
+        except requests.RequestException as exc:
+            raise HTTPRequestError(exc) from exc
+
+        return HTTPResponse(
+            response.status_code, response.content, dict(response.headers)
+        )
+
+    def __str__(self) -> str:
+        return self.__class__.__name__

csobpg/http/urllib_client.py

@@ -0,0 +1,62 @@
+"""HTTP client which uses `urllib` under the hood."""
+
+import json as _jsonlib
+import urllib
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Optional
+
+from .base import (
+    HTTPClient,
+    HTTPConnectionError,
+    HTTPRequestError,
+    HTTPResponse,
+    HTTPTimeoutError,
+)
+
+
+class UrllibHTTPClient(HTTPClient):
+    """`urllib` HTTP client."""
+
+    # pylint: disable=too-many-arguments
+    def _request(
+        self,
+        method: str,
+        url: str,
+        json: Optional[dict] = None,
+        headers: Optional[dict] = None,
+    ) -> HTTPResponse:
+        headers = headers or {}
+        data = None
+
+        if json:
+            headers["Content-Type"] = "application/json"
+            data = _jsonlib.dumps(json).encode()
+
+        try:
+            with urllib.request.urlopen(
+                urllib.request.Request(
+                    url,
+                    data=data,
+                    headers=headers,
+                    method=method.upper(),
+                ),
+                timeout=self.request_timeout,
+            ) as response:
+                return HTTPResponse(
+                    response.status, response.read(), dict(response.headers)
+                )
+        except ConnectionError as exc:
+            raise HTTPConnectionError(exc) from exc
+        except TimeoutError as exc:
+            raise HTTPTimeoutError(exc) from exc
+        except urllib.error.HTTPError as exc:
+            return HTTPResponse(
+                exc.status or 500, exc.read(), dict(exc.headers)
+            )
+        except urllib.error.URLError as exc:
+            raise HTTPRequestError(exc) from exc
+
+    def __str__(self) -> str:
+        return self.__class__.__name__

csobpg/v19/__init__.py

@@ -0,0 +1,18 @@
+"""Client for API v.1.9."""
+
+from .api import APIClient
+from .key import FileRSAKey, RAMRSAKey, RSAKey
+from .request.payment_init.cart import Cart, CartItem
+from .request.payment_init.currency import Currency
+from .response import PaymentStatus
+
+__all__ = (
+    "APIClient",
+    "Cart",
+    "CartItem",
+    "Currency",
+    "RAMRSAKey",
+    "FileRSAKey",
+    "RSAKey",
+    "PaymentStatus",
+)

csobpg/v19/api.py

@@ -0,0 +1,209 @@
+"""API client."""
+
+from typing import Optional, Union
+
+from csobpg.http import HTTPClient
+from csobpg.http.urllib_client import UrllibHTTPClient
+
+from .key import FileRSAKey, RAMRSAKey, RSAKey
+from .request import EchoRequest as _EchoRequest
+from .request import PaymentCloseRequest as _PaymentCloseRequest
+from .request import PaymentInitRequest as _PaymentInitRequest
+from .request import PaymentProcessRequest as _PaymentProcessRequest
+from .request import PaymentRefundRequest as _PaymentRefundRequest
+from .request import PaymentReverseRequest as _PaymentReverseRequest
+from .request import PaymentStatusRequest as _PaymentStatusRequest
+from .request import payment_init as _payment_init
+from .response import (
+    PaymentCloseResponse,
+    PaymentInitResponse,
+    PaymentProcessResponse,
+    PaymentRefundResponse,
+    PaymentReverseResponse,
+    PaymentStatusResponse,
+)
+
+
+class APIClient:
+    """API client."""
+
+    def __init__(
+        self,
+        merchant_id: str,
+        private_key: Union[str, RSAKey],
+        public_key: Union[str, RSAKey],
+        base_url: str = "https://api.platebnibrana.csob.cz/api/v1.9",
+        http_client: HTTPClient = UrllibHTTPClient(),
+    ) -> None:
+        # pylint:disable=too-many-arguments
+        self.merchant_id = merchant_id
+        self.base_url = base_url.rstrip("/")
+
+        if isinstance(private_key, str):
+            self.private_key = FileRSAKey(private_key)
+        else:
+            self.private_key = private_key
+
+        if isinstance(public_key, str):
+            self.public_key = RAMRSAKey(public_key)
+        else:
+            self.public_key = public_key
+
+        self._http_client = http_client
+
+    def init_payment(
+        self,
+        order_no: str,
+        total_amount: int,
+        return_url: str,
+        return_method: _payment_init.ReturnMethod = _payment_init.ReturnMethod.POST,
+        payment_operation: _payment_init.PaymentOperation = _payment_init.PaymentOperation.PAYMENT,
+        payment_method: _payment_init.PaymentMethod = _payment_init.PaymentMethod.CARD,
+        currency: _payment_init.Currency = _payment_init.Currency.CZK,
+        close_payment: bool = True,
+        ttl_sec: int = 600,
+        cart: Optional[_payment_init.Cart] = None,
+        customer: Optional[_payment_init.CustomerData] = None,
+        order: Optional[_payment_init.OrderData] = None,
+        merchant_data: Optional[bytes] = None,
+        customer_id: Optional[str] = None,
+        payment_expiry: Optional[int] = None,
+        # pylint:disable=line-too-long, too-many-locals
+        page_appearance: _payment_init.WebPageAppearanceConfig = _payment_init.WebPageAppearanceConfig(),
+    ) -> PaymentInitResponse:
+        """Init payment."""
+        request = _PaymentInitRequest(
+            self.merchant_id,
+            str(self.private_key),
+            order_no=order_no,
+            total_amount=total_amount,
+            return_url=return_url,
+            return_method=return_method,
+            payment_operation=payment_operation,
+            payment_method=payment_method,
+            currency=currency,
+            close_payment=close_payment,
+            ttl_sec=ttl_sec,
+            cart=cart,
+            customer=customer,
+            order=order,
+            merchant_data=merchant_data,
+            customer_id=customer_id,
+            payment_expiry=payment_expiry,
+            page_appearance=page_appearance,
+        )
+        return PaymentInitResponse.from_json(
+            self._call_api(
+                "post",
+                self._build_url(request.endpoint),
+                json=request.to_json(),
+            ),
+            str(self.public_key),
+        )
+
+    def get_payment_status(self, pay_id: str) -> PaymentStatusResponse:
+        """Request payment status information."""
+        request = _PaymentStatusRequest(
+            self.merchant_id, str(self.private_key), pay_id
+        )
+        return PaymentStatusResponse.from_json(
+            self._call_api("get", url=self._build_url(request.endpoint)),
+            str(self.public_key),
+        )
+
+    def reverse_payment(self, pay_id: str) -> PaymentReverseResponse:
+        """Reverse payment.
+
+        :param pay_id: payment ID
+        """
+        request = _PaymentReverseRequest(
+            self.merchant_id, str(self.private_key), pay_id
+        )
+        return PaymentReverseResponse.from_json(
+            self._call_api(
+                "put", self._build_url(request.endpoint), request.to_json()
+            ),
+            str(self.public_key),
+        )
+
+    def close_payment(
+        self, pay_id: str, total_amount: Optional[int] = None
+    ) -> PaymentCloseResponse:
+        """Close payment (move to settlement).
+
+        :param total_amount: close the payment with this amount. It must be
+          less or equal to the original amount and provided in hundredths of
+          the base currency
+        """
+        request = _PaymentCloseRequest(
+            self.merchant_id, str(self.private_key), pay_id, total_amount
+        )
+        return PaymentCloseResponse.from_json(
+            self._call_api(
+                "put",
+                self._build_url(request.endpoint),
+                json=request.to_json(),
+            ),
+            str(self.public_key),
+        )
+
+    def refund_payment(
+        self, pay_id: str, amount: Optional[int] = None
+    ) -> PaymentRefundResponse:
+        """Refund payment.
+
+        :param pay_id: payment ID
+        :param amount: amount to refund. It must be less or equal to the
+          original amount and provided in hundredths of the base currency.
+          If not provided, the full amount will be refunded.
+        """
+        request = _PaymentRefundRequest(
+            self.merchant_id, str(self.private_key), pay_id, amount
+        )
+        return PaymentRefundResponse.from_json(
+            self._call_api(
+                "put", self._build_url(request.endpoint), request.to_json()
+            ),
+            str(self.public_key),
+        )
+
+    def get_payment_process_url(self, pay_id: str) -> str:
+        """Build payment URL.
+
+        :param pay_id: pay_id obtained from `payment_init`
+        :return: url to process payment
+        """
+        return self._build_url(
+            _PaymentProcessRequest(
+                self.merchant_id, str(self.private_key), pay_id
+            ).endpoint
+        )
+
+    def echo(self) -> None:
+        """Make an echo request."""
+        request = _EchoRequest(self.merchant_id, str(self.private_key))
+        self._call_api(
+            "post", self._build_url(request.endpoint), request.to_json()
+        )
+
+    def process_gateway_return(self, datadict: dict) -> PaymentProcessResponse:
+        """Process gateway return."""
+        data = {}
+
+        for key in datadict:
+            data[key] = (
+                int(datadict[key])
+                if key in ("resultCode", "paymentStatus")
+                else datadict[key]
+            )
+
+        return PaymentProcessResponse.from_json(data, str(self.public_key))
+
+    def _call_api(
+        self, method: str, url: str, json: Optional[dict] = None
+    ) -> dict:
+        http_response = self._http_client.request(method, url, json)
+        return http_response.json or {}
+
+    def _build_url(self, endpoint: str) -> str:
+        return f"{self.base_url}/{endpoint.strip('/')}/"

csobpg/v19/errors.py

@@ -0,0 +1,225 @@
+"""API errors."""
+
+
+class APIClientError(Exception):
+    """API client error."""
+
+
+class APIInvalidSignatureError(APIClientError):
+    """API returned invalid signature."""
+
+
+class APIError(Exception):
+    """API error."""
+
+    def __init__(self, code: int, message: str) -> None:
+        """Init API error.
+
+        :param code: error code
+        :message: error message
+        """
+        self.code = code
+        self.message = message
+        super().__init__(f"{self.code}: {self.message}")
+
+
+class APIMissingParamError(APIError):
+    """API missing param error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(100, message)
+
+
+class APIInvalidParamError(APIError):
+    """API invalid param error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(110, message)
+
+
+class APIMerchantBlockedError(APIError):
+    """API merchant is blocked error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(120, message)
+
+
+class APISessionExpiredError(APIError):
+    """API session (request) expired error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(130, message)
+
+
+class APIPaymentNotFoundError(APIError):
+    """API payment not found error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(140, message)
+
+
+class APIPaymentInInvalidStateError(APIError):
+    """API payment is in invalid state error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(150, message)
+
+
+class APIPaymentMethodDisabledError(APIError):
+    """API payment method is disabled error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(160, message)
+
+
+class APIPaymentMethodUnavailableError(APIError):
+    """API payment method is unavailable error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(170, message)
+
+
+class APIOperationNotAllowedError(APIError):
+    """API operation is not allowed error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(180, message)
+
+
+class APIPaymentMethodError(APIError):
+    """API payment method error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(190, message)
+
+
+class APIDuplicatePurchaseIDError(APIError):
+    """API duplicate purchaseId error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(200, message)
+
+
+class APIEETRejectedError(APIError):
+    """API EET rejected error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(500, message)
+
+
+class APIMallPaymentPrecheckDeclinedError(APIError):
+    """API mall payment declined in pre-check error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(600, message)
+
+
+class APIOneClickTemplateNotFoundError(APIError):
+    """API one click template not found error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(700, message)
+
+
+class APIOneClickTemplatePaymentExpiredError(APIError):
+    """API one click template payment expired error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(710, message)
+
+
+class APIOneClickTemplateCardExpiredError(APIError):
+    """API one click template card expired error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(720, message)
+
+
+class APIOneClickTemplateCustomerRejectedError(APIError):
+    """API one click template customer rejected error.
+
+    the OneClick template was cancelled at the customer's request.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(730, message)
+
+
+class APIOneClickTemplatePaymentReversedError(APIError):
+    """API one click template payment reversed error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(740, message)
+
+
+class APICardholderAccountClosedError(APIError):
+    """API cardholder account closed error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(750, message)
+
+
+class APICustomerNotFoundError(APIError):
+    """API customer not found error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(800, message)
+
+
+class APICustomerFoundNoSavedCardsError(APIError):
+    """API customer found no saved cards error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(810, message)
+
+
+class APICustomerFoundSavedCardsFoundError(APIError):
+    """API customer found saved cards found error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(820, message)
+
+
+class APIInternalError(APIError):
+    """API internal error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(900, message)
+
+
+_ERROR_FOR_CODE = {
+    100: APIMissingParamError,
+    110: APIInvalidParamError,
+    120: APIMerchantBlockedError,
+    130: APISessionExpiredError,
+    140: APIPaymentNotFoundError,
+    150: APIPaymentInInvalidStateError,
+    160: APIPaymentMethodDisabledError,
+    170: APIPaymentMethodUnavailableError,
+    180: APIOperationNotAllowedError,
+    190: APIPaymentMethodError,
+    200: APIDuplicatePurchaseIDError,
+    500: APIEETRejectedError,
+    600: APIMallPaymentPrecheckDeclinedError,
+    700: APIOneClickTemplateNotFoundError,
+    710: APIOneClickTemplatePaymentExpiredError,
+    720: APIOneClickTemplateCardExpiredError,
+    730: APIOneClickTemplateCustomerRejectedError,
+    740: APIOneClickTemplatePaymentReversedError,
+    750: APICardholderAccountClosedError,
+    800: APICustomerNotFoundError,
+    810: APICustomerFoundNoSavedCardsError,
+    820: APICustomerFoundSavedCardsFoundError,
+    900: APIInternalError,
+}
+
+
+def raise_for_result_code(result_code: int, result_message: str) -> None:
+    """Raise APIError if resultCode != 0."""
+    if result_code == 0:
+        return
+
+    try:
+        raise _ERROR_FOR_CODE[result_code](result_message)
+    except KeyError:
+        raise APIError(result_code, result_message) from None