django-cfg 1.2.22__py3-none-any.whl → 1.2.25__py3-none-any.whl

django_cfg/apps/payments/decorators.py

@@ -0,0 +1,291 @@
+"""
+Decorators for API access control and endpoint registration.
+"""
+
+import functools
+import logging
+from typing import Optional, List, Callable, Any
+from django.http import JsonResponse
+from django.conf import settings
+from django.utils import timezone
+from .models import EndpointGroup, Subscription
+
+logger = logging.getLogger(__name__)
+
+
+def require_api_key(func: Callable) -> Callable:
+    """
+    Decorator to require valid API key for function-based views.
+    Works with APIAccessMiddleware.
+    """
+    @functools.wraps(func)
+    def wrapper(request, *args, **kwargs):
+        if not hasattr(request, 'payment_api_key'):
+            return JsonResponse({
+                'error': {
+                    'code': 'MISSING_API_KEY',
+                    'message': 'Valid API key required',
+                    'timestamp': timezone.now().isoformat(),
+                }
+            }, status=401)
+        
+        return func(request, *args, **kwargs)
+    
+    return wrapper
+
+
+def require_subscription(endpoint_group_name: str):
+    """
+    Decorator to require active subscription for specific endpoint group.
+    
+    Args:
+        endpoint_group_name: Name of the endpoint group to check
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(request, *args, **kwargs):
+            # Check if middleware already validated subscription
+            if hasattr(request, 'payment_subscription'):
+                subscription = request.payment_subscription
+                if subscription.endpoint_group.name == endpoint_group_name:
+                    return func(request, *args, **kwargs)
+            
+            # If not validated by middleware, check manually
+            if not hasattr(request, 'payment_api_key'):
+                return JsonResponse({
+                    'error': {
+                        'code': 'MISSING_API_KEY',
+                        'message': 'Valid API key required',
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=401)
+            
+            try:
+                endpoint_group = EndpointGroup.objects.get(
+                    name=endpoint_group_name,
+                    is_active=True
+                )
+                
+                subscription = Subscription.objects.filter(
+                    user=request.payment_api_key.user,
+                    endpoint_group=endpoint_group,
+                    status='active',
+                    expires_at__gt=timezone.now()
+                ).first()
+                
+                if not subscription:
+                    return JsonResponse({
+                        'error': {
+                            'code': 'NO_SUBSCRIPTION',
+                            'message': f'Active subscription required for {endpoint_group.display_name}',
+                            'timestamp': timezone.now().isoformat(),
+                        }
+                    }, status=403)
+                
+                # Store subscription in request
+                request.payment_subscription = subscription
+                
+                return func(request, *args, **kwargs)
+                
+            except EndpointGroup.DoesNotExist:
+                logger.error(f"Endpoint group '{endpoint_group_name}' not found")
+                return JsonResponse({
+                    'error': {
+                        'code': 'INVALID_ENDPOINT_GROUP',
+                        'message': 'Invalid endpoint group',
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=500)
+        
+        return wrapper
+    return decorator
+
+
+def require_tier(minimum_tier: str):
+    """
+    Decorator to require minimum subscription tier.
+    
+    Args:
+        minimum_tier: Minimum required tier (basic, premium, enterprise)
+    """
+    tier_hierarchy = {
+        'basic': 1,
+        'premium': 2,
+        'enterprise': 3,
+    }
+    
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(request, *args, **kwargs):
+            if not hasattr(request, 'payment_subscription'):
+                return JsonResponse({
+                    'error': {
+                        'code': 'NO_SUBSCRIPTION',
+                        'message': 'Active subscription required',
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=403)
+            
+            subscription = request.payment_subscription
+            current_tier_level = tier_hierarchy.get(subscription.tier, 0)
+            required_tier_level = tier_hierarchy.get(minimum_tier, 999)
+            
+            if current_tier_level < required_tier_level:
+                return JsonResponse({
+                    'error': {
+                        'code': 'INSUFFICIENT_TIER',
+                        'message': f'Tier {minimum_tier} or higher required',
+                        'current_tier': subscription.tier,
+                        'required_tier': minimum_tier,
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=403)
+            
+            return func(request, *args, **kwargs)
+        
+        return wrapper
+    return decorator
+
+
+def track_usage(cost_per_request: float = 0.0):
+    """
+    Decorator to track API usage and deduct costs.
+    
+    Args:
+        cost_per_request: Cost to deduct per successful request
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(request, *args, **kwargs):
+            # Execute the function
+            response = func(request, *args, **kwargs)
+            
+            # Track usage if successful and we have subscription
+            if (hasattr(request, 'payment_subscription') and 
+                hasattr(response, 'status_code') and
+                200 <= response.status_code < 300 and
+                cost_per_request > 0):
+                
+                try:
+                    from .models import Transaction
+                    
+                    subscription = request.payment_subscription
+                    
+                    # Create billing transaction
+                    Transaction.objects.create(
+                        user=subscription.user,
+                        subscription=subscription,
+                        transaction_type='debit',
+                        amount_usd=-cost_per_request,
+                        description=f"API usage: {request.method} {request.path}",
+                        metadata={
+                            'endpoint': request.path,
+                            'method': request.method,
+                            'cost_per_request': cost_per_request,
+                        }
+                    )
+                    
+                except Exception as e:
+                    logger.error(f"Error tracking usage: {e}")
+            
+            return response
+        
+        return wrapper
+    return decorator
+
+
+def register_endpoint(endpoint_group_name: str, 
+                     display_name: Optional[str] = None,
+                     description: Optional[str] = None,
+                     require_api_key: bool = True):
+    """
+    Decorator to automatically register endpoint with the system.
+    This creates or updates EndpointGroup records.
+    
+    Args:
+        endpoint_group_name: Internal name for the endpoint group
+        display_name: Human-readable name
+        description: Description of the endpoint functionality
+        require_api_key: Whether this endpoint requires API key
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Auto-register endpoint group if it doesn't exist
+            try:
+                endpoint_group, created = EndpointGroup.objects.get_or_create(
+                    name=endpoint_group_name,
+                    defaults={
+                        'display_name': display_name or endpoint_group_name.replace('_', ' ').title(),
+                        'description': description or f'Auto-registered endpoint group: {endpoint_group_name}',
+                        'require_api_key': require_api_key,
+                        'is_active': True,
+                    }
+                )
+                
+                if created:
+                    logger.info(f"Auto-registered endpoint group: {endpoint_group_name}")
+                
+            except Exception as e:
+                logger.error(f"Error auto-registering endpoint group: {e}")
+            
+            return func(*args, **kwargs)
+        
+        return wrapper
+    return decorator
+
+
+def check_usage_limit(func: Callable) -> Callable:
+    """
+    Decorator to check subscription usage limits before processing request.
+    """
+    @functools.wraps(func)
+    def wrapper(request, *args, **kwargs):
+        if hasattr(request, 'payment_subscription'):
+            subscription = request.payment_subscription
+            
+            # Check if usage limit exceeded
+            if (subscription.usage_limit > 0 and 
+                subscription.usage_current >= subscription.usage_limit):
+                
+                return JsonResponse({
+                    'error': {
+                        'code': 'USAGE_EXCEEDED',
+                        'message': 'Monthly usage limit exceeded',
+                        'current_usage': subscription.usage_current,
+                        'usage_limit': subscription.usage_limit,
+                        'reset_date': subscription.next_billing.isoformat() if subscription.next_billing else None,
+                        'timestamp': timezone.now().isoformat(),
+                    }
+                }, status=429)
+        
+        return func(request, *args, **kwargs)
+    
+    return wrapper
+
+
+# Utility decorator combinations
+def api_endpoint(endpoint_group_name: str, 
+                minimum_tier: str = 'basic',
+                cost_per_request: float = 0.0):
+    """
+    Combination decorator for typical API endpoint protection.
+    
+    Args:
+        endpoint_group_name: Name of the endpoint group
+        minimum_tier: Minimum subscription tier required
+        cost_per_request: Cost to charge per successful request
+    """
+    def decorator(func: Callable) -> Callable:
+        # Apply decorators in reverse order (they wrap from inside out)
+        decorated_func = func
+        decorated_func = track_usage(cost_per_request)(decorated_func)
+        decorated_func = check_usage_limit(decorated_func)
+        decorated_func = require_tier(minimum_tier)(decorated_func)
+        decorated_func = require_subscription(endpoint_group_name)(decorated_func)
+        decorated_func = require_api_key(decorated_func)
+        decorated_func = register_endpoint(endpoint_group_name)(decorated_func)
+        
+        return decorated_func
+    
+    return decorator

django_cfg/apps/payments/management/__init__.py

@@ -0,0 +1,3 @@
+"""
+Management commands for the payments app.
+"""

django_cfg/apps/payments/management/commands/README.md

@@ -0,0 +1,178 @@
+# Currency Management Commands
+
+Management команды для работы с валютами в Universal Payments System.
+
+## Команды
+
+### 🪙 `populate_currencies` - Первоначальное заполнение
+
+Заполняет пустую базу данных валютами из внешних API (CoinGecko, YFinance).
+
+```bash
+# Быстрое заполнение (50 криптовалют + 20 фиатных)
+python manage.py populate_currencies --quick
+
+# Стандартное заполнение (200 криптовалют + 30 фиатных)
+python manage.py populate_currencies
+
+# Только криптовалюты
+python manage.py populate_currencies --crypto-only
+
+# Только фиатные валюты
+python manage.py populate_currencies --fiat-only
+
+# Пропустить существующие валюты
+python manage.py populate_currencies --skip-existing
+```
+
+### 🔄 `update_currencies` - Обновление курсов
+
+Обновляет курсы валют с внешних API.
+
+```bash
+# Обновить устаревшие курсы (старше 6 часов)
+python manage.py update_currencies
+
+# Принудительно обновить все валюты
+python manage.py update_currencies --force-update
+
+# Сухой прогон (показать что будет обновлено)
+python manage.py update_currencies --dry-run
+
+# Кастомные лимиты
+python manage.py update_currencies --max-crypto 100 --max-fiat 30
+
+# Исключить стейблкоины
+python manage.py update_currencies --exclude-stablecoins
+
+# Подробный вывод
+python manage.py update_currencies --verbose
+```
+
+### 📊 `currency_stats` - Статистика валют
+
+Показывает статистику базы данных валют.
+
+```bash
+# Базовая статистика
+python manage.py currency_stats
+
+# Детальная статистика
+python manage.py currency_stats --detailed
+
+# Показать топ-10 валют
+python manage.py currency_stats --top 10
+
+# Проверить устаревшие курсы
+python manage.py currency_stats --check-rates
+
+# Экспортировать в CSV
+python manage.py currency_stats --export-csv currencies.csv
+```
+
+## Автоматизация
+
+### Cron для регулярного обновления
+
+```bash
+# Обновлять курсы каждые 6 часов
+0 */6 * * * cd /path/to/project && poetry run python manage.py update_currencies
+
+# Ежедневная проверка статистики
+0 9 * * * cd /path/to/project && poetry run python manage.py currency_stats --check-rates
+```
+
+### Docker
+
+```bash
+# В Docker контейнере
+docker exec -it container_name poetry run python manage.py populate_currencies --quick
+docker exec -it container_name poetry run python manage.py update_currencies
+```
+
+## Примеры использования
+
+### Первоначальная настройка
+
+```bash
+# 1. Заполнить базу данных валютами
+python manage.py populate_currencies --quick
+
+# 2. Проверить результат
+python manage.py currency_stats
+```
+
+### Регулярное обслуживание
+
+```bash
+# 1. Обновить курсы
+python manage.py update_currencies --verbose
+
+# 2. Проверить устаревшие курсы
+python manage.py currency_stats --check-rates
+
+# 3. При необходимости - принудительное обновление
+python manage.py update_currencies --force-update
+```
+
+### Production обслуживание
+
+```bash
+# Обновление с минимальными API запросами
+python manage.py update_currencies --max-crypto 50 --max-fiat 20
+
+# Мониторинг состояния
+python manage.py currency_stats --detailed --export-csv daily_report.csv
+```
+
+## Интеграция с django_currency
+
+Команды используют модуль `django_currency.database.database_loader` для:
+
+- ✅ Получения списка валют с CoinGecko
+- ✅ Загрузки курсов фиатных валют с YFinance  
+- ✅ Rate limiting для защиты от API throttling
+- ✅ Кэширования для оптимизации производительности
+- ✅ Pydantic валидации для типобезопасности
+
+## Конфигурация
+
+Настройки в `DatabaseLoaderConfig`:
+
+```python
+config = DatabaseLoaderConfig(
+    max_cryptocurrencies=500,        # Максимум криптовалют
+    max_fiat_currencies=50,          # Максимум фиатных валют  
+    min_market_cap_usd=1_000_000,    # Минимальная капитализация
+    coingecko_delay=1.5,             # Задержка между запросами
+    yfinance_delay=0.5,              # Задержка для YFinance
+    exclude_stablecoins=False,       # Исключить стейблкоины
+    cache_ttl_hours=24               # TTL кэша в часах
+)
+```
+
+## Мониторинг
+
+### Логи
+
+Команды логируют в `django_cfg.apps.payments.management.commands`:
+
+```python
+import logging
+logger = logging.getLogger('django_cfg.apps.payments.management.commands')
+```
+
+### Метрики
+
+- Количество созданных/обновленных валют
+- Время выполнения API запросов
+- Ошибки валидации и API
+- Статистика курсов валют
+
+## Безопасность
+
+- ✅ Rate limiting для API запросов
+- ✅ Atomic транзакции для консистентности
+- ✅ Graceful handling ошибок API
+- ✅ Валидация данных с Pydantic
+- ✅ Rollback при критических ошибках

django_cfg/apps/payments/management/commands/__init__.py

@@ -0,0 +1,3 @@
+"""
+Management commands directory.
+"""