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

django_cfg/apps/dashboard/services/statistics_service.py

@@ -0,0 +1,235 @@
+"""
+Statistics Service
+
+Collects and aggregates statistics for dashboard display.
+No ORM dependencies - can work with any data source.
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class StatisticsService:
+    """
+    Service for collecting dashboard statistics.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: This service collects data from various sources without ORM%%
+
+    TAGS: statistics, dashboard, service
+    """
+
+    def __init__(self):
+        """Initialize statistics service."""
+        self.logger = logger
+
+    def get_user_statistics(self) -> Dict[str, Any]:
+        """
+        Get user-related statistics.
+
+        Returns:
+            Dictionary containing user stats:
+            - total_users: Total number of users
+            - active_users: Number of active users (last 30 days)
+            - new_users: New users in last 7 days
+            - superusers: Number of superusers
+
+        %%AI_HINT: Currently returns mock data. Replace with real data source%%
+        """
+        try:
+            # TODO: Replace with real data collection
+            # Example: from django.contrib.auth import get_user_model
+            # User = get_user_model()
+            # total_users = User.objects.count()
+
+            return {
+                'total_users': 1250,
+                'active_users': 892,
+                'new_users': 45,
+                'superusers': 3,
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting user statistics: {e}")
+            return {
+                'total_users': 0,
+                'active_users': 0,
+                'new_users': 0,
+                'superusers': 0,
+                'error': str(e)
+            }
+
+    def get_app_statistics(self) -> Dict[str, Dict[str, int]]:
+        """
+        Get application-specific statistics.
+
+        Returns:
+            Dictionary with app names as keys and their stats as values.
+            Example:
+            {
+                'leads': {'total': 450, 'active': 120},
+                'tasks': {'total': 1200, 'completed': 890},
+                ...
+            }
+
+        %%AI_HINT: Aggregates statistics from different django-cfg apps%%
+        """
+        try:
+            # TODO: Collect real statistics from enabled apps
+            return {
+                'leads': {
+                    'total': 450,
+                    'active': 120,
+                    'converted': 85,
+                },
+                'tasks': {
+                    'total': 1200,
+                    'completed': 890,
+                    'pending': 310,
+                },
+                'support': {
+                    'total': 340,
+                    'open': 45,
+                    'closed': 295,
+                },
+                'newsletter': {
+                    'subscribers': 2500,
+                    'campaigns': 12,
+                    'sent': 28000,
+                }
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting app statistics: {e}")
+            return {'error': str(e)}
+
+    def get_stat_cards(self) -> List[Dict[str, Any]]:
+        """
+        Get statistics cards for dashboard overview.
+
+        Returns:
+            List of stat card dictionaries ready for serialization.
+            Each card contains: title, value, icon, change, change_type
+
+        USED_BY: DashboardViewSet.overview endpoint
+        """
+        try:
+            user_stats = self.get_user_statistics()
+
+            cards = [
+                {
+                    'title': 'Total Users',
+                    'value': str(user_stats['total_users']),
+                    'icon': 'people',
+                    'change': '+12%',
+                    'change_type': 'positive',
+                    'color': 'primary',
+                },
+                {
+                    'title': 'Active Users',
+                    'value': str(user_stats['active_users']),
+                    'icon': 'person',
+                    'change': '+5%',
+                    'change_type': 'positive',
+                    'color': 'success',
+                },
+                {
+                    'title': 'New Users (7d)',
+                    'value': str(user_stats['new_users']),
+                    'icon': 'person_add',
+                    'change': '-2%',
+                    'change_type': 'negative',
+                    'color': 'warning',
+                },
+                {
+                    'title': 'System Health',
+                    'value': '98%',
+                    'icon': 'health_and_safety',
+                    'change': '+1%',
+                    'change_type': 'positive',
+                    'color': 'success',
+                },
+            ]
+
+            return cards
+
+        except Exception as e:
+            self.logger.error(f"Error generating stat cards: {e}")
+            return []
+
+    def get_recent_activity(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent activity entries for dashboard.
+
+        Args:
+            limit: Maximum number of activity entries to return
+
+        Returns:
+            List of recent activity entries
+
+        %%AI_HINT: Can be connected to django-auditlog or custom activity tracking%%
+        """
+        try:
+            # TODO: Connect to real activity logging system
+            now = datetime.now()
+
+            activities = [
+                {
+                    'id': 1,
+                    'user': 'john@example.com',
+                    'action': 'created',
+                    'resource': 'Lead #1234',
+                    'timestamp': (now - timedelta(minutes=5)).isoformat(),
+                    'icon': 'add_circle',
+                    'color': 'success',
+                },
+                {
+                    'id': 2,
+                    'user': 'admin@example.com',
+                    'action': 'updated',
+                    'resource': 'User Settings',
+                    'timestamp': (now - timedelta(minutes=15)).isoformat(),
+                    'icon': 'edit',
+                    'color': 'primary',
+                },
+                {
+                    'id': 3,
+                    'user': 'sarah@example.com',
+                    'action': 'completed',
+                    'resource': 'Task #456',
+                    'timestamp': (now - timedelta(hours=1)).isoformat(),
+                    'icon': 'check_circle',
+                    'color': 'success',
+                },
+            ]
+
+            return activities[:limit]
+
+        except Exception as e:
+            self.logger.error(f"Error getting recent activity: {e}")
+            return []
+
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """
+        Get system performance metrics.
+
+        Returns:
+            Dictionary with system metrics (CPU, memory, disk, etc.)
+
+        %%AI_HINT: Can use psutil or similar for real system metrics%%
+        """
+        try:
+            # TODO: Collect real system metrics
+            return {
+                'cpu_usage': 45.2,
+                'memory_usage': 62.8,
+                'disk_usage': 38.5,
+                'network_in': '125 MB/s',
+                'network_out': '89 MB/s',
+                'response_time': '245 ms',
+                'uptime': '15 days, 3 hours',
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting system metrics: {e}")
+            return {'error': str(e)}

django_cfg/apps/dashboard/services/system_health_service.py

@@ -0,0 +1,280 @@
+"""
+System Health Service
+
+Monitors system components health status.
+Checks database, cache, queue, storage, and API availability.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Literal
+
+logger = logging.getLogger(__name__)
+
+
+class SystemHealthService:
+    """
+    Service for monitoring system component health.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: Checks health of various system components%%
+
+    TAGS: health, monitoring, system, service
+    DEPENDS_ON: [django.db.connection, django.core.cache, redis]
+    """
+
+    def __init__(self):
+        """Initialize system health service."""
+        self.logger = logger
+
+    def check_database_health(self) -> Dict[str, Any]:
+        """
+        Check database connectivity and health.
+
+        Returns:
+            Health status dictionary with status, description, last_check
+        """
+        try:
+            from django.db import connection
+
+            # Test database connection
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT 1")
+                cursor.fetchone()
+
+            return {
+                'component': 'database',
+                'status': 'healthy',
+                'description': 'Database connection is working',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 100,
+            }
+        except Exception as e:
+            self.logger.error(f"Database health check failed: {e}")
+            return {
+                'component': 'database',
+                'status': 'error',
+                'description': f'Database error: {str(e)}',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 0,
+            }
+
+    def check_cache_health(self) -> Dict[str, Any]:
+        """
+        Check cache (Redis/Memcached) connectivity and health.
+
+        Returns:
+            Health status dictionary
+        """
+        try:
+            from django.core.cache import cache
+
+            # Test cache by setting and getting a test value
+            test_key = 'health_check_test'
+            test_value = 'ok'
+            cache.set(test_key, test_value, timeout=10)
+            result = cache.get(test_key)
+
+            if result == test_value:
+                cache.delete(test_key)
+                return {
+                    'component': 'cache',
+                    'status': 'healthy',
+                    'description': 'Cache is working correctly',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 100,
+                }
+            else:
+                return {
+                    'component': 'cache',
+                    'status': 'warning',
+                    'description': 'Cache test failed',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 50,
+                }
+
+        except Exception as e:
+            self.logger.error(f"Cache health check failed: {e}")
+            return {
+                'component': 'cache',
+                'status': 'error',
+                'description': f'Cache error: {str(e)}',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 0,
+            }
+
+    def check_queue_health(self) -> Dict[str, Any]:
+        """
+        Check task queue (Celery/Dramatiq) health.
+
+        Returns:
+            Health status dictionary
+        """
+        try:
+            # TODO: Add real queue health check
+            # Example: Check Redis connection, queue sizes, worker status
+            from django_cfg.modules.django_tasks import DjangoTasks
+
+            tasks = DjangoTasks()
+            redis_client = tasks.get_redis_client()
+
+            if redis_client and redis_client.ping():
+                return {
+                    'component': 'queue',
+                    'status': 'healthy',
+                    'description': 'Queue system is operational',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 100,
+                }
+            else:
+                return {
+                    'component': 'queue',
+                    'status': 'error',
+                    'description': 'Queue system unavailable',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 0,
+                }
+
+        except Exception as e:
+            self.logger.error(f"Queue health check failed: {e}")
+            return {
+                'component': 'queue',
+                'status': 'error',
+                'description': f'Queue error: {str(e)}',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 0,
+            }
+
+    def check_storage_health(self) -> Dict[str, Any]:
+        """
+        Check storage/file system health.
+
+        Returns:
+            Health status dictionary
+        """
+        try:
+            import os
+            from django.conf import settings
+
+            # Check if media directory is writable
+            media_root = getattr(settings, 'MEDIA_ROOT', None)
+
+            if media_root and os.path.exists(media_root) and os.access(media_root, os.W_OK):
+                return {
+                    'component': 'storage',
+                    'status': 'healthy',
+                    'description': 'Storage is accessible and writable',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 100,
+                }
+            else:
+                return {
+                    'component': 'storage',
+                    'status': 'warning',
+                    'description': 'Storage may have limited access',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 70,
+                }
+
+        except Exception as e:
+            self.logger.error(f"Storage health check failed: {e}")
+            return {
+                'component': 'storage',
+                'status': 'error',
+                'description': f'Storage error: {str(e)}',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 0,
+            }
+
+    def get_all_health_checks(self) -> List[Dict[str, Any]]:
+        """
+        Run all health checks and return aggregated results.
+
+        Returns:
+            List of health check results for all components
+
+        USED_BY: DashboardViewSet.system_health endpoint
+        """
+        checks = [
+            self.check_database_health(),
+            self.check_cache_health(),
+            self.check_queue_health(),
+            self.check_storage_health(),
+        ]
+
+        return checks
+
+    def get_overall_health_status(self) -> Dict[str, Any]:
+        """
+        Get overall system health status.
+
+        Returns:
+            Dictionary with overall status, percentage, and component details
+        """
+        checks = self.get_all_health_checks()
+
+        # Calculate overall health percentage
+        total_health = sum(check.get('health_percentage', 0) for check in checks)
+        overall_percentage = total_health // len(checks) if checks else 0
+
+        # Determine overall status
+        statuses = [check.get('status') for check in checks]
+        if 'error' in statuses:
+            overall_status = 'error'
+        elif 'warning' in statuses:
+            overall_status = 'warning'
+        else:
+            overall_status = 'healthy'
+
+        return {
+            'overall_status': overall_status,
+            'overall_health_percentage': overall_percentage,
+            'components': checks,
+            'timestamp': datetime.now().isoformat(),
+        }
+
+    def get_quick_actions(self) -> List[Dict[str, Any]]:
+        """
+        Get quick action buttons for dashboard.
+
+        Returns:
+            List of quick action dictionaries
+
+        %%AI_HINT: Actions link to admin pages or trigger common tasks%%
+        """
+        actions = [
+            {
+                'title': 'User Management',
+                'description': 'Manage users and permissions',
+                'icon': 'people',
+                'link': '/admin/auth/user/',
+                'color': 'primary',
+                'category': 'admin',
+            },
+            {
+                'title': 'View Logs',
+                'description': 'Check system logs',
+                'icon': 'description',
+                'link': '/admin/django_cfg/logs/',
+                'color': 'secondary',
+                'category': 'system',
+            },
+            {
+                'title': 'Clear Cache',
+                'description': 'Clear application cache',
+                'icon': 'refresh',
+                'link': '/cfg/admin/cache/clear/',
+                'color': 'warning',
+                'category': 'system',
+            },
+            {
+                'title': 'Run Backup',
+                'description': 'Create system backup',
+                'icon': 'backup',
+                'link': '/cfg/admin/backup/create/',
+                'color': 'success',
+                'category': 'system',
+            },
+        ]
+
+        return actions

django_cfg/apps/dashboard/urls.py

@@ -0,0 +1,23 @@
+"""
+Dashboard URLs
+
+RESTful API endpoints for dashboard data.
+Follows the same pattern as tasks app.
+"""
+
+from django.urls import include, path
+from rest_framework.routers import DefaultRouter
+
+from .api.viewsets import DashboardViewSet
+
+app_name = 'dashboard'
+
+# Main router for ViewSets
+router = DefaultRouter()
+router.register(r'', DashboardViewSet, basename='dashboard')
+
+urlpatterns = [
+    # RESTful API endpoints using ViewSets
+    # Mounted at cfg/dashboard/api/
+    path('api/', include(router.urls)),
+]

django_cfg/apps/frontend/views.py

@@ -40,6 +40,11 @@ class NextJSStaticView(View):
         if not path or path == '/':
             path = 'index.html'
 
+        # Handle trailing slash (Next.js static export behavior)
+        # /private/ -> private.html
+        if path.endswith('/') and path != '/':
+            path = path.rstrip('/') + '.html'
+
         # 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:

django_cfg/apps/urls.py

@@ -84,7 +84,7 @@ def get_default_cfg_group():
         name="cfg",
         apps=get_enabled_cfg_apps(),
         title="Django-CFG API",
-        description="Authentication (OTP), Support, Newsletter, Leads, Knowledge Base, AI Agents, Tasks, Payments",
+        description="Authentication (OTP), Support, Newsletter, Leads, Knowledge Base, AI Agents, Tasks, Payments, Dashboard",
         version="1.0.0",
     )
 
@@ -134,6 +134,7 @@ urlpatterns = [
     path('cfg/commands/', include('django_cfg.apps.api.commands.urls')),
     path('cfg/openapi/', include('django_cfg.modules.django_client.urls')),
     path('cfg/admin/', include('django_cfg.apps.frontend.urls')),  # Next.js admin panel
+    path('cfg/dashboard/', include('django_cfg.apps.dashboard.urls')),  # Dashboard API
 ]
 
 # Django-CFG apps - conditionally registered based on config

django_cfg/core/builders/apps_builder.py

@@ -109,6 +109,7 @@ class InstalledAppsBuilder:
             "django_cfg.modules.django_tailwind",  # Universal Tailwind layouts
             "django_cfg.apps.api.health",
             "django_cfg.apps.api.commands",
+            "django_cfg.apps.dashboard",  # Dashboard API
         ]
 
         if self.config.enable_frontend:

django_cfg/modules/django_client/core/parser/openapi30.py

@@ -59,16 +59,23 @@ class OpenAPI30Parser(BaseParser):
             return True
 
         # Check anyOf: [{"type": "X"}, {"type": "null"}] format (Pydantic)
+        # or anyOf: [{"$ref": "..."}, {"type": "null"}] format
         if schema.anyOf and len(schema.anyOf) == 2:
-            types = []
+            has_null = False
+            has_actual_type = False
+
             for item in schema.anyOf:
                 if not isinstance(item, SchemaObject):
                     continue
-                if item.base_type:
-                    types.append(item.base_type)
 
-            # If one type is 'null' and another is actual type, it's nullable
-            if 'null' in types and len(types) == 2:
+                if item.base_type == 'null':
+                    has_null = True
+                elif item.base_type or item.ref:
+                    # Has actual type (either base_type or $ref)
+                    has_actual_type = True
+
+            # If one is null and another is actual type, it's nullable
+            if has_null and has_actual_type:
                 return True
 
         return False

django_cfg/modules/django_client/core/parser/openapi31.py

@@ -67,16 +67,23 @@ class OpenAPI31Parser(BaseParser):
             return True
 
         # Check anyOf: [{"type": "X"}, {"type": "null"}] format (Pydantic)
+        # or anyOf: [{"$ref": "..."}, {"type": "null"}] format
         if schema.anyOf and len(schema.anyOf) == 2:
-            types = []
+            has_null = False
+            has_actual_type = False
+
             for item in schema.anyOf:
                 if not isinstance(item, SchemaObject):
                     continue
-                if item.base_type:
-                    types.append(item.base_type)
 
-            # If one type is 'null' and another is actual type, it's nullable
-            if 'null' in types and len(types) == 2:
+                if item.base_type == 'null':
+                    has_null = True
+                elif item.base_type or item.ref:
+                    # Has actual type (either base_type or $ref)
+                    has_actual_type = True
+
+            # If one is null and another is actual type, it's nullable
+            if has_null and has_actual_type:
                 return True
 
         return False

django_cfg/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.83"
+version = "1.4.84"
 description = "Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "ai-agents", "enterprise-django", "django-settings", "type-safe-config",]