django-cfg 1.4.82__py3-none-any.whl → 1.4.83__py3-none-any.whl

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.82"
+__version__ = "1.4.83"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/centrifugo/serializers/channels.py

@@ -2,6 +2,8 @@
 Channel statistics serializers for Centrifugo monitoring API.
 """
 
+from typing import Optional
+
 from pydantic import BaseModel, Field
 
 
@@ -14,6 +16,7 @@ class ChannelStatsSerializer(BaseModel):
     failed: int = Field(description="Failed publishes")
     avg_duration_ms: float = Field(description="Average duration")
     avg_acks: float = Field(description="Average ACKs received")
+    last_activity_at: Optional[str] = Field(default=None, description="Last activity timestamp (ISO format)")
 
 
 class ChannelListSerializer(BaseModel):

django_cfg/apps/centrifugo/serializers/publishes.py

@@ -11,6 +11,8 @@ class RecentPublishesSerializer(BaseModel):
     publishes: list[dict] = Field(description="List of recent publishes")
     count: int = Field(description="Number of publishes returned")
     total_available: int = Field(description="Total publishes available")
+    offset: int = Field(default=0, description="Current offset for pagination")
+    has_more: bool = Field(default=False, description="Whether more results are available")
 
 
 __all__ = ["RecentPublishesSerializer"]

django_cfg/apps/centrifugo/views/admin_api.py

@@ -41,7 +41,7 @@ class CentrifugoAdminAPIViewSet(viewsets.ViewSet):
     All requests are authenticated via Django session and proxied to Centrifugo.
     """
 
-    authentication_classes = [SessionAuthentication]
+    # authentication_classes = [SessionAuthentication]
     permission_classes = [IsAdminUser]
 
     def __init__(self, *args, **kwargs):

django_cfg/apps/centrifugo/views/monitoring.py

@@ -4,10 +4,11 @@ Centrifugo Monitoring ViewSet.
 Provides REST API endpoints for monitoring Centrifugo publish statistics.
 """
 
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from django.db import models
-from django.db.models import Avg, Count
+from django.db.models import Avg, Count, Max
+from django.db.models.functions import TruncHour, TruncDay
 from django_cfg.modules.django_logging import get_logger
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, extend_schema
@@ -41,7 +42,7 @@ class CentrifugoMonitorViewSet(viewsets.ViewSet):
     - Channel-level statistics
     """
 
-    authentication_classes = [SessionAuthentication]
+    # authentication_classes = [SessionAuthentication]
     permission_classes = [IsAdminUser]
 
     @extend_schema(
@@ -144,6 +145,20 @@ class CentrifugoMonitorViewSet(viewsets.ViewSet):
                 description="Filter by channel name",
                 required=False,
             ),
