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

django_cfg/apps/dashboard/services/statistics_service.py

@@ -2,13 +2,17 @@
 Statistics Service
 
 Collects and aggregates statistics for dashboard display.
-No ORM dependencies - can work with any data source.
+Uses Django ORM for real data collection.
 """
 
 import logging
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional
 
+from django.apps import apps
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+
 logger = logging.getLogger(__name__)
 
 
@@ -17,7 +21,7 @@ class StatisticsService:
     Service for collecting dashboard statistics.
 
     %%PRIORITY:HIGH%%
-    %%AI_HINT: This service collects data from various sources without ORM%%
+    %%AI_HINT: This service collects data from various Django models using ORM%%
 
     TAGS: statistics, dashboard, service
     """
@@ -26,6 +30,10 @@ class StatisticsService:
         """Initialize statistics service."""
         self.logger = logger
 
+    def _get_user_model(self):
+        """Get the user model safely."""
+        return get_user_model()
+
     def get_user_statistics(self) -> Dict[str, Any]:
         """
         Get user-related statistics.
@@ -33,23 +41,27 @@ class StatisticsService:
         Returns:
             Dictionary containing user stats:
             - total_users: Total number of users
-            - active_users: Number of active users (last 30 days)
+            - active_users: Number of active users
             - new_users: New users in last 7 days
             - superusers: Number of superusers
 
-        %%AI_HINT: Currently returns mock data. Replace with real data source%%
+        %%AI_HINT: Uses real Django ORM queries from User model%%
         """
         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()
+            User = self._get_user_model()
+
+            total_users = User.objects.count()
+            active_users = User.objects.filter(is_active=True).count()
+            new_users_7d = User.objects.filter(
+                date_joined__gte=timezone.now() - timedelta(days=7)
+            ).count()
+            superusers = User.objects.filter(is_superuser=True).count()
 
             return {
-                'total_users': 1250,
-                'active_users': 892,
-                'new_users': 45,
-                'superusers': 3,
+                'total_users': total_users,
+                'active_users': active_users,
+                'new_users': new_users_7d,
+                'superusers': superusers,
             }
         except Exception as e:
             self.logger.error(f"Error getting user statistics: {e}")
@@ -61,48 +73,93 @@ class StatisticsService:
                 'error': str(e)
             }
 
-    def get_app_statistics(self) -> Dict[str, Dict[str, int]]:
+    def get_app_statistics(self) -> Dict[str, Any]:
         """
         Get application-specific statistics.
 
         Returns:
-            Dictionary with app names as keys and their stats as values.
-            Example:
+            Dictionary with aggregated app statistics.
             {
-                'leads': {'total': 450, 'active': 120},
-                'tasks': {'total': 1200, 'completed': 890},
-                ...
+                'apps': {app_label: {...stats...}},
+                'total_records': int,
+                'total_models': int,
+                'total_apps': int
             }
 
-        %%AI_HINT: Aggregates statistics from different django-cfg apps%%
+        %%AI_HINT: Real app introspection using Django apps registry%%
         """
         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,
-                }
-            }
+            stats = {"apps": {}, "total_records": 0, "total_models": 0, "total_apps": 0}
+
+            # Get all installed apps
+            for app_config in apps.get_app_configs():
+                app_label = app_config.label
+
+                # Skip system apps
+                if app_label in ["admin", "contenttypes", "sessions", "auth"]:
+                    continue
+
+                app_stats = self._get_app_stats(app_label)
+                if app_stats:
+                    stats["apps"][app_label] = app_stats
+                    stats["total_records"] += app_stats.get("total_records", 0)
+                    stats["total_models"] += app_stats.get("model_count", 0)
+                    stats["total_apps"] += 1
+
+            return stats
         except Exception as e:
             self.logger.error(f"Error getting app statistics: {e}")
