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

core/utils.py

@@ -0,0 +1,192 @@
+"""
+Utility functions for payment gateways.
+"""
+import base64
+import hashlib
+import hmac
+import json
+import logging
+import time
+from datetime import datetime
+from typing import Dict, Any, Union, Optional
+
+logger = logging.getLogger(__name__)
+
+def generate_timestamp() -> int:
+    """
+    Generate a Unix timestamp.
+
+    Returns:
+        Current Unix timestamp in seconds
+    """
+    return int(time.time())
+
+
+def generate_id(prefix: str = "") -> str:
+    """
+    Generate a unique ID.
+
+    Args:
+        prefix: Prefix for the ID
+
+    Returns:
+        Unique ID
+    """
+    timestamp = generate_timestamp()
+    unique_id = f"{timestamp}{hash(timestamp)}"
+    if prefix:
+        return f"{prefix}_{unique_id}"
+    return unique_id
+
+def format_amount(amount: Union[int, float, str]) -> int:
+    """
+    Format amount to integer (in tiyin/kopeyka).
+
+    Args:
+        amount: Amount in som/ruble
+
+    Returns:
+        Amount in tiyin/kopeyka (integer)
+    """
+    try:
+        # Convert to float first to handle string inputs
+        float_amount = float(amount)
+        # Convert to tiyin/kopeyka (multiply by 100) and round to integer
+        return int(float_amount * 100)
+    except (ValueError, TypeError) as e:
+        logger.error(f"Failed to format amount: {amount}, Error: {e}")
+        raise ValueError(f"Invalid amount format: {amount}")
+
+
+def format_datetime(dt: datetime) -> str:
+    """
+    Format datetime to ISO 8601 format.
+
+    Args:
+        dt: Datetime object
+
+    Returns:
+        Formatted datetime string
+    """
+    return dt.strftime("%Y-%m-%dT%H:%M:%S%z")
+
+def datetime_to_timestamp(dt: datetime) -> int:
+    """
+    Convert datetime to Unix timestamp.
+
+    Args:
+        dt: Datetime object
+
+    Returns:
+        Unix timestamp in seconds
+    """
+    return int(dt.timestamp())
+
+
+def timestamp_to_datetime(timestamp: int) -> datetime:
+    """
+    Convert Unix timestamp to datetime.
+
+    Args:
+        timestamp: Unix timestamp in seconds
+
+    Returns:
+        Datetime object
+    """
+    return datetime.fromtimestamp(timestamp)
+
+def generate_hmac_signature(
+    data: Union[str, Dict[str, Any], bytes],
+    secret_key: str,
+    algorithm: str = "sha256"
+) -> str:
+    """
+    Generate HMAC signature.
+
+    Args:
+        data: Data to sign
+        secret_key: Secret key for signing
+        algorithm: Hash algorithm to use
+
+    Returns:
+        HMAC signature as hexadecimal string
+    """
+    if isinstance(data, dict):
+        data = json.dumps(data, separators=(',', ':'))
+
+    if isinstance(data, str):
+        data = data.encode('utf-8')
+
+    key = secret_key.encode('utf-8')
+
+    if algorithm.lower() == "sha256":
+        signature = hmac.new(key, data, hashlib.sha256).hexdigest()
+    elif algorithm.lower() == "sha512":
+        signature = hmac.new(key, data, hashlib.sha512).hexdigest()
+    elif algorithm.lower() == "md5":
+        signature = hmac.new(key, data, hashlib.md5).hexdigest()
+    else:
+        raise ValueError(f"Unsupported algorithm: {algorithm}")
+
+    return signature
+
+
+def generate_basic_auth(username: str, password: str) -> str:
+    """
+    Generate Basic Authentication header value.
+
+    Args:
+        username: Username
+        password: Password
+
+    Returns:
+        Basic Authentication header value
+    """
+    auth_str = f"{username}:{password}"
+    auth_bytes = auth_str.encode('utf-8')
+    encoded = base64.b64encode(auth_bytes).decode('utf-8')
+    return f"Basic {encoded}"
+
+def handle_exceptions(func):
+    """
+    Decorator to handle exceptions and convert them to payment exceptions.
+
+    Args:
+        func: Function to decorate
+
+    Returns:
+        Decorated function
+    """
+    from paytechuz.core.exceptions import (
+        InternalServiceError,
+        exception_whitelist
+    )
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except exception_whitelist as exc:
+            # No need to wrap exceptions that are already payment exceptions
+            raise exc
+        except Exception as exc:
+            logger.exception(f"Unexpected error in {func.__name__}: {exc}")
+            raise InternalServiceError(str(exc))
+
+    return wrapper
+
+
+def validate_required_fields(data: Dict[str, Any], required_fields: list) -> Optional[str]:
+    """
+    Validate that all required fields are present in the data.
+
+    Args:
+        data: Data to validate
+        required_fields: List of required field names
+
+    Returns:
+        Error message if validation fails, None otherwise
+    """
+    missing_fields = [field for field in required_fields if field not in data or data[field] is None]
+    if missing_fields:
+        return f"Missing required fields: {', '.join(missing_fields)}"
+    return None

