django-cfg 1.4.88__py3-none-any.whl → 1.4.89__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.88"
+__version__ = "1.4.89"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/centrifugo/views/__init__.py

@@ -3,7 +3,6 @@ Views for Centrifugo module.
 """
 
 from .admin_api import CentrifugoAdminAPIViewSet
-from .dashboard import dashboard_view
 from .monitoring import CentrifugoMonitorViewSet
 from .testing_api import CentrifugoTestingAPIViewSet
 
@@ -11,5 +10,4 @@ __all__ = [
     'CentrifugoMonitorViewSet',
     'CentrifugoAdminAPIViewSet',
     'CentrifugoTestingAPIViewSet',
-    'dashboard_view',
 ]

django_cfg/apps/dashboard/services/__init__.py

@@ -10,6 +10,7 @@ from .system_health_service import SystemHealthService
 from .charts_service import ChartsService
 from .commands_service import CommandsService
 from .apizones_service import APIZonesService
+from .overview_service import OverviewService
 
 __all__ = [
     'StatisticsService',
@@ -17,4 +18,5 @@ __all__ = [
     'ChartsService',
     'CommandsService',
     'APIZonesService',
+    'OverviewService',
 ]

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/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

@@ -55,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)
@@ -116,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.

django_cfg/modules/django_unfold/__init__.py

@@ -1,13 +1,12 @@
 """
 Django CFG Unfold Module
 
-Provides complete Unfold admin interface integration with dashboard,
-navigation, theming, and callback support.
+Provides complete Unfold admin interface integration with
+navigation and theming support.
 """
 
-from .callbacks import UnfoldCallbacks
-from .dashboard import DashboardManager, get_dashboard_manager
 from .models import *
+from .navigation import NavigationManager, get_navigation_manager
 from .system_monitor import SystemMonitor
 from .tailwind import get_css_variables, get_unfold_colors
 
@@ -20,19 +19,10 @@ def get_system_monitor() -> SystemMonitor:
         globals()['_system_monitor'] = SystemMonitor()
     return globals()['_system_monitor']
 
-def get_unfold_callbacks() -> UnfoldCallbacks:
-    """Get the global unfold callbacks instance."""
-    global _unfold_callbacks
-    if '_unfold_callbacks' not in globals():
-        globals()['_unfold_callbacks'] = UnfoldCallbacks()
-    return globals()['_unfold_callbacks']
-
 # Export main components
 __all__ = [
-    'DashboardManager',
-    'get_dashboard_manager',
-    'UnfoldCallbacks',
-    'get_unfold_callbacks',
+    'NavigationManager',
+    'get_navigation_manager',
     'SystemMonitor',
     'get_system_monitor',
     'get_unfold_colors',
@@ -48,15 +38,6 @@ __all__ = [
     'NavigationSection',
     'NavigationItemType',
     'SiteDropdownItem',
-    'StatCard',
-    'SystemHealthItem',
-    'QuickAction',
-    'DashboardWidget',
-    'DashboardData',
-    'ChartDataset',
-    'ChartData',
-    'TabConfiguration',
-    'TabItem',
 ]
 
 # Version info

django_cfg/modules/django_unfold/models/__init__.py

@@ -12,18 +12,8 @@ from .config import (
     UnfoldTheme,
     UnfoldThemeConfig,
 )
-from .dashboard import (
-    ChartData,
-    ChartDataset,
-    DashboardData,
-    DashboardWidget,
-    QuickAction,
-    StatCard,
-    SystemHealthItem,
-)
 from .dropdown import SiteDropdownItem
 from .navigation import NavigationItem, NavigationItemType, NavigationSection
-from .tabs import TabConfiguration, TabItem
 
 __all__ = [
     # Config models
@@ -41,17 +31,4 @@ __all__ = [
 
     # Dropdown models
     'SiteDropdownItem',
-
-    # Dashboard models
-    'StatCard',
-    'SystemHealthItem',
-    'QuickAction',
-    'DashboardWidget',
-    'DashboardData',
-    'ChartDataset',
-    'ChartData',
-
-    # Tab models
-    'TabConfiguration',
-    'TabItem',
 ]