-            return {'error': str(e)}
+            return {'apps': {}, 'total_records': 0, 'total_models': 0, 'total_apps': 0, 'error': str(e)}
+
+    def _get_app_stats(self, app_label: str) -> Optional[Dict[str, Any]]:
+        """Get statistics for a specific app."""
+        try:
+            app_config = apps.get_app_config(app_label)
+            # Convert generator to list to avoid len() error
+            models_list = list(app_config.get_models())
+
+            if not models_list:
+                return None
+
+            app_stats = {
+                "name": app_config.verbose_name or app_label.title(),
+                "models": {},
+                "total_records": 0,
+                "model_count": len(models_list),
+            }
+
+            for model in models_list:
+                try:
+                    # Get model statistics
+                    model_stats = self._get_model_stats(model)
+                    if model_stats:
+                        app_stats["models"][model._meta.model_name] = model_stats
+                        app_stats["total_records"] += model_stats.get("count", 0)
+                except Exception:
+                    continue
+
+            return app_stats
+
+        except Exception:
+            return None
+
+    def _get_model_stats(self, model) -> Optional[Dict[str, Any]]:
+        """Get statistics for a specific model."""
+        try:
+            # Get basic model info
+            model_stats = {
+                "name": model._meta.verbose_name_plural
+                or model._meta.verbose_name
+                or model._meta.model_name,
+                "count": model.objects.count(),
+                "fields_count": len(model._meta.fields),
+                "admin_url": f"admin:{model._meta.app_label}_{model._meta.model_name}_changelist",
+            }
+
+            return model_stats
+
+        except Exception:
+            return None
 
     def get_stat_cards(self) -> List[Dict[str, Any]]:
         """
@@ -113,42 +170,59 @@ class StatisticsService:
             Each card contains: title, value, icon, change, change_type
 
         USED_BY: DashboardViewSet.overview endpoint
+        %%AI_HINT: Real data from User model with calculated changes%%
         """
         try:
             user_stats = self.get_user_statistics()
 
+            total_users = user_stats['total_users']
+            active_users = user_stats['active_users']
+            new_users_7d = user_stats['new_users']
+            superusers = user_stats['superusers']
+
             cards = [
                 {
                     'title': 'Total Users',
-                    'value': str(user_stats['total_users']),
+                    'value': f"{total_users:,}",
                     'icon': 'people',
-                    'change': '+12%',
-                    'change_type': 'positive',
+                    'change': f"+{new_users_7d}" if new_users_7d > 0 else None,
+                    'change_type': 'positive' if new_users_7d > 0 else 'neutral',
                     'color': 'primary',
+                    'description': 'Registered users',
                 },
                 {
                     'title': 'Active Users',
-                    'value': str(user_stats['active_users']),
+                    'value': f"{active_users:,}",
                     'icon': 'person',
-                    'change': '+5%',
-                    'change_type': 'positive',
+                    'change': (
+                        f"{(active_users/total_users*100):.1f}%"
+                        if total_users > 0
+                        else "0%"
+                    ),
+                    'change_type': (
+                        'positive' if active_users > total_users * 0.7 else 'neutral'
+                    ),
                     'color': 'success',
+                    'description': 'Currently active',
                 },
                 {
-                    'title': 'New Users (7d)',
-                    'value': str(user_stats['new_users']),
+                    'title': 'New This Week',
+                    'value': f"{new_users_7d:,}",
                     'icon': 'person_add',
-                    'change': '-2%',
-                    'change_type': 'negative',
-                    'color': 'warning',
+                    'change_type': 'positive' if new_users_7d > 0 else 'neutral',
+                    'color': 'info',
+                    'description': 'Last 7 days',
                 },
                 {
-                    'title': 'System Health',
-                    'value': '98%',
-                    'icon': 'health_and_safety',
-                    'change': '+1%',
-                    'change_type': 'positive',
-                    'color': 'success',
+                    'title': 'Superusers',
+                    'value': f"{superusers:,}",
+                    'icon': 'admin_panel_settings',
+                    'change': (
+                        f"{(superusers/total_users*100):.1f}%" if total_users > 0 else "0%"
+                    ),
+                    'change_type': 'neutral',
+                    'color': 'warning',
+                    'description': 'Administrative access',
                 },
             ]
 
@@ -168,48 +242,96 @@ class StatisticsService:
         Returns:
             List of recent activity entries
 
