paytechuz 0.2.19__py3-none-any.whl → 0.2.21__py3-none-any.whl

core/base.py

@@ -0,0 +1,97 @@
+"""
+Base classes for payment gateways.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional, Union
+
+
+class BasePaymentGateway(ABC):
+    """
+    Base class for all payment gateways.
+
+    This abstract class defines the common interface that all payment gateways
+    must implement. It provides a consistent API for creating, checking, and
+    canceling payments regardless of the underlying payment provider.
+    """
+
+    def __init__(self, is_test_mode: bool = False):
+        """
+        Initialize the payment gateway.
+
+        Args:
+            is_test_mode (bool): Whether to use the test environment
+        """
+        self.is_test_mode = is_test_mode
+
+    @abstractmethod
+    def create_payment(
+        self,
+        id: Union[int, str],
+        amount: Union[int, float, str],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Create a payment.
+
+        Args:
+            id: The account ID or order ID
+            amount: The payment amount
+            **kwargs: Additional parameters specific to the payment gateway
+
+        Returns:
+            Dict containing payment details including transaction ID
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_payment(self, transaction_id: str) -> Dict[str, Any]:
+        """
+        Check payment status.
+
+        Args:
+            transaction_id: The transaction ID to check
+
+        Returns:
+            Dict containing payment status and details
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def cancel_payment(
+        self,
+        transaction_id: str,
+        reason: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Cancel payment.
+
+        Args:
+            transaction_id: The transaction ID to cancel
+            reason: Optional reason for cancellation
+
+        Returns:
+            Dict containing cancellation status and details
+        """
+        raise NotImplementedError
+
+
+class BaseWebhookHandler(ABC):
+    """
+    Base class for payment gateway webhook handlers.
+
+    This abstract class defines the common interface for handling webhook
+    callbacks from payment gateways.
+    """
+
+    @abstractmethod
+    def handle_webhook(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle webhook data from payment gateway.
+
+        Args:
+            data: The webhook data received from the payment gateway
+
+        Returns:
+            Dict containing the response to be sent back to the payment gateway
+        """
+        raise NotImplementedError

core/constants.py

@@ -0,0 +1,68 @@
+"""
+Constants for payment gateways.
+"""
+from enum import Enum
+
+class TransactionState(Enum):
+    """Transaction states."""
+    CREATED = 0
+    INITIATING = 1
+    SUCCESSFULLY = 2
+    CANCELED = -2
+    CANCELED_DURING_INIT = -1
+
+
+class PaymentGateway(Enum):
+    """Payment gateway types."""
+    PAYME = "payme"
+    CLICK = "click"
+
+class PaymeEndpoints:
+    """Payme API endpoints."""
+    RECEIPTS_CREATE = "receipts/create"
+    RECEIPTS_PAY = "receipts/pay"
+    RECEIPTS_SEND = "receipts/send"
+    RECEIPTS_CHECK = "receipts/check"
+    RECEIPTS_CANCEL = "receipts/cancel"
+    RECEIPTS_GET = "receipts/get"
+    CARDS_CREATE = "cards/create"
+    CARDS_VERIFY = "cards/verify"
+    CARDS_CHECK = "cards/check"
+    CARDS_REMOVE = "cards/remove"
+    CARDS_GET_VERIFY_CODE = "cards/get_verify_code"
+
+
+class PaymeNetworks:
+    """Payme API networks."""
+    TEST_NET = "https://checkout.test.paycom.uz/api"
+    PROD_NET = "https://checkout.paycom.uz/api"
+
+class ClickEndpoints:
+    """Click API endpoints."""
+    PREPARE = "prepare"
+    COMPLETE = "complete"
+    MERCHANT_API = "merchant/api"
+
+
+class ClickNetworks:
+    """Click API networks."""
+    TEST_NET = "https://api.click.uz/v2/merchant"
+    PROD_NET = "https://api.click.uz/v2/merchant"
+
+class ClickActions:
+    """Click API actions."""
+    PREPARE = 0
+    COMPLETE = 1
+
+
+class PaymeCancelReason:
+    """Payme cancel reason codes."""
+    REASON_USER_NOT_FOUND = 1
+    REASON_DEBIT_OPERATION_FAILED = 2
+    REASON_EXECUTION_ERROR = 3
+    REASON_TIMEOUT = 4
+    REASON_FUND_RETURNED = 5
+    REASON_UNKNOWN = 6
+    REASON_CANCELLED_BY_USER = 7
+    REASON_SUSPICIOUS_OPERATION = 8
+    REASON_MERCHANT_DECISION = 9

core/exceptions.py

@@ -0,0 +1,190 @@
+"""
+Exceptions for payment gateways.
+"""
+from typing import Optional, Dict, Any
+
+class PaymentException(Exception):
+    """Base exception for all payment exceptions."""
+    code = "payment_error"
+    message = "Payment error occurred"
+    data: Dict[str, Any] = {}
+
+    def __init__(self, message: Optional[str] = None, code: Optional[str] = None, data: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the exception.
+
+        Args:
+            message: Custom error message
+            code: Custom error code
+            data: Additional error data
+        """
+        self.message = message or self.message
+        self.code = code or self.code
+        self.data = data or self.data
+        super().__init__(self.message)
+
+    def as_dict(self) -> Dict[str, Any]:
+        """
+        Convert the exception to a dictionary.
+
+        Returns:
+            Dict containing error details
+        """
+        return {
+            "code": self.code,
+            "message": self.message,
+            "data": self.data
+        }
+
+# Authentication and Authorization Exceptions
+class AuthenticationError(PaymentException):
+    """Exception raised when authentication fails."""
+    code = "authentication_error"
+    message = "Authentication failed"
+
+
+
+class InvalidCredentials(AuthenticationError):
+    """Exception raised when credentials are invalid."""
+    code = "invalid_credentials"
+    message = "Invalid credentials provided"
+
+class PermissionDenied(AuthenticationError):
+    """Exception raised when permission is denied."""
+    code = "permission_denied"
+    message = "Permission denied"
+
+# Transaction Exceptions
+class TransactionError(PaymentException):
+    """Base exception for transaction errors."""
+    code = "transaction_error"
+    message = "Transaction error occurred"
+
+
+class TransactionNotFound(TransactionError):
+    """Exception raised when a transaction is not found."""
+    code = "transaction_not_found"
+    message = "Transaction not found"
+
+class TransactionAlreadyExists(TransactionError):
+    """Exception raised when a transaction already exists."""
+    code = "transaction_already_exists"
+    message = "Transaction already exists"
+
+
+class TransactionCancelled(TransactionError):
+    """Exception raised when a transaction is cancelled."""
+    code = "transaction_cancelled"
+    message = "Transaction has been cancelled"
+
+class TransactionInProgress(TransactionError):
+    """Exception raised when a transaction is in progress."""
+    code = "transaction_in_progress"
+    message = "Transaction is in progress"
+
+
+class TransactionCompleted(TransactionError):
+    """Exception raised when a transaction is already completed."""
+    code = "transaction_completed"
+    message = "Transaction is already completed"
+
+# Account Exceptions
+class AccountError(PaymentException):
+    """Base exception for account errors."""
+    code = "account_error"
+    message = "Account error occurred"
+
+
+class AccountNotFound(AccountError):
+    """Exception raised when an account is not found."""
+    code = "account_not_found"
+    message = "Account not found"
+
+class InvalidAccount(AccountError):
+    """Exception raised when an account is invalid."""
+    code = "invalid_account"
+    message = "Invalid account"
+
+# Amount Exceptions
+class AmountError(PaymentException):
+    """Base exception for amount errors."""
+    code = "amount_error"
+    message = "Amount error occurred"
+
+
+class InvalidAmount(AmountError):
+    """Exception raised when an amount is invalid."""
+    code = "invalid_amount"
+    message = "Invalid amount"
+
+class InsufficientFunds(AmountError):
+    """Exception raised when there are insufficient funds."""
+    code = "insufficient_funds"
+    message = "Insufficient funds"
+
+# Method Exceptions
+class MethodError(PaymentException):
+    """Base exception for method errors."""
+    code = "method_error"
+    message = "Method error occurred"
+
+
+class MethodNotFound(MethodError):
+    """Exception raised when a method is not found."""
+    code = "method_not_found"
+    message = "Method not found"
+
+class UnsupportedMethod(MethodError):
+    """Exception raised when a method is not supported."""
+    code = "unsupported_method"
+    message = "Method not supported"
+
+# System Exceptions
+class SystemError(PaymentException):
+    """Base exception for system errors."""
+    code = "system_error"
+    message = "System error occurred"
+
+
+class InternalServiceError(SystemError):
+    """Exception raised when an internal service error occurs."""
+    code = "internal_service_error"
+    message = "Internal service error"
+
+class ExternalServiceError(SystemError):
+    """Exception raised when an external service error occurs."""
+    code = "external_service_error"
+    message = "External service error"
+
+
+class TimeoutError(SystemError):
+    """Exception raised when a timeout occurs."""
+    code = "timeout_error"
+    message = "Operation timed out"
+
+# Create a list of exceptions that should not be wrapped
+exception_whitelist = (
+    PaymentException,
+    AuthenticationError,
+    InvalidCredentials,
+    PermissionDenied,
+    TransactionError,
+    TransactionNotFound,
+    TransactionAlreadyExists,
+    TransactionCancelled,
+    TransactionInProgress,
+    TransactionCompleted,
+    AccountError,
+    AccountNotFound,
+    InvalidAccount,
+    AmountError,
+    InvalidAmount,
+    InsufficientFunds,
+    MethodError,
+    MethodNotFound,
+    UnsupportedMethod,
+    SystemError,
+    InternalServiceError,
+    ExternalServiceError,
+    TimeoutError,
+)

core/http.py

@@ -0,0 +1,268 @@
+"""
+HTTP client for making requests to payment gateways.
+"""
+import json
+import logging
+from typing import Dict, Any, Optional, Union, List
+
+import requests
+from requests.exceptions import RequestException, Timeout, ConnectionError
+
+from paytechuz.core.exceptions import (
+    ExternalServiceError,
+    TimeoutError as PaymentTimeoutError,
+    InternalServiceError
+)
+
+logger = logging.getLogger(__name__)
+
+class HttpClient:
+    """
+    HTTP client for making requests to payment gateways.
+
+    This class provides a simple interface for making HTTP requests to payment
+    gateways with proper error handling and logging.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: int = 30,
+        verify_ssl: bool = True
+    ):
+        """
+        Initialize the HTTP client.
+
+        Args:
+            base_url: Base URL for the API
+            headers: Default headers to include in all requests
+            timeout: Request timeout in seconds
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self.base_url = base_url.rstrip('/')
+        self.headers = headers or {}
+        self.timeout = timeout
+        self.verify_ssl = verify_ssl
+
+    def _build_url(self, endpoint: str) -> str:
+        """
+        Build the full URL for the given endpoint.
+
+        Args:
+            endpoint: API endpoint
+
+        Returns:
+            Full URL
+        """
+        endpoint = endpoint.lstrip('/')
+        return f"{self.base_url}/{endpoint}"
+
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        """
+        Handle the response from the API.
+
+        Args:
+            response: Response object
+
+        Returns:
+            Response data as dictionary
+
+        Raises:
+            ExternalServiceError: If the response status code is not 2xx
+        """
+        try:
+            response.raise_for_status()
+            return response.json()
+        except json.JSONDecodeError:
+            logger.error(f"Failed to decode JSON response: {response.text}")
+            raise InternalServiceError("Failed to decode JSON response")
+        except requests.HTTPError as e:
+            logger.error(f"HTTP error: {e}, Response: {response.text}")
+            try:
+                error_data = response.json()
+            except json.JSONDecodeError:
+                error_data = {"raw_response": response.text}
+
+            raise ExternalServiceError(
+                message=f"HTTP error: {response.status_code}",
+                data=error_data
+            )
+
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Union[Dict[str, Any], List[Any]]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        json_data: Optional[Union[Dict[str, Any], List[Any]]] = None,
+        timeout: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Make an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE, etc.)
+            endpoint: API endpoint
+            params: Query parameters
+            data: Form data
+            headers: Request headers
+            json_data: JSON data
+            timeout: Request timeout in seconds
+
+        Returns:
+            Response data as dictionary
+
+        Raises:
+            ExternalServiceError: If the request fails
+            TimeoutError: If the request times out
+        """
+        url = self._build_url(endpoint)
+        request_headers = {**self.headers}
+        if headers:
+            request_headers.update(headers)
+
+        timeout = timeout or self.timeout
+
+        try:
+            response = requests.request(
+                method=method.upper(),
+                url=url,
+                params=params,
+                data=data,
+                headers=request_headers,
+                json=json_data,
+                timeout=timeout,
+                verify=self.verify_ssl
+            )
+            return self._handle_response(response)
+        except Timeout:
+            logger.error(f"Request timed out: {method} {url}")
+            raise PaymentTimeoutError(f"Request timed out: {method} {url}")
+        except ConnectionError as e:
+            logger.error(f"Connection error: {e}")
+            raise ExternalServiceError(f"Connection error: {str(e)}")
+        except RequestException as e:
+            logger.error(f"Request error: {e}")
+            raise ExternalServiceError(f"Request error: {str(e)}")
+
+    def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Make a GET request.
+
+        Args:
+            endpoint: API endpoint
+            params: Query parameters
+            headers: Request headers
+            timeout: Request timeout in seconds
+
+        Returns:
+            Response data as dictionary
+        """
+        return self.request(
+            method="GET",
+            endpoint=endpoint,
+            params=params,
+            headers=headers,
+            timeout=timeout
+        )
+
+    def post(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Make a POST request.
+
+        Args:
+            endpoint: API endpoint
+            data: Form data
+            json_data: JSON data
+            params: Query parameters
+            headers: Request headers
+            timeout: Request timeout in seconds
+
+        Returns:
+            Response data as dictionary
+        """
+        return self.request(
+            method="POST",
+            endpoint=endpoint,
+            data=data,
+            json_data=json_data,
+            params=params,
+            headers=headers,
+            timeout=timeout
+        )
+
+    def put(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Make a PUT request.
+
+        Args:
+            endpoint: API endpoint
+            data: Form data
+            json_data: JSON data
+            params: Query parameters
+            headers: Request headers
+            timeout: Request timeout in seconds
+
+        Returns:
+            Response data as dictionary
+        """
+        return self.request(
+            method="PUT",
+            endpoint=endpoint,
+            data=data,
+            json_data=json_data,
+            params=params,
+            headers=headers,
+            timeout=timeout
+        )
+
+    def delete(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Make a DELETE request.
+
+        Args:
+            endpoint: API endpoint
+            params: Query parameters
+            headers: Request headers
+            timeout: Request timeout in seconds
+
+        Returns:
+            Response data as dictionary
+        """
+        return self.request(
+            method="DELETE",
+            endpoint=endpoint,
+            params=params,
+            headers=headers,
+            timeout=timeout
+        )

core/payme/errors.py

@@ -0,0 +1,25 @@
+"""
+Payme API error codes.
+"""
+
+# System errors
+SYSTEM_ERROR = -32400
+INVALID_JSON_RPC = -32600
+METHOD_NOT_FOUND = -32601
+INVALID_PARAMS = -32602
+INTERNAL_ERROR = -32603
+
+# Authorization errors
+AUTH_ERROR = -32504
+AUTH_TOKEN_INVALID = -32504
+AUTH_TOKEN_EXPIRED = -32504
+
+# Business logic errors
+INVALID_AMOUNT = -31001
+INVALID_ACCOUNT = -31050
+COULD_NOT_PERFORM = -31008
+COULD_NOT_CANCEL = -31007
+TRANSACTION_NOT_FOUND = -31003
+TRANSACTION_ALREADY_EXISTS = -31060
+TRANSACTION_ALREADY_CANCELLED = -31061
+TRANSACTION_ALREADY_COMPLETED = -31062