paytechuz 0.2.24__py3-none-any.whl → 0.3.0__py3-none-any.whl

paytechuz/__init__.py

@@ -1,12 +1,12 @@
 """
 PayTechUZ - Unified payment library for Uzbekistan payment systems.
 
-This library provides a unified interface for working with Payme and Click
+This library provides a unified interface for working with Payme, Click, and Atmos
 payment systems in Uzbekistan. It supports Django, Flask, and FastAPI.
 """
 from typing import Any
 
-__version__ = '0.2.24'
+__version__ = '0.3.0'
 
 # Import framework integrations - these imports are used to check availability
 # of frameworks, not for direct usage
@@ -31,6 +31,7 @@ except ImportError:
 from paytechuz.core.base import BasePaymentGateway  # noqa: E402
 from paytechuz.gateways.payme.client import PaymeGateway  # noqa: E402
 from paytechuz.gateways.click.client import ClickGateway  # noqa: E402
+from paytechuz.gateways.atmos.client import AtmosGateway  # noqa: E402
 from paytechuz.core.constants import PaymentGateway  # noqa: E402
 
 
@@ -39,7 +40,7 @@ def create_gateway(gateway_type: str, **kwargs) -> BasePaymentGateway:
     Create a payment gateway instance.
 
     Args:
-        gateway_type: Type of gateway ('payme' or 'click')
+        gateway_type: Type of gateway ('payme', 'click', or 'atmos')
         **kwargs: Gateway-specific configuration
 
     Returns:
@@ -53,5 +54,7 @@ def create_gateway(gateway_type: str, **kwargs) -> BasePaymentGateway:
         return PaymeGateway(**kwargs)
     if gateway_type.lower() == PaymentGateway.CLICK.value:
         return ClickGateway(**kwargs)
+    if gateway_type.lower() == PaymentGateway.ATMOS.value:
+        return AtmosGateway(**kwargs)
 
     raise ValueError(f"Unsupported gateway type: {gateway_type}")

paytechuz/core/constants.py

@@ -16,6 +16,7 @@ class PaymentGateway(Enum):
     """Payment gateway types."""
     PAYME = "payme"
     CLICK = "click"
+    ATMOS = "atmos"
 
 class PaymeEndpoints:
     """Payme API endpoints."""
@@ -66,3 +67,27 @@ class PaymeCancelReason:
     REASON_CANCELLED_BY_USER = 7
     REASON_SUSPICIOUS_OPERATION = 8
     REASON_MERCHANT_DECISION = 9
+
+
+class AtmosEndpoints:
+    """Atmos API endpoints."""
+    TOKEN = "/token"
+    CREATE_PAYMENT = "/merchant/pay/create"
+    CHECK_PAYMENT = "/merchant/pay/get-status"
+    CANCEL_PAYMENT = "/merchant/pay/cancel"
+
+
+class AtmosNetworks:
+    """Atmos API networks."""
+    PROD_NET = "https://partner.atmos.uz"
+    TEST_CHECKOUT = "https://test-checkout.pays.uz/invoice/get"
+    PROD_CHECKOUT = "https://checkout.pays.uz/invoice/get"
+
+
+class AtmosTransactionStatus:
+    """Atmos transaction status codes."""
+    CREATED = "created"
+    PENDING = "pending"
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"

paytechuz/gateways/atmos/__init__.py

@@ -0,0 +1,2 @@
+"""Atmos payment gateway implementation."""
+from .client import AtmosGateway  # noqa: F401

paytechuz/gateways/atmos/client.py