-        %%AI_HINT: Can be connected to django-auditlog or custom activity tracking%%
+        %%AI_HINT: Returns placeholder - connect to django-auditlog when available%%
         """
         try:
-            # TODO: Connect to real activity logging system
-            now = datetime.now()
+            # Note: This is a placeholder. Real implementation should connect to:
+            # - django-auditlog (if installed)
+            # - Custom activity/history tracking
+            # - Django admin logs (LogEntry model)
 
-            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',
-                },
-            ]
+            # Try to get Django admin logs as fallback
+            from django.contrib.admin.models import LogEntry
+
+            activities = []
+            log_entries = LogEntry.objects.select_related('user', 'content_type').order_by('-action_time')[:limit]
 
-            return activities[:limit]
+            for entry in log_entries:
+                activities.append({
+                    'id': entry.pk,
+                    'user': entry.user.get_username() if entry.user else 'System',
+                    'action': entry.get_action_flag_display().lower(),
+                    'resource': str(entry),
+                    'timestamp': entry.action_time.isoformat(),
+                    'icon': self._get_activity_icon(entry.action_flag),
+                    'color': self._get_activity_color(entry.action_flag),
+                })
+
+            return activities
 
         except Exception as e:
             self.logger.error(f"Error getting recent activity: {e}")
             return []
 
+    def _get_activity_icon(self, action_flag: int) -> str:
+        """Get icon for activity based on action flag."""
+        icons = {
+            1: 'add_circle',      # ADDITION
+            2: 'edit',            # CHANGE
+            3: 'delete',          # DELETION
+        }
+        return icons.get(action_flag, 'circle')
+
+    def _get_activity_color(self, action_flag: int) -> str:
+        """Get color for activity based on action flag."""
+        colors = {
+            1: 'success',   # ADDITION
+            2: 'primary',   # CHANGE
+            3: 'error',     # DELETION
+        }
+        return colors.get(action_flag, 'default')
+
+    def get_recent_users(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent users data.
+
+        Args:
+            limit: Maximum number of users to return
+
+        Returns:
+            List of recent user dictionaries with admin URLs
+
+        %%AI_HINT: Real data from User model with admin URLs%%
+        """
+        try:
+            User = self._get_user_model()
+            recent_users = User.objects.select_related().order_by("-date_joined")[:limit]
+
+            return [
+                {
+                    "id": user.id,
+                    "username": user.username,
+                    "email": user.email or "No email",
+                    "date_joined": (
+                        user.date_joined.strftime("%Y-%m-%d %H:%M")
+                        if user.date_joined
+                        else "Unknown"
+                    ),
+                    "is_active": user.is_active,
+                    "is_staff": user.is_staff,
+                    "is_superuser": user.is_superuser,
+                    "last_login": (
+                        user.last_login.strftime("%Y-%m-%d %H:%M")
+                        if user.last_login
+                        else None
+                    ),
+                }
+                for user in recent_users
+            ]
+        except Exception as e:
+            self.logger.error(f"Error getting recent users: {e}")
+            return []
+
     def get_system_metrics(self) -> Dict[str, Any]:
         """
         Get system performance metrics.
@@ -217,19 +339,55 @@ class StatisticsService:
         Returns:
             Dictionary with system metrics (CPU, memory, disk, etc.)
 
-        %%AI_HINT: Can use psutil or similar for real system metrics%%
+        %%AI_HINT: Uses psutil for real system metrics when available%%
         """
         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',