gateways/click/client.py

@@ -0,0 +1,199 @@
+"""
+Click payment gateway client.
+"""
+import logging
+from typing import Dict, Any, Optional, Union
+
+from paytechuz.core.base import BasePaymentGateway
+from paytechuz.core.http import HttpClient
+from paytechuz.core.constants import ClickNetworks
+from paytechuz.core.utils import handle_exceptions
+from paytechuz.gateways.click.merchant import ClickMerchantApi
+
+logger = logging.getLogger(__name__)
+
+
+class ClickGateway(BasePaymentGateway):
+    """
+    Click payment gateway implementation.
+
+    This class provides methods for interacting with the Click payment gateway,
+    including creating payments, checking payment status, and canceling payments.
+    """
+
+    def __init__(
+        self,
+        service_id: str,
+        merchant_id: str,
+        merchant_user_id: Optional[str] = None,
+        secret_key: Optional[str] = None,
+        is_test_mode: bool = False
+    ):
+        """
+        Initialize the Click gateway.
+
+        Args:
+            service_id: Click service ID
+            merchant_id: Click merchant ID
+            merchant_user_id: Click merchant user ID
+            secret_key: Secret key for authentication
+            is_test_mode: Whether to use the test environment
+        """
+        super().__init__(is_test_mode)
+        self.service_id = service_id
+        self.merchant_id = merchant_id
+        self.merchant_user_id = merchant_user_id
+        self.secret_key = secret_key
+
+        # Set the API URL based on the environment
+        url = ClickNetworks.TEST_NET if is_test_mode else ClickNetworks.PROD_NET
+
+        # Initialize HTTP client
+        self.http_client = HttpClient(base_url=url)
+
+        # Initialize merchant API
+        self.merchant_api = ClickMerchantApi(
+            http_client=self.http_client,
+            service_id=service_id,
+            merchant_user_id=merchant_user_id,
+            secret_key=secret_key
+        )
+
+    @handle_exceptions
+    def create_payment(
+        self,
+        id: Union[int, str],
+        amount: Union[int, float, str],
+        **kwargs
+    ) -> str:
+        """
+        Create a payment using Click.
+
+        Args:
+            id: The account ID or order ID
+            amount: The payment amount in som
+            **kwargs: Additional parameters for the payment
+                - description: Payment description
+                - return_url: URL to return after payment
+                - callback_url: URL for payment notifications
+                - language: Language code (uz, ru, en)
+                - phone: Customer phone number
+                - email: Customer email
+
+        Returns:
+            Payment URL string for redirecting the user to Click payment page
+        """
+        # Format amount for URL (no need to convert to tiyin for URL)
+
+        # Extract additional parameters
+        description = kwargs.get('description', f'Payment for account {id}')
+        return_url = kwargs.get('return_url')
+        callback_url = kwargs.get('callback_url')
+        # These parameters are not used in the URL but are available in the API
+        # language = kwargs.get('language', 'uz')
+        # phone = kwargs.get('phone')
+        # email = kwargs.get('email')
+
+        # Create payment URL
+        payment_url = "https://my.click.uz/services/pay"
+        payment_url += f"?service_id={self.service_id}"
+        payment_url += f"&merchant_id={self.merchant_id}"
+        payment_url += f"&amount={amount}"
+        payment_url += f"&transaction_param={id}"
+
+        if return_url:
+            payment_url += f"&return_url={return_url}"
+
+        if callback_url:
+            payment_url += f"&callback_url={callback_url}"
+
+        if description:
+            payment_url += f"&description={description}"
+
+        if self.merchant_user_id:
+            payment_url += f"&merchant_user_id={self.merchant_user_id}"
+
+        # Return the payment URL directly
+        return payment_url
+
+    @handle_exceptions
+    def check_payment(self, transaction_id: str) -> Dict[str, Any]:
+        """
+        Check payment status using Click merchant API.
+
+        Args:
+            transaction_id: The transaction ID to check
+
+        Returns:
+            Dict containing payment status and details
+        """
+        # Extract account_id from transaction_id
+        # Format: click_account_id_amount
+        parts = transaction_id.split('_')
+        if len(parts) < 3 or parts[0] != 'click':
+            raise ValueError(
+                f"Invalid transaction ID format: {transaction_id}"
+            )
+
+        account_id = parts[1]
+
+        # Check payment status using merchant API
+        payment_data = self.merchant_api.check_payment(account_id)
+
+        # Extract payment status
+        status = payment_data.get('status')
+
+        # Map Click status to our status
+        status_mapping = {
+            'success': 'paid',
+            'processing': 'waiting',
+            'failed': 'failed',
+            'cancelled': 'cancelled'
+        }
+
+        mapped_status = status_mapping.get(status, 'unknown')
+
+        return {
+            'transaction_id': transaction_id,
+            'status': mapped_status,
+            'amount': payment_data.get('amount'),
+            'paid_at': payment_data.get('paid_at'),
+            'created_at': payment_data.get('created_at'),
+            'raw_response': payment_data
+        }
+
+    @handle_exceptions
+    def cancel_payment(
+        self,
+        transaction_id: str,
+        reason: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Cancel payment using Click merchant API.
+
+        Args:
+            transaction_id: The transaction ID to cancel
+            reason: Optional reason for cancellation
+
+        Returns:
+            Dict containing cancellation status and details
+        """
+        # Extract account_id from transaction_id
+        # Format: click_account_id_amount
+        parts = transaction_id.split('_')
+        if len(parts) < 3 or parts[0] != 'click':
+            raise ValueError(
+                f"Invalid transaction ID format: {transaction_id}"
+            )
+
+        account_id = parts[1]
+
+        # Cancel payment using merchant API
+        cancel_data = self.merchant_api.cancel_payment(account_id, reason)
+
+        return {
+            'transaction_id': transaction_id,
+            'status': 'cancelled',
+            'cancelled_at': cancel_data.get('cancelled_at'),
+            'raw_response': cancel_data
+        }

gateways/click/merchant.py

@@ -0,0 +1,265 @@
+"""
+Click merchant API operations.
+"""
+import hashlib
+import logging
+from typing import Dict, Any, Optional, Union
+
+from paytechuz.core.http import HttpClient
+from paytechuz.core.constants import ClickEndpoints
+from paytechuz.core.utils import handle_exceptions, generate_timestamp
+
+logger = logging.getLogger(__name__)
+
+
+class ClickMerchantApi:
+    """
+    Click merchant API operations.
+
+    This class provides methods for interacting with the Click merchant API,
+    including checking payment status and canceling payments.
+    """
+
+    def __init__(
+        self,
+        http_client: HttpClient,
+        service_id: str,
+        merchant_user_id: Optional[str] = None,
+        secret_key: Optional[str] = None
+    ):
+        """
+        Initialize the Click merchant API.
+
+        Args:
+            http_client: HTTP client for making requests
+            service_id: Click service ID
+            merchant_user_id: Click merchant user ID
+            secret_key: Secret key for authentication
+        """
+        self.http_client = http_client
+        self.service_id = service_id
+        self.merchant_user_id = merchant_user_id
+        self.secret_key = secret_key
+
+    def _generate_signature(self, data: Dict[str, Any]) -> str:
+        """
+        Generate signature for Click API requests.
+
+        Args:
+            data: Request data
+
+        Returns:
+            Signature string
+        """
+        if not self.secret_key:
+            return ""
+
+        # Sort keys alphabetically
+        sorted_data = {k: data[k] for k in sorted(data.keys())}
+
+        # Create string to sign
+        sign_string = ""
+        for key, value in sorted_data.items():
+            if key != "sign":
+                sign_string += str(value)
+
+        # Add secret key
+        sign_string += self.secret_key
+
+        # Generate signature
+        return hashlib.md5(sign_string.encode('utf-8')).hexdigest()
+
+    @handle_exceptions
+    def check_payment(self, id: Union[int, str]) -> Dict[str, Any]:
+        """
+        Check payment status.
+
+        Args:
+            account_id: Account ID or order ID
+
+        Returns:
+            Dict containing payment status and details
+        """
+        # Prepare request data
+        data = {
+            "service_id": self.service_id,
+            "merchant_transaction_id": str(id),
+            "request_id": str(generate_timestamp())
+        }
+
+        # Add signature if secret key is provided
+        if self.secret_key:
+            data["sign"] = self._generate_signature(data)
+
+        # Make request
+        response = self.http_client.post(
+            endpoint=f"{ClickEndpoints.MERCHANT_API}/payment/status",
+            json_data=data
+        )
+
+        return response
+
+    @handle_exceptions
+    def cancel_payment(
+        self,
+        id: Union[int, str],
+        reason: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Cancel payment.
+
+        Args:
+            id: Account ID or order ID
+            reason: Optional reason for cancellation
+
+        Returns:
+            Dict containing cancellation status and details
+        """
+        # Prepare request data
+        data = {
+            "service_id": self.service_id,
+            "merchant_transaction_id": str(id),
+            "request_id": str(generate_timestamp())
+        }
+
+        # Add reason if provided
+        if reason:
+            data["reason"] = reason
+
+        # Add signature if secret key is provided
+        if self.secret_key:
+            data["sign"] = self._generate_signature(data)
+
+        # Make request
+        response = self.http_client.post(
+            endpoint=f"{ClickEndpoints.MERCHANT_API}/payment/cancel",
+            json_data=data
+        )
+
+        return response
+
+    @handle_exceptions
+    def create_invoice(
+        self,
+        id: Union[int, str],
+        amount: Union[int, float],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Create an invoice.
+
+        Args:
+            amount: Payment amount
+            id: Account ID or order ID
+            **kwargs: Additional parameters
+                - description: Payment description
+                - phone: Customer phone number
+                - email: Customer email
+                - expire_time: Invoice expiration time in minutes
+
+        Returns:
+            Dict containing invoice details
+        """
+        # Extract additional parameters
+        description = kwargs.get('description', f'Payment for account {id}')
+        phone = kwargs.get('phone')
+        email = kwargs.get('email')
+        expire_time = kwargs.get('expire_time', 60)  # Default 1 hour
+
+        # Prepare request data
+        data = {
+            "service_id": self.service_id,
+            "amount": float(amount),
+            "merchant_transaction_id": str(id),
+            "description": description,
+            "request_id": str(generate_timestamp()),
+            "expire_time": expire_time
+        }
+
+        # Add optional parameters
+        if phone:
+            data["phone"] = phone
+
+        if email:
+            data["email"] = email
+
+        # Add signature if secret key is provided
+        if self.secret_key:
+            data["sign"] = self._generate_signature(data)
+
+        # Make request
+        response = self.http_client.post(
+            endpoint=f"{ClickEndpoints.MERCHANT_API}/invoice/create",
+            json_data=data
+        )
+
+        return response
+
+    @handle_exceptions
+    def check_invoice(self, invoice_id: str) -> Dict[str, Any]:
+        """
+        Check invoice status.
+
+        Args:
+            invoice_id: Invoice ID
+
+        Returns:
+            Dict containing invoice status and details
+        """
+        # Prepare request data
+        data = {
+            "service_id": self.service_id,
+            "invoice_id": invoice_id,
+            "request_id": str(generate_timestamp())
+        }
+
+        # Add signature if secret key is provided
+        if self.secret_key:
+            data["sign"] = self._generate_signature(data)
+
+        # Make request
+        response = self.http_client.post(
+            endpoint=f"{ClickEndpoints.MERCHANT_API}/invoice/status",
+            json_data=data
+        )
+
+        return response
+
+    @handle_exceptions
+    def cancel_invoice(
+        self,
+        invoice_id: str,
+        reason: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Cancel invoice.
+
+        Args:
+            invoice_id: Invoice ID
+            reason: Optional reason for cancellation
+
+        Returns:
+            Dict containing cancellation status and details
+        """
+        # Prepare request data
+        data = {
+            "service_id": self.service_id,
+            "invoice_id": invoice_id,
+            "request_id": str(generate_timestamp())
+        }
+
+        # Add reason if provided
+        if reason:
+            data["reason"] = reason
+
+        # Add signature if secret key is provided
+        if self.secret_key:
+            data["sign"] = self._generate_signature(data)
+
+        # Make request
+        response = self.http_client.post(
+            endpoint=f"{ClickEndpoints.MERCHANT_API}/invoice/cancel",
+            json_data=data
+        )
+
+        return response