+            OpenApiParameter(
+                name="status",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by status (success, failed, timeout, pending, partial)",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="offset",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Offset for pagination (default: 0)",
+                required=False,
+            ),
         ],
         responses={
             200: RecentPublishesSerializer,
@@ -158,14 +173,24 @@ class CentrifugoMonitorViewSet(viewsets.ViewSet):
             count = min(count, 200)  # Max 200
 
             channel = request.GET.get("channel")
+            status_filter = request.GET.get("status")  # NEW: status filter
+            offset = int(request.GET.get("offset", 0))  # NEW: offset for pagination
 
             queryset = CentrifugoLog.objects.all()
 
             if channel:
                 queryset = queryset.filter(channel=channel)
 
+            # NEW: Filter by status
+            if status_filter and status_filter in ["success", "failed", "timeout", "pending", "partial"]:
+                queryset = queryset.filter(status=status_filter)
+
+            # Get total count before slicing
+            total = queryset.count()
+
+            # NEW: Apply offset and limit
             publishes_list = list(
-                queryset.order_by("-created_at")[:count].values(
+                queryset.order_by("-created_at")[offset:offset + count].values(
                     "message_id",
                     "channel",
                     "status",
@@ -187,12 +212,12 @@ class CentrifugoMonitorViewSet(viewsets.ViewSet):
                 if pub["completed_at"]:
                     pub["completed_at"] = pub["completed_at"].isoformat()
 
-            total = queryset.count()
-
             response_data = {
                 "publishes": publishes_list,
                 "count": len(publishes_list),
                 "total_available": total,
+                "offset": offset,  # NEW: for pagination
+                "has_more": (offset + count) < total,  # NEW: pagination helper
             }
 
             serializer = RecentPublishesSerializer(**response_data)
@@ -228,6 +253,89 @@ class CentrifugoMonitorViewSet(viewsets.ViewSet):
             400: {"description": "Invalid parameters"},
         },
     )
+    @extend_schema(
+        tags=["Centrifugo Monitoring"],
+        summary="Get publish timeline",
+        description="Returns hourly or daily breakdown of publish counts for charts.",
+        parameters=[
+            OpenApiParameter(
+                name="hours",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Time period in hours (default: 24)",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="interval",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Time interval: 'hour' or 'day' (default: hour)",
+                required=False,
+            ),
+        ],
+        responses={
+            200: {"description": "Timeline data"},
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="timeline")
+    def timeline(self, request):
+        """Get publish timeline breakdown for charts."""
+        try:
+            hours = int(request.GET.get("hours", 24))
+            hours = min(max(hours, 1), 168)
+            interval = request.GET.get("interval", "hour")
+
+            if interval not in ["hour", "day"]:
+                interval = "hour"
+
+            # Determine truncation function
+            trunc_func = TruncHour if interval == "hour" else TruncDay
+
+            # Get timeline data
+            timeline_data = (
+                CentrifugoLog.objects.recent(hours)
+                .annotate(period=trunc_func("created_at"))
+                .values("period")
+                .annotate(
+                    count=Count("id"),
+                    successful=Count("id", filter=models.Q(status="success")),
+                    failed=Count("id", filter=models.Q(status="failed")),
+                    timeout=Count("id", filter=models.Q(status="timeout")),
+                )
+                .order_by("period")
+            )
+
+            timeline_list = []
+            for item in timeline_data:
+                timeline_list.append({
+                    "timestamp": item["period"].isoformat(),
+                    "count": item["count"],
+                    "successful": item["successful"],
+                    "failed": item["failed"],
+                    "timeout": item["timeout"],
+                })
+
+            response_data = {
+                "timeline": timeline_list,
+                "period_hours": hours,
+                "interval": interval,
+            }
+
+            return Response(response_data)
+
+        except ValueError as e:
+            logger.warning(f"Timeline validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"Timeline error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
     @action(detail=False, methods=["get"], url_path="channels")
     def channels(self, request):
         """Get statistics per channel."""
@@ -245,6 +353,7 @@ class CentrifugoMonitorViewSet(viewsets.ViewSet):
                     failed=Count("id", filter=models.Q(status="failed")),
                     avg_duration_ms=Avg("duration_ms"),
                     avg_acks=Avg("acks_received"),
+                    last_activity_at=Max("created_at"),  # NEW: last activity timestamp
                 )
                 .order_by("-total")
             )
@@ -259,6 +368,7 @@ class CentrifugoMonitorViewSet(viewsets.ViewSet):
                         failed=stats["failed"],
                         avg_duration_ms=round(stats["avg_duration_ms"] or 0, 2),
                         avg_acks=round(stats["avg_acks"] or 0, 2),
+                        last_activity_at=stats["last_activity_at"].isoformat() if stats["last_activity_at"] else None,  # NEW
                     )
                 )
 

django_cfg/apps/centrifugo/views/testing_api.py