-            }
+            # Try to use psutil for real system metrics
+            try:
+                import psutil
+                import time
+
+                # Get CPU usage
+                cpu_percent = psutil.cpu_percent(interval=0.1)
+
+                # Get memory usage
+                memory = psutil.virtual_memory()
+                memory_percent = memory.percent
+
+                # Get disk usage for root partition
+                disk = psutil.disk_usage('/')
+                disk_percent = disk.percent
+
+                # Get network IO
+                net_io = psutil.net_io_counters()
+
+                # Get system uptime
+                boot_time = psutil.boot_time()
+                uptime_seconds = time.time() - boot_time
+                uptime_days = int(uptime_seconds // 86400)
+                uptime_hours = int((uptime_seconds % 86400) // 3600)
+
+                return {
+                    'cpu_usage': round(cpu_percent, 1),
+                    'memory_usage': round(memory_percent, 1),
+                    'disk_usage': round(disk_percent, 1),
+                    'network_in': f"{net_io.bytes_recv / (1024**2):.1f} MB",
+                    'network_out': f"{net_io.bytes_sent / (1024**2):.1f} MB",
+                    'response_time': '< 100ms',  # Placeholder - can be calculated from middleware
+                    'uptime': f"{uptime_days} days, {uptime_hours} hours",
+                }
+            except ImportError:
+                self.logger.warning("psutil not installed, returning placeholder metrics")
+                # Fallback to placeholder data if psutil not available
+                return {
+                    'cpu_usage': 0,
+                    'memory_usage': 0,
+                    'disk_usage': 0,
+                    'network_in': 'N/A',
+                    'network_out': 'N/A',
+                    'response_time': 'N/A',
+                    'uptime': 'N/A',
+                }
         except Exception as e:
             self.logger.error(f"Error getting system metrics: {e}")
             return {'error': str(e)}

django_cfg/apps/dashboard/urls.py

@@ -1,23 +1,42 @@
 """
 Dashboard URLs
 
-RESTful API endpoints for dashboard data.
-Follows the same pattern as tasks app.
+RESTful API endpoints for dashboard data organized by domain.
+
+API Structure:
+- /api/overview/ - Complete dashboard overview
+- /api/statistics/ - Statistics endpoints (cards, users, apps)
+- /api/system/ - System monitoring (health, metrics)
+- /api/activity/ - Activity tracking (recent, actions)
 """
 
 from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
-from .api.viewsets import DashboardViewSet
+from .views import (
+    OverviewViewSet,
+    StatisticsViewSet,
+    SystemViewSet,
+    ActivityViewSet,
+    ChartsViewSet,
+    CommandsViewSet,
+    APIZonesViewSet,
+)
 
-app_name = 'dashboard'
+app_name = 'django_cfg_dashboard'
 
 # Main router for ViewSets
 router = DefaultRouter()
-router.register(r'', DashboardViewSet, basename='dashboard')
+router.register(r'overview', OverviewViewSet, basename='overview')
+router.register(r'statistics', StatisticsViewSet, basename='statistics')
+router.register(r'system', SystemViewSet, basename='system')
+router.register(r'activity', ActivityViewSet, basename='activity')
+router.register(r'charts', ChartsViewSet, basename='charts')
+router.register(r'commands', CommandsViewSet, basename='commands')
+router.register(r'zones', APIZonesViewSet, basename='zones')
 
 urlpatterns = [
     # RESTful API endpoints using ViewSets
-    # Mounted at cfg/dashboard/api/
+    # Mounted at /cfg/dashboard/api/
     path('api/', include(router.urls)),
 ]

django_cfg/apps/dashboard/views/__init__.py

@@ -0,0 +1,23 @@
+"""
+Dashboard Views
+
+ViewSets organized by domain for better maintainability.
+"""
+
+from .overview_views import OverviewViewSet
+from .statistics_views import StatisticsViewSet
+from .system_views import SystemViewSet
+from .activity_views import ActivityViewSet
+from .charts_views import ChartsViewSet
+from .commands_views import CommandsViewSet
+from .apizones_views import APIZonesViewSet
+
+__all__ = [
+    'OverviewViewSet',
+    'StatisticsViewSet',
+    'SystemViewSet',
+    'ActivityViewSet',
+    'ChartsViewSet',
+    'CommandsViewSet',
+    'APIZonesViewSet',
+]

django_cfg/apps/dashboard/views/activity_views.py

@@ -0,0 +1,83 @@
+"""
+Activity ViewSet
+
+Endpoints for activity tracking:
+- GET /activity/recent/ - Recent activity entries
+- GET /activity/actions/ - Quick action buttons
+"""
+
+import logging
+
+from drf_spectacular.utils import OpenApiParameter, 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 ..services import StatisticsService, SystemHealthService
+from ..serializers import ActivityEntrySerializer, QuickActionSerializer
+
+logger = logging.getLogger(__name__)
+
+
+class ActivityViewSet(viewsets.GenericViewSet):
+    """
+    Activity Tracking ViewSet
+
+    Provides endpoints for recent activity and quick actions.
+    """
+
+    authentication_classes = [SessionAuthentication, BasicAuthentication]
+    permission_classes = [IsAdminUser]
+    serializer_class = ActivityEntrySerializer
+
+    @extend_schema(
+        summary="Get recent activity",
+        description="Retrieve recent system activity entries",
+        parameters=[
+            OpenApiParameter(
+                name='limit',
+                description='Maximum number of entries to return',
+                required=False,
+                type=int,
+                default=10
+            ),
+        ],
+        responses=ActivityEntrySerializer(many=True),
+        tags=["Dashboard - Activity"]
+    )
+    @action(detail=False, methods=['get'], url_path='recent', pagination_class=None, serializer_class=ActivityEntrySerializer)
+    def recent(self, request):
+        """Get recent activity entries."""
+        try:
+            limit = int(request.query_params.get('limit', 10))
+            stats_service = StatisticsService()
+            activity = stats_service.get_recent_activity(limit=limit)
+            return Response(activity)
+
+        except Exception as e:
+            logger.error(f"Recent activity API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get quick actions",
+        description="Retrieve quick action buttons for dashboard",
+        responses=QuickActionSerializer(many=True),
+        tags=["Dashboard - Activity"]
+    )
+    @action(detail=False, methods=['get'], url_path='actions', pagination_class=None, serializer_class=QuickActionSerializer)
+    def actions(self, request):
+        """Get quick action buttons."""
+        try:
+            health_service = SystemHealthService()
+            actions = health_service.get_quick_actions()
+            return Response(actions)
+
+        except Exception as e:
+            logger.error(f"Quick actions API error: {e}")
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)