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

gateways/click/webhook.py

@@ -1,227 +0,0 @@
-"""
-Click webhook handler.
-"""
-import hashlib
-import logging
-from typing import Dict, Any, Callable
-
-from paytechuz.core.base import BaseWebhookHandler
-from paytechuz.core.constants import ClickActions
-from paytechuz.core.exceptions import (
-    PermissionDenied,
-    InvalidAmount,
-    TransactionNotFound,
-    UnsupportedMethod,
-    AccountNotFound
-)
-from paytechuz.core.utils import handle_exceptions
-
-logger = logging.getLogger(__name__)
-
-class ClickWebhookHandler(BaseWebhookHandler):
-    """
-    Click webhook handler.
-
-    This class handles webhook requests from the Click payment system,
-    including transaction preparation and completion.
-    """
-
-    def __init__(
-        self,
-        service_id: str,
-        secret_key: str,
-        find_transaction_func: Callable[[str], Dict[str, Any]],
-        find_account_func: Callable[[str], Dict[str, Any]],
-        create_transaction_func: Callable[[Dict[str, Any]], Dict[str, Any]],
-        complete_transaction_func: Callable[[str, bool], Dict[str, Any]],
-        commission_percent: float = 0.0
-    ):
-        """
-        Initialize the Click webhook handler.
-
-        Args:
-            service_id: Click service ID
-            secret_key: Secret key for authentication
-            find_transaction_func: Function to find a transaction by ID
-            find_account_func: Function to find an account by ID
-            create_transaction_func: Function to create a transaction
-            complete_transaction_func: Function to complete a transaction
-            commission_percent: Commission percentage
-        """
-        self.service_id = service_id
-        self.secret_key = secret_key
-        self.find_transaction = find_transaction_func
-        self.find_account = find_account_func
-        self.create_transaction = create_transaction_func
-        self.complete_transaction = complete_transaction_func
-        self.commission_percent = commission_percent
-
-    def _check_auth(self, params: Dict[str, Any]) -> None:
-        """
-        Check authentication using signature.
-
-        Args:
-            params: Request parameters
-
-        Raises:
-            PermissionDenied: If authentication fails
-        """
-        if str(params.get('service_id')) != self.service_id:
-            raise PermissionDenied("Invalid service ID")
-
-        # Check signature if secret key is provided
-        if self.secret_key:
-            sign_string = params.get('sign_string')
-            sign_time = params.get('sign_time')
-
-            if not sign_string or not sign_time:
-                raise PermissionDenied("Missing signature parameters")
-
-            # Create string to sign
-            to_sign = f"{params.get('click_trans_id')}{params.get('service_id')}"
-            to_sign += f"{self.secret_key}{params.get('merchant_trans_id')}"
-            to_sign += f"{params.get('amount')}{params.get('action')}"
-            to_sign += f"{sign_time}"
-
-            # Generate signature
-            signature = hashlib.md5(to_sign.encode('utf-8')).hexdigest()
-
-            if signature != sign_string:
-                raise PermissionDenied("Invalid signature")
-
-    def _validate_amount(
-        self,
-        received_amount: float,
-        expected_amount: float
-    ) -> None:
-        """
-        Validate payment amount.
-
-        Args:
-            received_amount: Amount received from Click
-            expected_amount: Expected amount
-
-        Raises:
-            InvalidAmount: If amounts don't match
-        """
-        # Add commission if needed
-        if self.commission_percent > 0:
-            expected_amount = expected_amount * (1 + self.commission_percent / 100)
-            expected_amount = round(expected_amount, 2)
-
-        # Allow small difference due to floating point precision
-        if abs(received_amount - expected_amount) > 0.01:
-            raise InvalidAmount(f"Incorrect amount. Expected: {expected_amount}, received: {received_amount}")
-
-    @handle_exceptions
-    def handle_webhook(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Handle webhook data from Click.
-
-        Args:
-            data: The webhook data received from Click
-
-        Returns:
-            Dict containing the response to be sent back to Click
-
-        Raises:
-            PermissionDenied: If authentication fails
-            UnsupportedMethod: If the requested action is not supported
-        """
-        # Check authentication
-        self._check_auth(data)
-
-        # Extract parameters
-        click_trans_id = data.get('click_trans_id')
-        merchant_trans_id = data.get('merchant_trans_id')
-        amount = float(data.get('amount', 0))
-        action = int(data.get('action', -1))
-        error = int(data.get('error', 0))
-
-        # Find account
-        try:
-            account = self.find_account(merchant_trans_id)
-        except AccountNotFound:
-            logger.error(f"Account not found: {merchant_trans_id}")
-            return {
-                'click_trans_id': click_trans_id,
-                'merchant_trans_id': merchant_trans_id,
-                'error': -5,
-                'error_note': "User not found"
-            }
-
-        # Validate amount
-        try:
-            self._validate_amount(amount, float(account.get('amount', 0)))
-        except InvalidAmount as e:
-            logger.error(f"Invalid amount: {e}")
-            return {
-                'click_trans_id': click_trans_id,
-                'merchant_trans_id': merchant_trans_id,
-                'error': -2,
-                'error_note': str(e)
-            }
-
-        # Check if transaction already exists
-        try:
-            transaction = self.find_transaction(click_trans_id)
-
-            # If transaction is already completed, return success
-            if transaction.get('state') == 2:  # SUCCESSFULLY
-                return {
-                    'click_trans_id': click_trans_id,
-                    'merchant_trans_id': merchant_trans_id,
-                    'merchant_prepare_id': transaction.get('id'),
-                    'error': 0,
-                    'error_note': "Success"
-                }
-
-            # If transaction is cancelled, return error
-            if transaction.get('state') == -2:  # CANCELLED
-                return {
-                    'click_trans_id': click_trans_id,
-                    'merchant_trans_id': merchant_trans_id,
-                    'merchant_prepare_id': transaction.get('id'),
-                    'error': -9,
-                    'error_note': "Transaction cancelled"
-                }
-        except TransactionNotFound:
-            # Transaction doesn't exist, continue with the flow
-            pass
-
-        # Handle different actions
-        if action == ClickActions.PREPARE:
-            # Create transaction
-            transaction = self.create_transaction({
-                'click_trans_id': click_trans_id,
-                'merchant_trans_id': merchant_trans_id,
-                'amount': amount,
-                'account': account
-            })
-
-            return {
-                'click_trans_id': click_trans_id,
-                'merchant_trans_id': merchant_trans_id,
-                'merchant_prepare_id': transaction.get('id'),
-                'error': 0,
-                'error_note': "Success"
-            }
-
-        elif action == ClickActions.COMPLETE:
-            # Check if error is negative (payment failed)
-            is_successful = error >= 0
-
-            # Complete transaction
-            transaction = self.complete_transaction(click_trans_id, is_successful)
-
-            return {
-                'click_trans_id': click_trans_id,
-                'merchant_trans_id': merchant_trans_id,
-                'merchant_prepare_id': transaction.get('id'),
-                'error': 0,
-                'error_note': "Success"
-            }
-
-        else:
-            logger.error(f"Unsupported action: {action}")
-            raise UnsupportedMethod(f"Unsupported action: {action}")

gateways/payme/cards.py

@@ -1,222 +0,0 @@
-"""
-Payme cards operations.
-"""
-import logging
-from typing import Dict, Any
-
-from paytechuz.core.http import HttpClient
-from paytechuz.core.constants import PaymeEndpoints
-from paytechuz.core.utils import handle_exceptions
-
-logger = logging.getLogger(__name__)
-
-class PaymeCards:
-    """
-    Payme cards operations.
-
-    This class provides methods for working with cards in the Payme payment system,
-    including creating cards, verifying cards, and removing cards.
-    """
-
-    def __init__(self, http_client: HttpClient, payme_id: str):
-        """
-        Initialize the Payme cards component.
-
-        Args:
-            http_client: HTTP client for making requests
-            payme_id: Payme merchant ID
-        """
-        self.http_client = http_client
-        self.payme_id = payme_id
-
-    @handle_exceptions
-    def create(
-        self,
-        card_number: str,
-        expire_date: str,
-        save: bool = True,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Create a new card.
-
-        Args:
-            card_number: Card number
-            expire_date: Card expiration date in format "MM/YY"
-            save: Whether to save the card for future use
-            **kwargs: Additional parameters
-                - phone: Customer phone number
-                - language: Language code (uz, ru, en)
-
-        Returns:
-            Dict containing card creation response
-        """
-        # Extract additional parameters
-        phone = kwargs.get('phone')
-        language = kwargs.get('language', 'uz')
-
-        # Prepare request data
-        data = {
-            "method": PaymeEndpoints.CARDS_CREATE,
-            "params": {
-                "card": {
-                    "number": card_number,
-                    "expire": expire_date
-                },
-                "save": save,
-                "merchant_id": self.payme_id
-            }
-        }
-
-        # Add optional parameters
-        if phone:
-            data["params"]["phone"] = phone
-
-        # Add language header
-        headers = {"Accept-Language": language}
-
-        # Make request
-        response = self.http_client.post(
-            endpoint="",
-            json_data=data,
-            headers=headers
-        )
-
-        return response
-
-    @handle_exceptions
-    def verify(
-        self,
-        token: str,
-        code: str,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Verify a card with the verification code.
-
-        Args:
-            token: Card token received from create method
-            code: Verification code sent to the card owner
-            **kwargs: Additional parameters
-                - language: Language code (uz, ru, en)
-
-        Returns:
-            Dict containing card verification response
-        """
-        # Extract additional parameters
-        language = kwargs.get('language', 'uz')
-
-        # Prepare request data
-        data = {
-            "method": PaymeEndpoints.CARDS_VERIFY,
-            "params": {
-                "token": token,
-                "code": code
-            }
-        }
-
-        # Add language header
-        headers = {"Accept-Language": language}
-
-        # Make request
-        response = self.http_client.post(
-            endpoint="",
-            json_data=data,
-            headers=headers
-        )
-
-        return response
-
-    @handle_exceptions
-    def check(self, token: str) -> Dict[str, Any]:
-        """
-        Check if a card exists and is active.
-
-        Args:
-            token: Card token
-
-        Returns:
-            Dict containing card check response
-        """
-        # Prepare request data
-        data = {
-            "method": PaymeEndpoints.CARDS_CHECK,
-            "params": {
-                "token": token
-            }
-        }
-
-        # Make request
-        response = self.http_client.post(
-            endpoint="",
-            json_data=data
-        )
-
-        return response
-
-    @handle_exceptions
-    def remove(self, token: str) -> Dict[str, Any]:
-        """
-        Remove a card.
-
-        Args:
-            token: Card token
-
-        Returns:
-            Dict containing card removal response
-        """
-        # Prepare request data
-        data = {
-            "method": PaymeEndpoints.CARDS_REMOVE,
-            "params": {
-                "token": token
-            }
-        }
-
-        # Make request
-        response = self.http_client.post(
-            endpoint="",
-            json_data=data
-        )
-
-        return response
-
-    @handle_exceptions
-    def get_verify_code(
-        self,
-        token: str,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Get a new verification code for a card.
-
-        Args:
-            token: Card token
-            **kwargs: Additional parameters
-                - language: Language code (uz, ru, en)
-
-        Returns:
-            Dict containing verification code response
-        """
-        # Extract additional parameters
-        language = kwargs.get('language', 'uz')
-
-        # Prepare request data
-        data = {
-            "method": PaymeEndpoints.CARDS_GET_VERIFY_CODE,
-            "params": {
-                "token": token
-            }
-        }
-
-        # Add language header
-        headers = {"Accept-Language": language}
-
-        # Make request
-        response = self.http_client.post(
-            endpoint="",
-            json_data=data,
-            headers=headers
-        )
-
-        return response

gateways/payme/client.py

@@ -1,238 +0,0 @@
-"""
-Payme 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 PaymeNetworks
-from paytechuz.core.utils import format_amount, handle_exceptions
-from paytechuz.gateways.payme.cards import PaymeCards
-from paytechuz.gateways.payme.receipts import PaymeReceipts
-
-logger = logging.getLogger(__name__)
-
-class PaymeGateway(BasePaymentGateway):
-    """
-    Payme payment gateway implementation.
-
-    This class provides methods for interacting with the Payme payment gateway,
-    including creating payments, checking payment status, and canceling payments.
-    """
-
-    def __init__(
-        self,
-        payme_id: str,
-        payme_key: Optional[str] = None,
-        fallback_id: Optional[str] = None,
-        is_test_mode: bool = False
-    ):
-        """
-        Initialize the Payme gateway.
-
-        Args:
-            payme_id: Payme merchant ID
-            payme_key: Payme merchant key for authentication
-            fallback_id: Fallback merchant ID
-            is_test_mode: Whether to use the test environment
-        """
-        super().__init__(is_test_mode)
-        self.payme_id = payme_id
-        self.payme_key = payme_key
-        self.fallback_id = fallback_id
-
-        # Set the API URL based on the environment
-        url = PaymeNetworks.TEST_NET if is_test_mode else PaymeNetworks.PROD_NET
-
-        # Initialize HTTP client
-        self.http_client = HttpClient(base_url=url)
-
-        # Initialize components
-        self.cards = PaymeCards(http_client=self.http_client, payme_id=payme_id)
-        self.receipts = PaymeReceipts(
-            http_client=self.http_client,
-            payme_id=payme_id,
-            payme_key=payme_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 Payme receipts.
-
-        Args:
-            amount: The payment amount in som
-            account_id: The account ID or order ID
-            **kwargs: Additional parameters for the payment
-                - description: Payment description
-                - detail: Payment details
-                - callback_url: URL to redirect after payment
-                - return_url: URL to return after payment
-                - phone: Customer phone number
-                - email: Customer email
-                - language: Language code (uz, ru, en)
-                - expire_minutes: Payment expiration time in minutes
-
-        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}')
-        detail = kwargs.get('detail', {})
-        callback_url = kwargs.get('callback_url')
-        return_url = kwargs.get('return_url')
-        phone = kwargs.get('phone')
-        email = kwargs.get('email')
-        language = kwargs.get('language', 'uz')
-        expire_minutes = kwargs.get('expire_minutes', 60)  # Default 1 hour
-
-        # Check if we have a merchant key
-        if self.payme_key:
-            # Create receipt using the API
-            receipt_data = self.receipts.create(
-                amount=amount_tiyin,
-                account={"account_id": str(account_id)},
-                description=description,
-                detail=detail,
-                callback_url=callback_url,
-                return_url=return_url,
-                phone=phone,
-                email=email,
-                language=language,
-                expire_minutes=expire_minutes
-            )
-
-            # Extract receipt ID and payment URL
-            receipt_id = receipt_data.get('receipt', {}).get('_id')
-            payment_url = receipt_data.get('receipt', {}).get('pay_url')
-
-            return {
-                'transaction_id': receipt_id,
-                'payment_url': payment_url,
-                'amount': amount,
-                'account_id': account_id,
-                'status': 'created',
-                'raw_response': receipt_data
-            }
-        else:
-            # Generate a payment URL using payme-pkg style
-            # This is a fallback method that doesn't require authentication
-            import base64
-            from paytechuz.core.utils import generate_id
-
-            # Generate a unique transaction ID
-            transaction_id = generate_id("payme")
-
-            # Format amount to the smallest currency unit (tiyin)
-            # amount_tiyin is already in tiyin format
-
-            # Build the payment parameters string
-            # Format: m=merchant_id;ac.field=value;a=amount;c=callback_url
-            params_str = f"m={self.payme_id};ac.id={account_id};a={amount_tiyin}"
-
-            # Add callback URL if provided (this is used for return URL in payme-pkg)
-            if return_url:
-                params_str += f";c={return_url}"
-
-            # Encode the parameters string to base64
-            encoded_params = base64.b64encode(params_str.encode("utf-8")).decode("utf-8")
-
-            # Build the payment URL
-            if self.is_test_mode:
-                payment_url = f"https://test.paycom.uz/{encoded_params}"
-            else:
-                payment_url = f"https://checkout.paycom.uz/{encoded_params}"
-
-            # Print the parameters for debugging
-            print("Payme payment parameters:")
-            print(f"Parameters string: {params_str}")
-            print(f"Encoded parameters: {encoded_params}")
-            print(f"Payment URL: {payment_url}")
-
-            return {
-                'transaction_id': transaction_id,
-                'payment_url': payment_url,
-                'amount': amount,
-                'account_id': account_id,
-                'status': 'created',
-                'raw_response': {}
-            }
-
-    @handle_exceptions
-    def check_payment(self, transaction_id: str) -> Dict[str, Any]:
-        """
-        Check payment status using Payme receipts.
-
-        Args:
-            transaction_id: The receipt ID to check
-
-        Returns:
-            Dict containing payment status and details
-        """
-        receipt_data = self.receipts.check(receipt_id=transaction_id)
-
-        # Extract receipt status
-        receipt = receipt_data.get('receipt', {})
-        status = receipt.get('state')
-
-        # Map Payme status to our status
-        status_mapping = {
-            0: 'created',
-            1: 'waiting',
-            2: 'paid',
-            3: 'cancelled',
-            4: 'refunded'
-        }
-
-        mapped_status = status_mapping.get(status, 'unknown')
-
-        return {
-            'transaction_id': transaction_id,
-            'status': mapped_status,
-            'amount': receipt.get('amount') / 100,  # Convert from tiyin to som
-            'paid_at': receipt.get('pay_time'),
-            'created_at': receipt.get('create_time'),
-            'cancelled_at': receipt.get('cancel_time'),
-            'raw_response': receipt_data
-        }
-
-    @handle_exceptions
-    def cancel_payment(
-        self,
-        transaction_id: str,
-        reason: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Cancel payment using Payme receipts.
-
-        Args:
-            transaction_id: The receipt ID to cancel
-            reason: Optional reason for cancellation
-
-        Returns:
-            Dict containing cancellation status and details
-        """
-        receipt_data = self.receipts.cancel(
-            receipt_id=transaction_id,
-            reason=reason or "Cancelled by merchant"
-        )
-
-        # Extract receipt status
-        receipt = receipt_data.get('receipt', {})
-        status = receipt.get('state')
-
-        return {
-            'transaction_id': transaction_id,
-            'status': 'cancelled' if status == 3 else 'unknown',
-            'cancelled_at': receipt.get('cancel_time'),
-            'raw_response': receipt_data
-        }