@@ -103,7 +103,7 @@ class CentrifugoTestingAPIViewSet(viewsets.ViewSet):
     publishing, and manual ACK management.
     """
 
-    authentication_classes = [SessionAuthentication]
+    # authentication_classes = [SessionAuthentication]
     permission_classes = [IsAdminUser]
 
     def __init__(self, *args, **kwargs):

django_cfg/apps/frontend/JWT_AUTO_INJECTION.md

@@ -0,0 +1,224 @@
+# JWT Auto-Injection для Next.js приложений
+
+## Обзор
+
+Django-CFG автоматически инжектирует JWT токены (`auth_token` и `refresh_token`) в `localStorage` для авторизованных пользователей при загрузке Next.js приложений через **NextJSStaticView**.
+
+## Как это работает
+
+### Автоматическая инжекция в Next.js apps (рекомендуется)
+
+**NextJSStaticView** автоматически инжектирует JWT токены во все HTML ответы для авторизованных пользователей.
+
+```python
+# urls.py
+from django_cfg.apps.frontend.views import AdminView
+
+urlpatterns = [
+    path('admin/', include('django_cfg.apps.frontend.urls')),  # JWT injection automatic
+]
+```
+
+При загрузке **любой страницы Next.js приложения**, если пользователь авторизован:
+1. View обслуживает статический файл Next.js
+2. Генерируются JWT токены (access + refresh)
+3. Токены автоматически инжектируются в `<head>` или `<body>` через `<script>` тег
+4. Токены сохраняются в `localStorage`
+
+**Преимущества:**
+- Работает только для Next.js приложений (безопасный scope)
+- Не нужно модифицировать templates
+- Централизованная логика в базовом view
+- Не влияет на другие HTML responses (Django admin, etc.)
+
+### Template Tags (для кастомных шаблонов)
+
+Если вы используете собственные Django шаблоны, можете использовать готовые template tags:
+
+#### 1. Полная автоматическая инжекция
+
+```django
+{% load django_cfg %}
+
+<!DOCTYPE html>
+<html>
+<head>
+    <title>My App</title>
+    {% inject_jwt_tokens_script %}  {# Автоматически инжектит оба токена #}
+</head>
+<body>
+    <!-- Your content -->
+</body>
+</html>
+```
+
+#### 2. Отдельные токены
+
+```django
+{% load django_cfg %}
+
+<script>
+    // Access token
+    const accessToken = '{% user_jwt_token %}';
+
+    // Refresh token
+    const refreshToken = '{% user_jwt_refresh_token %}';
+
+    // Manual storage
+    localStorage.setItem('auth_token', accessToken);
+    localStorage.setItem('refresh_token', refreshToken);
+</script>
+```
+
+## Использование в Next.js
+
+После инжекции токены доступны в вашем Next.js приложении:
+
+```typescript
+// В любом Next.js компоненте или API клиенте
+const accessToken = localStorage.getItem('auth_token');
+const refreshToken = localStorage.getItem('refresh_token');
+
+// Использование с API клиентом
+import { API } from './generated/cfg';
+
+const api = new API('http://localhost:8000', {
+  storage: {
+    getItem: (key) => localStorage.getItem(key),
+    setItem: (key, value) => localStorage.setItem(key, value),
+    removeItem: (key) => localStorage.removeItem(key),
+  }
+});
+```
+
+## Безопасность
+
+### Что инжектируется
+- `auth_token` - JWT access token (короткий срок жизни)
+- `refresh_token` - JWT refresh token (длинный срок жизни)
+
+### Когда инжектируется
+Токены генерируются **только** если:
+1. Пользователь **авторизован** через Django session
+2. Загружается **HTML файл** (не JS, CSS и т.д.)
+3. `rest_framework_simplejwt` установлен
+
+### Безопасность токенов
+- Токены генерируются **на лету** при каждом запросе
+- Access token имеет короткий срок жизни (настраивается в `JWTConfig`)
+- Refresh token позволяет получить новый access token без повторной авторизации
+- Токены хранятся только в `localStorage` на клиенте
+
+## Конфигурация JWT
+
+Настройка времени жизни токенов в `django_cfg`:
+
+```python
+from django_cfg.models.api import JWTConfig
+
+jwt_config = JWTConfig(
+    access_token_lifetime_hours=24,      # Access token на 24 часа
+    refresh_token_lifetime_days=30,      # Refresh token на 30 дней
+    rotate_refresh_tokens=True,          # Ротация refresh токенов
+    blacklist_after_rotation=True,       # Блэклист старых токенов
+)
+```
+
+## Отладка
+
+Проверьте в консоли браузера:
+
+```javascript
+// Проверить наличие токенов
+console.log('Access Token:', localStorage.getItem('auth_token'));
+console.log('Refresh Token:', localStorage.getItem('refresh_token'));
+
+// Сообщение об успешной инжекции
+// "JWT tokens injected successfully"
+```
+
+## Примеры
+
+### Пример 1: Автоматическая инжекция в Next.js приложении (рекомендуется)
+
+```python
+# urls.py - JWT injection работает автоматически
+urlpatterns = [
+    path('cfg/admin/', include('django_cfg.apps.frontend.urls')),  # Admin Panel with JWT
+]
+
+# views.py - создайте свой Next.js app view
+from django_cfg.apps.frontend.views import NextJSStaticView
+
+class MyAppView(NextJSStaticView):
+    """Custom Next.js app with automatic JWT injection."""
+    app_name = 'my_app'  # Serves from static/frontend/my_app/
+```
+
+При переходе на **любую страницу** Next.js приложения авторизованный пользователь автоматически получит JWT токены в localStorage.
+
+**⚠️ На /cfg/admin/auth токены НЕ инжектятся** - это страница логина, пользователь ещё не авторизован!
+
+### Пример 2: Кастомный шаблон с инжекцией
+
+```django
+{% load django_cfg %}
+
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Centrifugo Monitor</title>
+
+    {# Автоматическая инжекция JWT токенов #}
+    {% inject_jwt_tokens_script %}
+</head>
+<body>
+    <div id="root"></div>
+    <script src="/_next/static/chunks/main.js"></script>
+</body>
+</html>
+```
+
+## Требования
+
+- Django с включенной аутентификацией
+- `rest_framework_simplejwt` установлен
+- Пользователь авторизован через Django session
+
+## API Reference
+
+### Template Tags
+
+#### `{% user_jwt_token %}`
+Возвращает JWT access token для текущего пользователя.
+
+#### `{% user_jwt_refresh_token %}`
+Возвращает JWT refresh token для текущего пользователя.
+
+#### `{% inject_jwt_tokens_script %}`
+Генерирует полный `<script>` тег с автоматической инжекцией обоих токенов в localStorage.
+
+### View Classes
+
+#### `NextJSStaticView`
+Базовый view для обслуживания Next.js статических сборок с автоматической JWT инжекцией.
+
+**Features:**
+- Serves Next.js static export files
+- Automatically injects JWT tokens for authenticated users
+- Tokens injected into HTML responses only
+- Handles Next.js client-side routing (.html fallback)
+
+**Usage:**
+```python
+from django_cfg.apps.frontend.views import NextJSStaticView
+
+class MyAppView(NextJSStaticView):
+    app_name = 'my_app'  # Serves from static/frontend/my_app/
+```
+
+#### `AdminView`
+Специализированный view для Admin Panel (наследует `NextJSStaticView`).
+
+**Built-in JWT injection** - no additional configuration needed.

django_cfg/apps/frontend/views.py

@@ -1,20 +1,34 @@
-"""Views for serving Next.js static builds."""
+"""Views for serving Next.js static builds with automatic JWT injection.
 