@@ -0,0 +1,212 @@
+"""
+Atmos payment gateway client.
+"""
+import base64
+import logging
+from typing import Dict, Any, Optional, Union
+
+from paytechuz.core.base import BasePaymentGateway
+from paytechuz.core.http import HttpClient
+from paytechuz.core.utils import handle_exceptions
+
+logger = logging.getLogger(__name__)
+
+
+class AtmosGateway(BasePaymentGateway):
+    """
+    Atmos payment gateway implementation.
+
+    This class provides methods for interacting with the Atmos payment gateway,
+    including creating payments, checking payment status, and canceling
+    payments.
+    """
+
+    def __init__(
+        self,
+        consumer_key: str,
+        consumer_secret: str,
+        store_id: str,
+        terminal_id: Optional[str] = None,
+        is_test_mode: bool = False
+    ):
+        """
+        Initialize the Atmos gateway.
+
+        Args:
+            consumer_key: Atmos consumer key
+            consumer_secret: Atmos consumer secret
+            store_id: Atmos store ID
+            terminal_id: Atmos terminal ID (optional)
+            is_test_mode: Whether to use the test environment
+        """
+        super().__init__(is_test_mode)
+        self.consumer_key = consumer_key
+        self.consumer_secret = consumer_secret
+        self.store_id = store_id
+        self.terminal_id = terminal_id
+
+        # Base URL is hard coded as per requirements
+        self.base_url = 'https://partner.atmos.uz'
+
+        # Initialize HTTP client
+        self.client = HttpClient(base_url=self.base_url)
+
+        # Get access token
+        self._access_token = None
+        self._get_access_token()
+
+    def _get_access_token(self) -> str:
+        """Get access token for API authentication."""
+        try:
+            # Create basic auth header
+            credentials = f"{self.consumer_key}:{self.consumer_secret}"
+            encoded_credentials = base64.b64encode(
+                credentials.encode('utf-8')).decode('utf-8')
+
+            headers = {
+                'Authorization': f'Basic {encoded_credentials}',
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+
+            data = {'grant_type': 'client_credentials'}
+
+            response = self.client.post('/token', data=data, headers=headers)
+
+            if response.get('access_token'):
+                self._access_token = response['access_token']
+                return self._access_token
+
+            raise ValueError("Failed to get access token")
+
+        except Exception as e:
+            logger.error("Error getting access token: %s", e)
+            raise
+
+    def _make_request(self, endpoint: str,
+                      data: Dict[str, Any]) -> Dict[str, Any]:
+        """Make authenticated request to Atmos API."""
+        if not self._access_token:
+            self._get_access_token()
+
+        headers = {
+            'Authorization': f'Bearer {self._access_token}',
+            'Content-Type': 'application/json'
+        }
+
+        try:
+            response = self.client.post(endpoint, json_data=data,
+                                        headers=headers)
+            return response
+        except Exception as e:
+            logger.error("API request failed: %s", e)
+            raise
+
+    @handle_exceptions
+    def create_payment(
+        self,
+        account_id: Union[int, str],
+        amount: Union[int, float, str],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Create a payment transaction.
+
+        Args:
+            account_id: The account ID or order ID
+            amount: The payment amount
+            **kwargs: Additional parameters
+
+        Returns:
+            Dict containing payment details including transaction ID and
+            payment URL
+        """
+        # Convert amount to tiyin (multiply by 100)
+        amount_tiyin = int(float(amount) * 100)
+
+        # Prepare request data
+        create_data = {
+            'amount': amount_tiyin,
+            'account': str(account_id),
+            'store_id': self.store_id
+        }
+
+        # Add terminal_id if provided
+        if self.terminal_id:
+            create_data['terminal_id'] = self.terminal_id
+
+        # Create transaction
+        response = self._make_request('/merchant/pay/create', create_data)
+        transaction_id = response['transaction_id']
+
+        # Generate payment URL
+        if self.is_test_mode:
+            base_url = "https://test-checkout.pays.uz/invoice/get"
+        else:
+            base_url = "https://checkout.pays.uz/invoice/get"
+
+        payment_url = (f"{base_url}?storeId={self.store_id}"
+                       f"&transactionId={transaction_id}")
+
+        return {
+            'transaction_id': transaction_id,
+            'payment_url': payment_url,
+            'amount': amount,
+            'account': str(account_id),
+            'status': 'created'
+        }
+
+    @handle_exceptions
+    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
+        """
+        data = {
+            'transaction_id': transaction_id,
+            'store_id': self.store_id
+        }
+
+        response = self._make_request('/merchant/pay/get-status', data)
+
+        return {
+            'transaction_id': transaction_id,
+            'status': response.get('status', 'unknown'),
+            'details': response
+        }
+
+    @handle_exceptions
+    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
+        """
+        data = {
+            'transaction_id': transaction_id,
+            'store_id': self.store_id
+        }
+
+        if reason:
+            data['reason'] = reason
+
+        response = self._make_request('/merchant/pay/cancel', data)
+
+        return {
+            'transaction_id': transaction_id,
+            'status': 'cancelled',
+            'details': response
+        }

paytechuz/gateways/atmos/webhook.py

@@ -0,0 +1,99 @@
+"""
+Atmos webhook handler.
+"""
+import hashlib
+import logging
+from typing import Dict, Any
+
+from paytechuz.core.base import BaseWebhookHandler
+
+logger = logging.getLogger(__name__)
+
+
+class AtmosWebhookHandler(BaseWebhookHandler):
+    """
+    Atmos webhook handler for processing payment notifications.
+    """
+
+    def __init__(self, api_key: str):
+        """
+        Initialize the webhook handler.
+
+        Args:
+            api_key: API key for signature verification
+        """
+        self.api_key = api_key
+
+    def verify_signature(self, webhook_data: Dict[str, Any],
+                         received_signature: str) -> bool:
+        """
+        Verify webhook signature from Atmos.
+
+        Args:
+            webhook_data: The webhook data received
+            received_signature: The signature received from Atmos
+
+        Returns:
+            bool: True if signature is valid, False otherwise
+        """
+        # Extract data from webhook
+        store_id = str(webhook_data.get('store_id', ''))
+        transaction_id = str(webhook_data.get('transaction_id', ''))
+        invoice = str(webhook_data.get('invoice', ''))
+        amount = str(webhook_data.get('amount', ''))
+
+        # Create signature string:
+        # store_id+transaction_id+invoice+amount+api_key
+        signature_string = (f"{store_id}{transaction_id}{invoice}"
+                            f"{amount}{self.api_key}")
+
+        # Generate MD5 hash
+        calculated_signature = hashlib.md5(
+            signature_string.encode('utf-8')).hexdigest()
+
+        # Compare signatures
+        return calculated_signature == received_signature
+
+    def handle_webhook(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle webhook data from Atmos.
+
+        Args:
+            data: The webhook data received from Atmos
+
+        Returns:
+            Dict containing the response to be sent back to Atmos
+        """
+        try:
+            # Extract signature
+            received_signature = data.get('sign', '')
+
+            # Verify signature
+            if not self.verify_signature(data, received_signature):
+                logger.error("Invalid webhook signature")
+                return {
+                    'status': 0,
+                    'message': 'Invalid signature'
+                }
+
+            # Extract webhook data
+            transaction_id = data.get('transaction_id')
+            amount = data.get('amount')
+            invoice = data.get('invoice')
+
+            logger.info("Webhook received for transaction %s, "
+                        "invoice %s, amount %s",
+                        transaction_id, invoice, amount)
+
+            # Return success response
+            return {
+                'status': 1,
+                'message': 'Успешно'
+            }
+
+        except ValueError as e:
+            logger.error("Webhook processing error: %s", e)
+            return {
+                'status': 0,
+                'message': f'Error: {str(e)}'
+            }

paytechuz/integrations/django/migrations/0002_alter_paymenttransaction_gateway.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.5 on 2025-08-19 08:13
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('django', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='paymenttransaction',
+            name='gateway',
+            field=models.CharField(choices=[('payme', 'Payme'), ('click', 'Click'), ('atmos', 'Atmos')], max_length=10),
+        ),
+    ]

paytechuz/integrations/django/models.py

@@ -12,10 +12,12 @@ class PaymentTransaction(models.Model):
     # Payment gateway choices
     PAYME = 'payme'
     CLICK = 'click'
+    ATMOS = 'atmos'
 
     GATEWAY_CHOICES = [
         (PAYME, 'Payme'),
         (CLICK, 'Click'),
+        (ATMOS, 'Atmos'),
     ]
 
     # Transaction states

paytechuz/integrations/django/views.py

@@ -5,7 +5,7 @@ import logging
 from django.views.decorators.csrf import csrf_exempt
 from django.utils.decorators import method_decorator
 
-from .webhooks import PaymeWebhook, ClickWebhook
+from .webhooks import PaymeWebhook, ClickWebhook, AtmosWebhook
 
 logger = logging.getLogger(__name__)
 
@@ -98,3 +98,39 @@ class BaseClickWebhookView(ClickWebhook):
             transaction: Transaction object
         """
         logger.info(f"Click payment cancelled: {transaction.transaction_id}")
+
+
+@method_decorator(csrf_exempt, name='dispatch')
+class BaseAtmosWebhookView(AtmosWebhook):
+    """
+    Default Atmos webhook view.
+
+    This view handles webhook requests from the Atmos payment system.
+    You can extend this class and override the event methods to customize
+    the behavior.
+
+    Example:
+    ```python
+    from paytechuz.integrations.django.views import AtmosWebhookView
+
+    class CustomAtmosWebhookView(AtmosWebhookView):
+        def successfully_payment(self, params, transaction):
+            # Your custom logic here
+            print(f"Payment successful: {transaction.transaction_id}")
+
+            # Update your order status
+            order = Order.objects.get(id=transaction.account_id)
+            order.status = 'paid'
+            order.save()
+    ```
+    """
+
+    def successfully_payment(self, params, transaction):
+        """
+        Called when a payment is successful.
+
+        Args:
+            params: Request parameters
+            transaction: Transaction object
+        """
+        logger.info(f"Atmos payment successful: {transaction.transaction_id}")

paytechuz/integrations/django/webhooks.py

@@ -898,3 +898,134 @@ class ClickWebhook(View):
             transaction: Transaction object
         """
         # This method is meant to be overridden by subclasses
+
+
+class AtmosWebhook(View):
+    """
+    Base Atmos webhook handler for Django.
+
+    This class handles webhook requests from the Atmos payment system.
+    You can extend this class and override the event methods to customize
+    the behavior.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        paytechuz_settings = getattr(settings, 'PAYTECHUZ', {})
+        atmos_settings = paytechuz_settings.get('ATMOS', {})
+
+        self.api_key = (
+            atmos_settings.get('API_KEY') or
+            getattr(settings, 'ATMOS_API_KEY', '')
+        )
+
+        account_model_path = (
+            atmos_settings.get('ACCOUNT_MODEL') or
+            getattr(settings, 'ATMOS_ACCOUNT_MODEL', 'django.contrib.auth.models.User')
+        )
+        try:
+            self.account_model = import_string(account_model_path)
+        except ImportError:
+            logger.error(
+                "Could not import %s. Check PAYTECHUZ.ATMOS.ACCOUNT_MODEL setting.",
+                account_model_path
+            )
+            raise ImportError(f"Import error: {account_model_path}") from None
+
+        self.account_field = (
+            atmos_settings.get('ACCOUNT_FIELD') or
+            getattr(settings, 'ATMOS_ACCOUNT_FIELD', 'id')
+        )
+
+    def post(self, request, **_):
+        """
+        Handle POST requests from Atmos.
+        """
+        try:
+            # Parse request data
+            data = json.loads(request.body.decode('utf-8'))
+
+            # Verify signature
+            received_signature = data.get('sign', '')
+            if not self._verify_signature(data, received_signature):
+                logger.error("Invalid webhook signature")
+                return JsonResponse({
+                    'status': 0,
+                    'message': 'Invalid signature'
+                }, status=400)
+
+            # Extract webhook data
+            store_id = data.get('store_id')
+            transaction_id = data.get('transaction_id')
+            amount = data.get('amount')
+            invoice = data.get('invoice')
+            transaction_time = data.get('transaction_time')
+
+            logger.info(f"Webhook received for transaction {transaction_id}, "
+                       f"invoice {invoice}, amount {amount}")
+
+            # Find transaction by invoice (account)
+            try:
+                transaction = PaymentTransaction._default_manager.get(
+                    gateway=PaymentTransaction.ATMOS,
+                    account_id=invoice
+                )
+
+                # Update transaction with webhook data
+                transaction.transaction_id = transaction_id
+                transaction.mark_as_paid()
+
+                # Call the event method
+                self.successfully_payment(data, transaction)
+
+                return JsonResponse({
+                    'status': 1,
+                    'message': 'Успешно'
+                })
+
+            except PaymentTransaction.DoesNotExist:
+                logger.error(f"Transaction not found for invoice: {invoice}")
+                return JsonResponse({
+                    'status': 0,
+                    'message': f'Transaction not found for invoice: {invoice}'
+                }, status=400)
+
+        except Exception as e:
+            logger.exception("Unexpected error in Atmos webhook: %s", e)
+            return JsonResponse({
+                'status': 0,
+                'message': f'Error: {str(e)}'
+            }, status=500)
+
+    def _verify_signature(self, webhook_data, received_signature):
+        """
+        Verify webhook signature from Atmos.
+        """
+        # Extract data from webhook
+        store_id = str(webhook_data.get('store_id', ''))
+        transaction_id = str(webhook_data.get('transaction_id', ''))
+        invoice = str(webhook_data.get('invoice', ''))
+        amount = str(webhook_data.get('amount', ''))
+
+        # Create signature string: store_id+transaction_id+invoice+amount+api_key
+        signature_string = f"{store_id}{transaction_id}{invoice}{amount}{self.api_key}"
+
+        # Generate MD5 hash
+        calculated_signature = hashlib.md5(
+            signature_string.encode('utf-8')).hexdigest()
+
+        # Compare signatures
+        return calculated_signature == received_signature
+
+    # Event methods that can be overridden by subclasses
+
+    def successfully_payment(self, params, transaction):
+        """
+        Called when a payment is successful.
+
+        Args:
+            params: Request parameters
+            transaction: Transaction object
+        """
+        # This method is meant to be overridden by subclasses

{paytechuz-0.2.24.dist-info → paytechuz-0.3.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: paytechuz
-Version: 0.2.24
-Summary: Unified Python package for Uzbekistan payment gateways
+Version: 0.3.0
+Summary: Unified Python package for Uzbekistan payment gateways (Payme, Click, Atmos)
 Home-page: https://github.com/Muhammadali-Akbarov/paytechuz
 Author: Muhammadali Akbarov
 Author-email: muhammadali17abc@gmail.com
@@ -20,7 +20,7 @@ Dynamic: requires-python
 [![Documentation](https://img.shields.io/badge/docs-pay--tech.uz-blue.svg)](https://pay-tech.uz)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-PayTechUZ is a unified payment library for integrating with popular payment systems in Uzbekistan. It provides a simple and consistent interface for working with Payme and Click payment gateways.
+PayTechUZ is a unified payment library for integrating with popular payment systems in Uzbekistan. It provides a simple and consistent interface for working with Payme, Click, and Atmos payment gateways.
 
 📖 **[Complete Documentation](https://pay-tech.uz)** | 🚀 **[Quick Start Guide](https://pay-tech.uz/quickstart)**
 
@@ -59,6 +59,7 @@ pip install paytechuz[fastapi]
 ```python
 from paytechuz.gateways.payme import PaymeGateway
 from paytechuz.gateways.click import ClickGateway
+from paytechuz.gateways.atmos import AtmosGateway
 
 # Initialize Payme gateway
 payme = PaymeGateway(
@@ -76,6 +77,15 @@ click = ClickGateway(
     is_test_mode=True  # Set to False in production environment
 )
 
+# Initialize Atmos gateway
+atmos = AtmosGateway(
+    consumer_key="your_consumer_key",
+    consumer_secret="your_consumer_secret",
+    store_id="your_store_id",
+    terminal_id="your_terminal_id",  # optional
+    is_test_mode=True  # Set to False in production environment
+)
+
 # Generate payment links
 payme_link = payme.create_payment(
     id="order_123",
@@ -89,6 +99,116 @@ click_link = click.create_payment(
     description="Test payment",
     return_url="https://example.com/return"
 )
+
+atmos_payment = atmos.create_payment(
+    account_id="order_123",
+    amount=150000  # amount in UZS
+)
+atmos_link = atmos_payment['payment_url']
+
+# Check payment status
+status = atmos.check_payment(atmos_payment['transaction_id'])
+print(f"Payment status: {status['status']}")
+
+# Cancel payment if needed
+if status['status'] == 'pending':
+    cancel_result = atmos.cancel_payment(
+        transaction_id=atmos_payment['transaction_id'],
+        reason="Customer request"
+    )
+    print(f"Cancellation status: {cancel_result['status']}")
+```
+
+### Complete Atmos Integration Example
+
+```python
+from paytechuz.gateways.atmos import AtmosGateway
+from paytechuz.gateways.atmos.webhook import AtmosWebhookHandler
+
+# 1. Initialize Atmos Gateway
+atmos = AtmosGateway(
+    consumer_key="your_consumer_key",
+    consumer_secret="your_consumer_secret",
+    store_id="your_store_id",
+    terminal_id="your_terminal_id",  # optional
+    is_test_mode=True
+)
+
+# 2. Create payment
+def create_atmos_payment(order_id, amount):
+    try:
+        payment = atmos.create_payment(
+            account_id=order_id,
+            amount=amount
+        )
+
+        print(f"✅ Payment created successfully!")
+        print(f"Transaction ID: {payment['transaction_id']}")
+        print(f"Payment URL: {payment['payment_url']}")
+        print(f"Redirect user to: {payment['payment_url']}")
+
+        return payment
+
+    except Exception as e:
+        print(f"❌ Payment creation failed: {e}")
+        return None
+
+# 3. Check payment status
+def check_atmos_payment(transaction_id):
+    try:
+        status = atmos.check_payment(transaction_id)
+
+        print(f"Transaction ID: {status['transaction_id']}")
+        print(f"Status: {status['status']}")
+
+        return status
+
+    except Exception as e:
+        print(f"❌ Status check failed: {e}")
+        return None
+
+# 4. Handle webhook (for web frameworks)
+def handle_atmos_webhook(webhook_data):
+    webhook_handler = AtmosWebhookHandler(api_key="your_atmos_api_key")
+
+    try:
+        response = webhook_handler.handle_webhook(webhook_data)
+
+        if response['status'] == 1:
+            # Payment successful
+            transaction_id = webhook_data.get('transaction_id')
+            amount = webhook_data.get('amount')
+            invoice = webhook_data.get('invoice')
+
+            print(f"✅ Payment successful!")
+            print(f"Transaction ID: {transaction_id}")
+            print(f"Order ID: {invoice}")
+            print(f"Amount: {amount}")
+
+            # Update your order status here
+            # update_order_status(invoice, 'paid')
+
+        return response
+
+    except Exception as e:
+        print(f"❌ Webhook processing failed: {e}")
+        return {
+            'status': 0,
+            'message': f'Error: {str(e)}'
+        }
+
+# Usage example
+if __name__ == "__main__":
+    # Create payment
+    payment = create_atmos_payment("order_12345", 50000)  # 500.00 UZS
+
+    if payment:
+        # Check status after some time
+        import time
+        time.sleep(5)  # Wait 5 seconds
+
+        status = check_atmos_payment(payment['transaction_id'])
+        print(f"Current status: {status['status'] if status else 'Unknown'}")
 ```
 
 ### Django Integration
@@ -144,6 +264,16 @@ PAYTECHUZ = {
         'ACCOUNT_MODEL': 'your_app.models.Order',
         'COMMISSION_PERCENT': 0.0,
         'IS_TEST_MODE': True,  # Set to False in production
+    },
+    'ATMOS': {
+        'CONSUMER_KEY': 'your_atmos_consumer_key',
+        'CONSUMER_SECRET': 'your_atmos_consumer_secret',
+        'STORE_ID': 'your_atmos_store_id',
+        'TERMINAL_ID': 'your_atmos_terminal_id',  # Optional
+        'API_KEY': 'your_atmos_api_key'
+        'ACCOUNT_MODEL': 'your_app.models.Order',
+        'ACCOUNT_FIELD': 'id',
+        'IS_TEST_MODE': True,  # Set to False in production
     }
 }
 ```
@@ -152,7 +282,11 @@ PAYTECHUZ = {
 
 ```python
 # views.py
-from paytechuz.integrations.django.views import BasePaymeWebhookView, BaseClickWebhookView
+from paytechuz.integrations.django.views import (
+    BasePaymeWebhookView,
+    BaseClickWebhookView,
+    BaseAtmosWebhookView
+)
 from .models import Order
 
 class PaymeWebhookView(BasePaymeWebhookView):
@@ -176,6 +310,17 @@ class ClickWebhookView(BaseClickWebhookView):
         order = Order.objects.get(id=transaction.account_id)
         order.status = 'cancelled'
         order.save()
+
+class AtmosWebhookView(BaseAtmosWebhookView):
+    def successfully_payment(self, params, transaction):
+        order = Order.objects.get(id=transaction.account_id)
+        order.status = 'paid'
+        order.save()
+
+    def cancelled_payment(self, params, transaction):
+        order = Order.objects.get(id=transaction.account_id)
+        order.status = 'cancelled'
+        order.save()
 ```
 
 4. Add webhook URLs to `urls.py`:
@@ -184,12 +329,13 @@ class ClickWebhookView(BaseClickWebhookView):
 # urls.py
 from django.urls import path
 from django.views.decorators.csrf import csrf_exempt
-from .views import PaymeWebhookView, ClickWebhookView
+from .views import PaymeWebhookView, ClickWebhookView, AtmosWebhookView
 
 urlpatterns = [
     # ...
     path('payments/webhook/payme/', csrf_exempt(PaymeWebhookView.as_view()), name='payme_webhook'),
     path('payments/webhook/click/', csrf_exempt(ClickWebhookView.as_view()), name='click_webhook'),
+    path('payments/webhook/atmos/', csrf_exempt(AtmosWebhookView.as_view()), name='atmos_webhook'),
 ]
 ```
 
@@ -243,6 +389,7 @@ from fastapi import FastAPI, Request, Depends
 from sqlalchemy.orm import Session
 
 from paytechuz.integrations.fastapi import PaymeWebhookHandler, ClickWebhookHandler
+from paytechuz.gateways.atmos.webhook import AtmosWebhookHandler
 
 
 app = FastAPI()
@@ -302,6 +449,39 @@ async def click_webhook(request: Request, db: Session = Depends(get_db)):
         account_model=Order
     )
     return await handler.handle_webhook(request)
+
+@app.post("/payments/atmos/webhook")
+async def atmos_webhook(request: Request, db: Session = Depends(get_db)):
+    import json
+
+    # Atmos webhook handler
+    atmos_handler = AtmosWebhookHandler(api_key="your_atmos_api_key")
+
+    try:
+        # Get request body
+        body = await request.body()
+        webhook_data = json.loads(body.decode('utf-8'))
+
+        # Process webhook
+        response = atmos_handler.handle_webhook(webhook_data)
+
+        if response['status'] == 1:
+            # Payment successful
+            invoice = webhook_data.get('invoice')
+
+            # Update order status
+            order = db.query(Order).filter(Order.id == invoice).first()
+            if order:
+                order.status = "paid"
+                db.commit()
+
+        return response
+
+    except Exception as e:
+        return {
+            'status': 0,
+            'message': f'Error: {str(e)}'
+        }
 ```
 
 ## Documentation
@@ -315,11 +495,13 @@ Detailed documentation is available in multiple languages:
 
 - [Django Integration Guide](src/docs/en/django_integration.md) | [Django integratsiyasi bo'yicha qo'llanma](src/docs/django_integration.md)
 - [FastAPI Integration Guide](src/docs/en/fastapi_integration.md) | [FastAPI integratsiyasi bo'yicha qo'llanma](src/docs/fastapi_integration.md)
+- [Atmos Integration Guide](src/docs/en/atmos_integration.md) | [Atmos integratsiyasi bo'yicha qo'llanma](src/docs/atmos_integration.md)
 
 ## Supported Payment Systems
 
 - **Payme** - [Official Website](https://payme.uz)
 - **Click** - [Official Website](https://click.uz)
+- **Atmos** - [Official Website](https://atmos.uz)
 
 ## Contributing
 

{paytechuz-0.2.24.dist-info → paytechuz-0.3.0.dist-info}/RECORD

@@ -1,12 +1,15 @@
-paytechuz/__init__.py,sha256=ODKIHhEIrUJ9I-8OQ22jNkG0W8PCHxWi3DBFXFQLqYk,1754
+paytechuz/__init__.py,sha256=Pfndm1UE44F1lgRs9wFP3OH0760ziw3EBJbN-wkRuXg,1939
 paytechuz/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 paytechuz/core/base.py,sha256=Es6eEGNgDjQJe-kEJVAHSAh8AWbgtIuQMm0xn7qfjl4,2549
-paytechuz/core/constants.py,sha256=P2zeZ_cfZIttdC1vqkpIngkfRFh6loWzJYEgzQb5cKA,1660
+paytechuz/core/constants.py,sha256=hzCy5Kc8HVSDhXxNgObbJ2e9SYcXTYL3qky_q0tlpHU,2305
 paytechuz/core/exceptions.py,sha256=XMJkqiponTkvhjoh3S2iFNuU3UbBdFW4130kd0hpudg,5489
 paytechuz/core/http.py,sha256=1PFv_Fo62GtfyYKUK2nsT4AaeQNuMgZlFUFL1q9p2MI,7672
 paytechuz/core/utils.py,sha256=EbNtDweR1ABOtCu4D6cYlolM0t_fbiE3gNoc_qfcKKA,4704
 paytechuz/core/payme/errors.py,sha256=CZE62MbYDMsRfNIX23Syt6of_tPMMGLnXhYMii4hw3A,542
 paytechuz/gateways/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+paytechuz/gateways/atmos/__init__.py,sha256=piVcHu32K-D8I0Kr6bSXXrdtny2S5TY0hxMbyCuVuIo,91
+paytechuz/gateways/atmos/client.py,sha256=Llo4utBVYPq1a3eLQaCtOMIzXooRhati3Eh2o6qbVdE,6212
+paytechuz/gateways/atmos/webhook.py,sha256=bqMHipJ_GowGYuxVaZd2f8bSEzSNHavdsvpGpsqy96s,2989
 paytechuz/gateways/click/__init__.py,sha256=35RPIrZYHgMWDzxjQkJMZYjzHDa8cY_BqQztCdZZmBM,90
 paytechuz/gateways/click/client.py,sha256=NwsPGfXacO0tWvZCA0V9KZ9XhFV7AnyHBmtxsWAvci8,6736
 paytechuz/gateways/click/merchant.py,sha256=tvHUwNr_eiDz_ED4-m2GNBh_LXN0b5lwtq1jw1e0zAQ,7191
@@ -20,17 +23,18 @@ paytechuz/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 paytechuz/integrations/django/__init__.py,sha256=fNs4c2IWpCe78-_Yvgz59TdKbHiYRYDkLR33QOBf-Ok,356
 paytechuz/integrations/django/admin.py,sha256=6fs6GiKcdc-hGlLxJ0BthY7TFo_2RVVJRhQwhxMroCY,2664
 paytechuz/integrations/django/apps.py,sha256=Q9wG2osL7_Ip2BcAkq7lmmhu4UKJAg6UtSsSq_RgHlc,640
-paytechuz/integrations/django/models.py,sha256=x3cVLY812Xts5oNk4VmCzK3zjb0FXQON9WV41PCtxaw,5696
+paytechuz/integrations/django/models.py,sha256=EInAti6LZlf7t1kiTSceV-xQZ-hNcVe8qzem2yjOWh4,5742
 paytechuz/integrations/django/signals.py,sha256=VtNYEAnu13wi9PqadEaCU9LY_k2tY26AS4bnPIAqw7M,1319
-paytechuz/integrations/django/views.py,sha256=TL-LNbwrLvYjoBvGxm_yZjMVLBqelorgKjr4l3sKH1Y,3037
-paytechuz/integrations/django/webhooks.py,sha256=gATM5oxoNKznnCHHYanjwhgdpeoRGIhDGRxVO3SIYYU,32048
+paytechuz/integrations/django/views.py,sha256=KFiuMcr4BtMbzbrW_RbIkv0-Fk214WIWWwaStscArzs,4149
+paytechuz/integrations/django/webhooks.py,sha256=j5f4BbOQaFniK26RTQW7KlM90KFOioCUwjBjJQCdkek,36646
 paytechuz/integrations/django/migrations/0001_initial.py,sha256=SWHIUuwq91crzaxa9v1UK0kay8CxsjUo6t4bqg7j0Gw,1896
+paytechuz/integrations/django/migrations/0002_alter_paymenttransaction_gateway.py,sha256=XiZx5urgfhXxra3W_KWksQ1LbaDOs3sjPn4w0T2cW50,457
 paytechuz/integrations/django/migrations/__init__.py,sha256=KLQ5NdjOMLDS21-u3b_g08G1MjPMMhG95XI_N8m4FSo,41
 paytechuz/integrations/fastapi/__init__.py,sha256=DLnhAZQZf2ghu8BuFFfE7FzbNKWQQ2SLG8qxldRuwR4,565
 paytechuz/integrations/fastapi/models.py,sha256=9IqrsndIVuIDwDbijZ89biJxEWQASXRBfWVShxgerAc,5113
 paytechuz/integrations/fastapi/routes.py,sha256=t8zbqhMZsaJmEvMDgmF-NoRmbqksfX_AvIrx-3kCjg8,37845
 paytechuz/integrations/fastapi/schemas.py,sha256=PgRqviJiD4-u3_CIkUOX8R7L8Yqn8L44WLte7968G0E,3887
-paytechuz-0.2.24.dist-info/METADATA,sha256=wWTY1mR8E2eE9ChZjydxSYQoITVmPwWpjqV0sCiMH_8,10084
-paytechuz-0.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-paytechuz-0.2.24.dist-info/top_level.txt,sha256=oloyKGNVj9Z2h3wpKG5yPyTlpdpWW0-CWr-j-asCWBc,10
-paytechuz-0.2.24.dist-info/RECORD,,
+paytechuz-0.3.0.dist-info/METADATA,sha256=UsVUiMRztSPWOfzb6N3GthBY7ZdMhBBbdsSSAwp_4QQ,15730
+paytechuz-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+paytechuz-0.3.0.dist-info/top_level.txt,sha256=oloyKGNVj9Z2h3wpKG5yPyTlpdpWW0-CWr-j-asCWBc,10
+paytechuz-0.3.0.dist-info/RECORD,,