django-cfg 1.4.87__py3-none-any.whl → 1.4.89__py3-none-any.whl

django_cfg/apps/dashboard/services/overview_service.py

@@ -0,0 +1,205 @@
+"""
+Overview Service
+
+Provides overview data including recent users and activity tracking.
+Extracted from django_dashboard for API-based dashboard.
+"""
+
+import logging
+from datetime import timedelta
+from typing import Any, Dict, List
+
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
+
+
+class OverviewService:
+    """
+    Service for dashboard overview data.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: Provides recent activity and user registration tracking%%
+
+    TAGS: overview, dashboard, activity, service
+    DEPENDS_ON: [django.contrib.auth]
+    """
+
+    def __init__(self):
+        """Initialize overview service."""
+        self.logger = logger
+
+    def _get_user_model(self):
+        """Get the user model safely."""
+        return get_user_model()
+
+    def get_recent_users(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent users for activity section.
+
+        Args:
+            limit: Maximum number of users to return (default: 10)
+
+        Returns:
+            List of user dictionaries with id, username, email, is_active, date_joined
+
+        %%AI_HINT: Real Django ORM query for recent users%%
+        """
+        try:
+            User = self._get_user_model()
+            recent_users = User.objects.order_by('-date_joined')[:limit]
+
+            return [
+                {
+                    'id': user.id,
+                    'username': user.username,
+                    'email': user.email or '',
+                    'is_active': user.is_active,
+                    'is_staff': user.is_staff,
+                    'date_joined': user.date_joined.isoformat() if user.date_joined else None,
+                }
+                for user in recent_users
+            ]
+        except Exception as e:
+            self.logger.error(f"Error getting recent users: {e}")
+            return []
+
+    def get_activity_tracker(self, days: int = 365) -> List[Dict[str, Any]]:
+        """
+        Get activity tracker data for GitHub-style heatmap.
+
+        Returns list of dicts with date and count for last N days.
+
+        Args:
+            days: Number of days to track (default: 365)
+
+        Returns:
+            List of activity data: [{'date': 'YYYY-MM-DD', 'count': int, 'level': int}, ...]
+            level: 0-4 (0=no activity, 4=very high activity)
+
+        %%AI_HINT: Generates daily activity counts from user registrations and logins%%
+        """
+        try:
+            User = self._get_user_model()
+            today = timezone.now().date()
+            activity_data = []
+
+            for days_ago in range(days - 1, -1, -1):  # Newest last
+                date = today - timedelta(days=days_ago)
+
+                # Count user registrations on this day
+                registrations = User.objects.filter(
+                    date_joined__date=date
+                ).count()
+
+                # Count logins on this day (if last_login exists)
+                logins = 0
+                if hasattr(User, 'last_login'):
+                    logins = User.objects.filter(
+                        last_login__date=date
+                    ).count()
+
+                # Total activity for the day
+                total_activity = registrations + logins
+
+                activity_data.append({
+                    'date': date.isoformat(),
+                    'count': total_activity,
+                    'level': self._get_activity_level(total_activity),
+                })
+
+            return activity_data
+
+        except Exception as e:
+            self.logger.error(f"Error getting activity tracker: {e}")
+            return []
+
+    def _get_activity_level(self, count: int) -> int:
+        """
+        Convert activity count to level (0-4) for heatmap colors.
+
+        Args:
+            count: Number of activities
+
+        Returns:
+            Activity level (0-4):
+            - 0 = no activity (gray)
+            - 1 = low (light green)
+            - 2 = medium (green)
+            - 3 = high (dark green)
+            - 4 = very high (darkest green)
+        """
+        if count == 0:
+            return 0
+        elif count <= 2:
+            return 1
+        elif count <= 5:
+            return 2
+        elif count <= 10:
+            return 3
+        else:
+            return 4
+
+    def get_key_stats(self) -> Dict[str, Any]:
+        """
+        Get key statistics for overview.
+
+        Returns:
+            Dictionary with users, databases, apps counts
+
+        %%AI_HINT: Provides high-level system statistics%%
+        """
+        try:
+            User = self._get_user_model()
+
+            # Get database count
+            from django.db import connection
+            db_count = len(connection.settings_dict.get('DATABASES', {})) if hasattr(connection, 'settings_dict') else 1
+
+            # Get app count
+            from django.apps import apps
+            app_count = len(apps.get_app_configs())
+
+            return {
+                'users': User.objects.count(),
+                'databases': db_count,
+                'apps': app_count,
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting key stats: {e}")
+            return {
+                'users': 0,
+                'databases': 0,
+                'apps': 0,
+                'error': str(e)
+            }
+
+    def get_system_info(self) -> Dict[str, Any]:
+        """
+        Get system information.
+
+        Returns:
+            Dictionary with Python version and system metrics
+
+        %%AI_HINT: System-level information using psutil%%
+        """
+        import sys
+        import psutil
+
+        try:
+            return {
+                'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+                'cpu_percent': round(psutil.cpu_percent(interval=0.1), 1),
+                'memory_percent': round(psutil.virtual_memory().percent, 1),
+                'disk_percent': round(psutil.disk_usage('/').percent, 1),
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting system info: {e}")
+            return {
+                'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+                'cpu_percent': 0,
+                'memory_percent': 0,
+                'disk_percent': 0,
+                'error': str(e)
+            }

django_cfg/apps/dashboard/views/commands_views.py

@@ -4,19 +4,29 @@ Commands ViewSet
 Endpoints for Django management commands:
 - GET /commands/ - All available commands
 - GET /commands/summary/ - Commands summary with statistics
+- POST /commands/execute/ - Execute a command with streaming output
+- GET /commands/{name}/help/ - Get help for a specific command
 """
 
+import json
 import logging
 
+from django.http import StreamingHttpResponse
 from drf_spectacular.utils import extend_schema
 from rest_framework import status, viewsets
 from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 from rest_framework.decorators import action
-from rest_framework.permissions import IsAdminUser
 from rest_framework.response import Response
+from rest_framework_simplejwt.authentication import JWTAuthentication
 
+from ..permissions import IsSuperAdmin
 from ..services import CommandsService
-from ..serializers import CommandSerializer, CommandsSummarySerializer
+from ..serializers import (
+    CommandSerializer,
+    CommandsSummarySerializer,
+    CommandExecuteRequestSerializer,
+    CommandHelpResponseSerializer,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -28,8 +38,8 @@ class CommandsViewSet(viewsets.GenericViewSet):
     Provides endpoints for Django management commands discovery.
     """
 
-    authentication_classes = [SessionAuthentication, BasicAuthentication]
-    permission_classes = [IsAdminUser]
+    authentication_classes = [JWTAuthentication, SessionAuthentication, BasicAuthentication]
+    permission_classes = [IsSuperAdmin]  # Only superusers can access commands
     serializer_class = CommandSerializer
     pagination_class = None  # Disable pagination for commands list
 
@@ -71,3 +81,81 @@ class CommandsViewSet(viewsets.GenericViewSet):
             return Response({
                 'error': str(e)
             }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Execute command",
+        description="Execute a Django management command and stream output in Server-Sent Events format",
+        request=CommandExecuteRequestSerializer,
+        responses={
+            200: {"description": "Command execution started (SSE stream)"},
+            400: {"description": "Invalid request"},
+            403: {"description": "Command not allowed"},
+        },
+        tags=["Dashboard - Commands"]
+    )
+    @action(detail=False, methods=['post'], url_path='execute', serializer_class=CommandExecuteRequestSerializer)
+    def execute(self, request):
+        """Execute a Django management command with streaming output."""
+        try:
+            # Validate request data
+            serializer = CommandExecuteRequestSerializer(data=request.data)
+            if not serializer.is_valid():
+                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+            command_name = serializer.validated_data['command']
+            args = serializer.validated_data.get('args', [])
+            options = serializer.validated_data.get('options', {})
+
+            # Create streaming response
+            def stream_execution():
+                """Generator that streams command output as Server-Sent Events."""
+                commands_service = CommandsService()
+
+                for event in commands_service.execute_command(
+                    command_name=command_name,
+                    args=args,
+                    options=options,
+                    user=request.user
+                ):
+                    # Format as Server-Sent Event
+                    yield f"data: {json.dumps(event)}\n\n"
+
+            response = StreamingHttpResponse(
+                stream_execution(),
+                content_type='text/event-stream'
+            )
+            response['Cache-Control'] = 'no-cache'
+            response['X-Accel-Buffering'] = 'no'  # Disable nginx buffering
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Command execution API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get command help",
+        description="Get detailed help text for a specific Django management command",
+        responses={200: CommandHelpResponseSerializer},
+        tags=["Dashboard - Commands"]
+    )
+    @action(detail=True, methods=['get'], url_path='help', serializer_class=CommandHelpResponseSerializer)
+    def help(self, request, pk=None):
+        """Get help text for a specific command."""
+        try:
+            commands_service = CommandsService()
+            help_data = commands_service.get_command_help(pk)
+
+            if help_data.get('status') == 'error':
+                return Response(help_data, status=status.HTTP_404_NOT_FOUND)
+
+            return Response(help_data)
+
+        except Exception as e:
+            logger.error(f"Command help API error: {e}")
+            return Response({
+                'status': 'error',
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

django_cfg/apps/frontend/test_routing.py

@@ -0,0 +1,134 @@
+"""
+Test script for SPA routing logic.
+
+Run this to verify that URL paths resolve correctly to static files.
+"""
+
+from pathlib import Path
+import django_cfg
+
+
+def test_resolve_spa_path():
+    """Test the SPA path resolution logic."""
+
+    # Simulate the base directory
+    base_dir = Path(django_cfg.__file__).parent / 'static' / 'frontend' / 'admin'
+
+    print(f"Base directory: {base_dir}")
+    print(f"Base directory exists: {base_dir.exists()}\n")
+
+    # Test cases
+    test_cases = [
+        # (input_path, expected_output_path, description)
+        ('', 'index.html', 'Root path'),
+        ('/', 'index.html', 'Root path with slash'),
+        ('private/centrifugo', 'private/centrifugo/index.html', 'Nested route without trailing slash'),
+        ('private/centrifugo/', 'private/centrifugo/index.html', 'Nested route with trailing slash'),
+        ('private', 'private.html', 'Single segment route'),
+        ('private/', 'private/index.html', 'Single segment with trailing slash'),
+        ('_next/static/chunks/app.js', '_next/static/chunks/app.js', 'Static asset (exact match)'),
+        ('favicon.ico', 'favicon.ico', 'Favicon (exact match)'),
+        ('unknown/route', 'index.html', 'Unknown route (SPA fallback)'),
+    ]
+
+    def resolve_spa_path(base_dir, path):
+        """
+        Exact copy of the view's _resolve_spa_path method.
+
+        This should match the logic in views.py exactly.
+        """
+        # Handle empty path (done in view before calling this method)
+        if not path or path == '/':
+            path = 'index.html'
+            return path
+
+        file_path = base_dir / path
+        path_normalized = path.rstrip('/')
+
+        # Strategy 1: Exact file match (for static assets like JS, CSS, images)
+        if file_path.exists() and file_path.is_file():
+            return path
+
+        # Strategy 2: Try path/index.html (most common for SPA routes)
+        index_in_dir = base_dir / path_normalized / 'index.html'
+        if index_in_dir.exists():
+            resolved_path = f"{path_normalized}/index.html"
+            return resolved_path
+
+        # Strategy 3: Try with trailing slash + index.html
+        if path.endswith('/'):
+            index_path = path + 'index.html'
+            if (base_dir / index_path).exists():
+                return index_path
+
+        # Strategy 4: Try path.html (Next.js static export behavior)
+        html_file = base_dir / (path_normalized + '.html')
+        if html_file.exists():
+            resolved_path = path_normalized + '.html'
+            return resolved_path
+
+        # Strategy 5: Check if it's a directory without index.html
+        if file_path.exists() and file_path.is_dir():
+            # Try index.html in that directory
+            index_in_existing_dir = file_path / 'index.html'
+            if index_in_existing_dir.exists():
+                resolved_path = f"{path_normalized}/index.html"
+                return resolved_path
+
+        # Strategy 6: SPA fallback - serve root index.html
+        # This allows client-side routing to handle unknown routes
+        root_index = base_dir / 'index.html'
+        if root_index.exists():
+            return 'index.html'
+
+        # Strategy 7: Nothing found - return original path (will 404)
+        return path
+
+    print("=" * 80)
+    print("SPA ROUTING TEST RESULTS")
+    print("=" * 80)
+
+    passed = 0
+    failed = 0
+
+    for input_path, expected, description in test_cases:
+        result = resolve_spa_path(base_dir, input_path)
+
+        # Check if file exists
+        resolved_file = base_dir / result
+        file_exists = resolved_file.exists() and resolved_file.is_file()
+
+        # Determine test status
+        if result == expected:
+            status = "✅ PASS"
+            passed += 1
+        else:
+            status = "❌ FAIL"
+            failed += 1
+
+        print(f"\n{status} - {description}")
+        print(f"  Input:    '{input_path}'")
+        print(f"  Expected: '{expected}'")
+        print(f"  Got:      '{result}'")
+        print(f"  File exists: {file_exists}")
+
+        if result != expected:
+            print(f"  ⚠️  Mismatch detected!")
+
+    print("\n" + "=" * 80)
+    print(f"TEST SUMMARY: {passed} passed, {failed} failed out of {len(test_cases)} tests")
+    print("=" * 80)
+
+    # Additional info
+    print("\n📁 File structure check:")
+    if base_dir.exists():
+        print(f"  - index.html: {(base_dir / 'index.html').exists()}")
+        print(f"  - private.html: {(base_dir / 'private.html').exists()}")
+        print(f"  - private/index.html: {(base_dir / 'private' / 'index.html').exists()}")
+        print(f"  - private/centrifugo/index.html: {(base_dir / 'private' / 'centrifugo' / 'index.html').exists()}")
+    else:
+        print(f"  ⚠️  Base directory does not exist!")
+
+
+if __name__ == '__main__':
+    test_resolve_spa_path()

django_cfg/apps/frontend/views.py

@@ -9,11 +9,14 @@ from pathlib import Path
 from django.http import Http404, HttpResponse, FileResponse
 from django.views.static import serve
 from django.views import View
+from django.views.decorators.clickjacking import xframe_options_exempt
+from django.utils.decorators import method_decorator
 from rest_framework_simplejwt.tokens import RefreshToken
 
 logger = logging.getLogger(__name__)
 
 
+@method_decorator(xframe_options_exempt, name='dispatch')
 class NextJSStaticView(View):
     """
     Serve Next.js static build files with automatic JWT token injection.
@@ -24,6 +27,7 @@ class NextJSStaticView(View):
     - Tokens injected into HTML responses only
     - Handles Next.js client-side routing (.html fallback)
     - Automatically serves index.html for directory paths
+    - X-Frame-Options exempt to allow embedding in iframes
 
     Path resolution examples:
     - /cfg/admin/              → /cfg/admin/index.html
@@ -51,34 +55,8 @@ class NextJSStaticView(View):
             path = 'index.html'
             logger.debug(f"Root path requested, serving: {path}")
 
-        # Handle trailing slash - try multiple strategies like a static file server
-        if path.endswith('/') and path != '/':
-            path_without_slash = path.rstrip('/')
-
-            # Strategy 1: Try directory/index.html (most common for static servers)
-            index_path = path + 'index.html'
-            if (base_dir / index_path).exists():
-                path = index_path
-            # Strategy 2: Try path.html (Next.js static export behavior)
-            elif (base_dir / (path_without_slash + '.html')).exists():
-                path = path_without_slash + '.html'
-            # Strategy 3: Keep as directory path (will fail later if directory doesn't exist)
-            else:
-                path = index_path  # Default to index.html in directory
-
-        # 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:
-            html_path = path + '.html'
-            html_file = base_dir / html_path
-            if html_file.exists():
-                path = html_path
-            else:
-                # Try path/index.html as fallback
-                index_path = path + '/index.html'
-                index_file = base_dir / index_path
-                if index_file.exists():
-                    path = index_path
+        # Resolve file path with SPA routing fallback strategy
+        path = self._resolve_spa_path(base_dir, path)
 
         # For HTML files, remove conditional GET headers to force full response
         # This allows JWT token injection (can't inject into 304 Not Modified responses)
@@ -112,6 +90,73 @@ class NextJSStaticView(View):
 
         return response
 
+    def _resolve_spa_path(self, base_dir, path):
+        """
+        Resolve SPA path with multiple fallback strategies.
+
+        Resolution order:
+        1. Exact file match (e.g., script.js, style.css)
+        2. path/index.html (e.g., private/centrifugo/index.html)
+        3. path.html (e.g., private.html for /private)
+        4. Fallback to root index.html for SPA routing
+
+        Examples:
+            /private/centrifugo → private/centrifugo/index.html
+            /private → private.html OR private/index.html
+            /_next/static/... → _next/static/... (exact match)
+            /unknown/route → index.html (SPA fallback)
+        """
+        file_path = base_dir / path
+
+        # Remove trailing slash for processing
+        path_normalized = path.rstrip('/')
+
+        # Strategy 1: Exact file match (for static assets like JS, CSS, images)
+        if file_path.exists() and file_path.is_file():
+            logger.debug(f"[SPA Router] Exact match: {path}")
+            return path
+
+        # Strategy 2: Try path/index.html (most common for SPA routes)
+        index_in_dir = base_dir / path_normalized / 'index.html'
+        if index_in_dir.exists():
+            resolved_path = f"{path_normalized}/index.html"
+            logger.debug(f"[SPA Router] Resolved {path} → {resolved_path}")
+            return resolved_path
+
+        # Strategy 3: Try with trailing slash + index.html
+        if path.endswith('/'):
+            index_path = path + 'index.html'
+            if (base_dir / index_path).exists():
+                logger.debug(f"[SPA Router] Trailing slash resolved: {index_path}")
+                return index_path
+
+        # Strategy 4: Try path.html (Next.js static export behavior)
+        html_file = base_dir / (path_normalized + '.html')
+        if html_file.exists():
+            resolved_path = path_normalized + '.html'
+            logger.debug(f"[SPA Router] HTML file match: {resolved_path}")
+            return resolved_path
+
+        # Strategy 5: Check if it's a directory without index.html
+        if file_path.exists() and file_path.is_dir():
+            # Try index.html in that directory
+            index_in_existing_dir = file_path / 'index.html'
+            if index_in_existing_dir.exists():
+                resolved_path = f"{path_normalized}/index.html"
+                logger.debug(f"[SPA Router] Directory with index: {resolved_path}")
+                return resolved_path
+
+        # Strategy 6: SPA fallback - serve root index.html
+        # This allows client-side routing to handle unknown routes
+        root_index = base_dir / 'index.html'
+        if root_index.exists():
+            logger.debug(f"[SPA Router] Fallback to index.html for route: {path}")
+            return 'index.html'
+
+        # Strategy 7: Nothing found - return original path (will 404)
+        logger.warning(f"[SPA Router] No match found for: {path}")
+        return path
+
     def _should_inject_jwt(self, request, response):
         """Check if JWT tokens should be injected."""
         # Only for authenticated users

django_cfg/apps/urls.py

@@ -170,7 +170,6 @@ APP_URL_MAP = {
     ],
     "django_cfg.apps.centrifugo": [
         ("cfg/centrifugo/", "django_cfg.apps.centrifugo.urls"),
-        ("cfg/centrifugo/admin/", "django_cfg.apps.centrifugo.urls_admin"),
     ],
 }
 

django_cfg/core/builders/apps_builder.py

@@ -183,66 +183,8 @@ class InstalledAppsBuilder:
                 # django-browser-reload not installed, skip it
                 pass
 
-        # Auto-detect dashboard apps from Unfold callback
-        dashboard_apps = self._get_dashboard_apps_from_callback()
-        apps.extend(dashboard_apps)
-
         return apps
 
-    def _get_dashboard_apps_from_callback(self) -> List[str]:
-        """
-        Auto-detect dashboard apps from Unfold dashboard_callback setting.
-
-        Extracts app names from callback paths like:
-        - "api.dashboard.callbacks.main_dashboard_callback" → ["api.dashboard"]
-        - "myproject.admin.callbacks.dashboard" → ["myproject.admin"]
-
-        This allows django-cfg to automatically add dashboard apps to INSTALLED_APPS
-        without requiring manual configuration.
-
-        Returns:
-            List of dashboard app names to add to INSTALLED_APPS
-        """
-        dashboard_apps = []
-
-        # Check if Unfold is configured with a theme
-        if not self.config.unfold or not self.config.unfold.theme:
-            return dashboard_apps
-
-        # Get dashboard callback path from theme
-        callback_path = getattr(self.config.unfold.theme, "dashboard_callback", None)
-        if not callback_path:
-            return dashboard_apps
-
-        try:
-            # Parse callback path: "api.dashboard.callbacks.main_dashboard_callback"
-            # Extract app part: "api.dashboard"
-            parts = callback_path.split(".")
-
-            # Look for common callback patterns
-            callback_indicators = ["callbacks", "views", "handlers"]
-
-            # Find the callback indicator and extract app path before it
-            app_parts = []
-            for i, part in enumerate(parts):
-                if part in callback_indicators:
-                    app_parts = parts[:i]  # Everything before the callback indicator
-                    break
-
-            # If no callback indicator found, assume last part is function name
-            if not app_parts and len(parts) > 1:
-                app_parts = parts[:-1]  # Everything except the last part
-
-            if app_parts:
-                app_name = ".".join(app_parts)
-                dashboard_apps.append(app_name)
-
-        except Exception:
-            # If parsing fails, silently continue - dashboard callback is optional
-            pass
-
-        return dashboard_apps
-
     def _deduplicate(self, apps: List[str]) -> List[str]:
         """
         Remove duplicate apps while preserving order.