+JWT tokens are automatically injected into HTML responses for authenticated users.
+This is specific to Next.js frontend apps only.
+"""
+
+import logging
 from pathlib import Path
-from django.http import Http404
+from django.http import Http404, HttpResponse, FileResponse
 from django.views.static import serve
 from django.views import View
+from rest_framework_simplejwt.tokens import RefreshToken
+
+logger = logging.getLogger(__name__)
 
 
 class NextJSStaticView(View):
     """
-    Serve Next.js static build files using Django's built-in static file serving.
+    Serve Next.js static build files with automatic JWT token injection.
+
+    Features:
+    - Serves Next.js static export files
+    - Automatically injects JWT tokens for authenticated users
+    - Tokens injected into HTML responses only
+    - Handles Next.js client-side routing (.html fallback)
     """
 
     app_name = 'admin'
 
     def get(self, request, path=''):
-        """Serve static files from Next.js build."""
+        """Serve static files from Next.js build with JWT injection."""
         import django_cfg
 
         base_dir = Path(django_cfg.__file__).parent / 'static' / 'frontend' / self.app_name
@@ -29,14 +43,109 @@ class NextJSStaticView(View):
         # For routes without extension, try .html (Next.js static export behavior)
         file_path = base_dir / path
         if not file_path.exists() and not path.endswith('.html') and '.' not in Path(path).name:
-            # Try adding .html extension
             html_path = path + '.html'
             html_file = base_dir / html_path
             if html_file.exists():
                 path = html_path
 
-        # Use Django's static serve view (handles security, content-type, etc.)
-        return serve(request, path, document_root=str(base_dir))
+        # For HTML files, remove conditional GET headers to force full response
+        # This allows JWT token injection (can't inject into 304 Not Modified responses)
+        is_html_file = path.endswith('.html')
+        if is_html_file and request.user.is_authenticated:
+            request.META.pop('HTTP_IF_MODIFIED_SINCE', None)
+            request.META.pop('HTTP_IF_NONE_MATCH', None)
+
+        # Serve the static file
+        response = serve(request, path, document_root=str(base_dir))
+
+        # Convert FileResponse to HttpResponse for HTML files to enable JWT injection
+        if isinstance(response, FileResponse):
+            content_type = response.get('Content-Type', '')
+            if 'text/html' in content_type and request.user.is_authenticated:
+                content = b''.join(response.streaming_content)
+                original_response = response
+                response = HttpResponse(
+                    content=content,
+                    status=original_response.status_code,
+                    content_type=content_type
+                )
+                # Copy headers from original response
+                for header, value in original_response.items():
+                    if header.lower() not in ('content-length', 'content-type'):
+                        response[header] = value
+
+        # Inject JWT tokens for authenticated users on HTML responses
+        if self._should_inject_jwt(request, response):
+            self._inject_jwt_tokens(request, response)
+
+        return response
+
+    def _should_inject_jwt(self, request, response):
+        """Check if JWT tokens should be injected."""
+        # Only for authenticated users
+        if not request.user or not request.user.is_authenticated:
+            return False
+
+        # Only for HttpResponse (not FileResponse or StreamingHttpResponse)
+        if not isinstance(response, HttpResponse) or isinstance(response, FileResponse):
+            return False
+
+        # Check if response has content attribute
+        if not hasattr(response, 'content'):
+            return False
+
+        # Only for HTML responses
+        content_type = response.get('Content-Type', '')
+        return 'text/html' in content_type
+
+    def _inject_jwt_tokens(self, request, response):
+        """Inject JWT tokens into HTML response."""
+        try:
+            # Generate JWT tokens
+            refresh = RefreshToken.for_user(request.user)
+            access_token = str(refresh.access_token)
+            refresh_token = str(refresh)
+
+            # Create injection script
+            injection_script = f"""
+<script>
+(function() {{
+    try {{
+        localStorage.setItem('auth_token', '{access_token}');
+        localStorage.setItem('refresh_token', '{refresh_token}');
+        console.log('[Django-CFG] JWT tokens injected successfully');
+    }} catch (e) {{
+        console.error('[Django-CFG] Failed to inject JWT tokens:', e);
+    }}
+}})();
+</script>
+"""
+
+            # Decode response content
+            try:
+                content = response.content.decode('utf-8')
+            except UnicodeDecodeError:
+                logger.warning("Failed to decode response content as UTF-8, skipping JWT injection")
+                return
+
+            # Inject before </head> or </body>
+            if '</head>' in content:
+                content = content.replace('</head>', f'{injection_script}</head>', 1)
+                logger.debug(f"JWT tokens injected before </head> for user {request.user.pk}")
+            elif '</body>' in content:
+                content = content.replace('</body>', f'{injection_script}</body>', 1)
+                logger.debug(f"JWT tokens injected before </body> for user {request.user.pk}")
+            else:
+                logger.warning(f"No </head> or </body> tag found in HTML, skipping JWT injection")
+                return
+
+            # Update response
+            response.content = content.encode('utf-8')
+            response['Content-Length'] = len(response.content)
+
+        except Exception as e:
+            # Log error but don't break the response
+            logger.error(f"Failed to inject JWT tokens for user {request.user.pk}: {e}", exc_info=True)
 
 
 class AdminView(NextJSStaticView):