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

django_cfg/apps/dashboard/services/statistics_service.py

@@ -0,0 +1,393 @@
+"""
+Statistics Service
+
+Collects and aggregates statistics for dashboard display.
+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__)
+
+
+class StatisticsService:
+    """
+    Service for collecting dashboard statistics.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: This service collects data from various Django models using ORM%%
+
+    TAGS: statistics, dashboard, service
+    """
+
+    def __init__(self):
+        """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.
+
+        Returns:
+            Dictionary containing user stats:
+            - total_users: Total number of users
+            - active_users: Number of active users
+            - new_users: New users in last 7 days
+            - superusers: Number of superusers
+
+        %%AI_HINT: Uses real Django ORM queries from User model%%
+        """
+        try:
+            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': 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}")
+            return {
+                'total_users': 0,
+                'active_users': 0,
+                'new_users': 0,
+                'superusers': 0,
+                'error': str(e)
+            }
+
+    def get_app_statistics(self) -> Dict[str, Any]:
+        """
+        Get application-specific statistics.
+
+        Returns:
+            Dictionary with aggregated app statistics.
+            {
+                'apps': {app_label: {...stats...}},
+                'total_records': int,
+                'total_models': int,
+                'total_apps': int
+            }
+
+        %%AI_HINT: Real app introspection using Django apps registry%%
+        """
+        try:
+            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 {'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]]:
+        """
+        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
+        %%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': f"{total_users:,}",
+                    'icon': 'people',
+                    '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': f"{active_users:,}",
+                    'icon': 'person',
+                    '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 This Week',
+                    'value': f"{new_users_7d:,}",
+                    'icon': 'person_add',
+                    'change_type': 'positive' if new_users_7d > 0 else 'neutral',
+                    'color': 'info',
+                    'description': 'Last 7 days',
+                },
+                {
+                    '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',
+                },
+            ]
+
+            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: Returns placeholder - connect to django-auditlog when available%%
+        """
+        try:
+            # Note: This is a placeholder. Real implementation should connect to:
+            # - django-auditlog (if installed)
+            # - Custom activity/history tracking
+            # - Django admin logs (LogEntry model)
+
+            # 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]
+
+            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.
+
+        Returns:
+            Dictionary with system metrics (CPU, memory, disk, etc.)
+
+        %%AI_HINT: Uses psutil for real system metrics when available%%
+        """
+        try:
+            # 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/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