paytechuz 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

core/utils.py

@@ -1,192 +0,0 @@
-"""
-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

@@ -1,202 +0,0 @@
-"""
-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 format_amount, 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,
-        amount: Union[int, float, str],
-        account_id: Union[int, str],
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Create a payment using Click.
-
-        Args:
-            amount: The payment amount in som
-            account_id: The account ID or order ID
-            **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:
-            Dict containing payment details including transaction ID and payment URL
-        """
-        # Format amount to tiyin (1 som = 100 tiyin)
-        amount_tiyin = format_amount(amount)
-
-        # Extract additional parameters
-        description = kwargs.get('description', f'Payment for account {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={account_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"&merchant_user_id={description}"
-
-        # Generate a unique transaction ID
-        transaction_id = f"click_{account_id}_{int(amount_tiyin)}"
-
-        return {
-            'transaction_id': transaction_id,
-            'payment_url': payment_url,
-            'amount': amount,
-            'account_id': account_id,
-            'status': 'created',
-            'service_id': self.service_id,
-            'merchant_id': self.merchant_id
-        }
-
-    @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

@@ -1,264 +0,0 @@
-"""
-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, account_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(account_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,
-        account_id: Union[int, str],
-        reason: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Cancel payment.
-
-        Args:
-            account_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(account_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,
-        amount: Union[int, float],
-        account_id: Union[int, str],
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Create an invoice.
-
-        Args:
-            amount: Payment amount
-            account_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 {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(account_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