django-cfg 1.3.13__py3-none-any.whl → 1.4.3__py3-none-any.whl

django_cfg/dashboard/sections/base.py

@@ -0,0 +1,128 @@
+"""
+Base dashboard section classes.
+
+Provides foundation for dashboard sections following Unfold's pattern.
+"""
+
+from typing import Dict, Any, Optional
+from django.http import HttpRequest
+from django.template.loader import render_to_string
+
+
+class DashboardSection:
+    """
+    Base class for dashboard sections.
+
+    Each section is responsible for:
+    - Data collection
+    - Context preparation
+    - Template rendering
+
+    Usage:
+        class MySection(DashboardSection):
+            template_name = "admin/sections/my_section.html"
+
+            def get_context_data(self, **kwargs):
+                context = super().get_context_data(**kwargs)
+                context['custom_data'] = self.get_custom_data()
+                return context
+    """
+
+    template_name: Optional[str] = None
+    title: Optional[str] = None
+    icon: Optional[str] = None
+
+    def __init__(self, request: HttpRequest) -> None:
+        """Initialize section with request context."""
+        self.request = request
+
+    def get_context_data(self, **kwargs) -> Dict[str, Any]:
+        """
+        Get context data for template rendering.
+
+        Override this method to add custom context.
+        """
+        context = {
+            'request': self.request,
+            'section': self,
+        }
+
+        if self.title:
+            context['title'] = self.title
+
+        if self.icon:
+            context['icon'] = self.icon
+
+        context.update(kwargs)
+        return context
+
+    def render(self, **kwargs) -> str:
+        """
+        Render the section template.
+
+        Args:
+            **kwargs: Additional context to pass to template
+
+        Returns:
+            Rendered HTML string
+        """
+        if not self.template_name:
+            raise NotImplementedError(
+                f"{self.__class__.__name__} must define 'template_name' or override render()"
+            )
+
+        context = self.get_context_data(**kwargs)
+        return render_to_string(self.template_name, context=context, request=self.request)
+
+    def __str__(self) -> str:
+        """String representation."""
+        return self.title or self.__class__.__name__
+
+
+class DataSection(DashboardSection):
+    """
+    Section that provides data-driven content.
+
+    Extend this for sections that need to fetch and process data.
+    """
+
+    def get_data(self) -> Any:
+        """
+        Get section data.
+
+        Override this to provide section-specific data.
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__} must implement get_data()"
+        )
+
+    def get_context_data(self, **kwargs) -> Dict[str, Any]:
+        """Add data to context."""
+        context = super().get_context_data(**kwargs)
+        context['data'] = self.get_data()
+        return context
+
+
+class CardSection(DashboardSection):
+    """
+    Section rendered as a card component.
+
+    Automatically wraps content in card template.
+    """
+
+    template_name = "admin/components/card.html"
+    content_template: Optional[str] = None
+
+    def get_context_data(self, **kwargs) -> Dict[str, Any]:
+        """Add card-specific context."""
+        context = super().get_context_data(**kwargs)
+
+        # Render content if content_template is provided
+        if self.content_template:
+            context['content'] = render_to_string(
+                self.content_template,
+                context=context,
+                request=self.request
+            )
+
+        return context

django_cfg/dashboard/sections/commands.py

@@ -0,0 +1,32 @@
+"""Commands section for dashboard."""
+
+from typing import Dict, Any, List
+from .base import DataSection
+
+
+class CommandsSection(DataSection):
+    """
+    Management commands section.
+    """
+
+    template_name = "admin/sections/commands_section.html"
+    title = "Management Commands"
+    icon = "terminal"
+
+    def get_data(self) -> Dict[str, Any]:
+        """Get commands data."""
+        from django_cfg.modules.django_unfold.callbacks.base import (
+            get_available_commands,
+            get_commands_by_category
+        )
+
+        commands = get_available_commands()
+        categorized = get_commands_by_category()
+
+        return {
+            'commands': commands,
+            'categories': categorized,
+            'total_commands': len(commands),
+            'core_commands': len([cmd for cmd in commands if cmd.get('is_core')]),
+            'custom_commands': len([cmd for cmd in commands if cmd.get('is_custom')]),
+        }

django_cfg/dashboard/sections/overview.py

@@ -0,0 +1,394 @@
+"""Overview section for dashboard."""
+
+from typing import Dict, Any, List
+from .base import DataSection
+
+
+class OverviewSection(DataSection):
+    """
+    Overview section showing key metrics and system status.
+    """
+
+    template_name = "admin/sections/overview_section.html"
+    title = "System Overview"
+    icon = "dashboard"
+
+    def get_data(self) -> Dict[str, Any]:
+        """Get overview data."""
+        from django_cfg.core.config import get_current_config
+
+        config = get_current_config()
+
+        return {
+            'stats': self.get_key_stats(),
+            'system_health': self.get_system_health(),
+            'recent_activity': self.get_recent_activity(),
+        }
+
+    def get_context_data(self, **kwargs) -> Dict[str, Any]:
+        """Add additional context for includes."""
+        import json
+        from django.utils.safestring import mark_safe
+
+        context = super().get_context_data(**kwargs)
+
+        # Get time range from kwargs (default: 7 days)
+        time_range = kwargs.get('time_range', 7)
+
+        # Add data needed by included components
+        context['system_metrics'] = self.get_system_metrics()
+        context['recent_users'] = self.get_recent_users()
+        context['recent_users_table'] = self.get_recent_users_table()
+
+        # Convert activity tracker to JSON for JavaScript
+        activity_data = self.get_activity_tracker()
+        context['activity_tracker'] = mark_safe(json.dumps(activity_data))
+
+        context['charts'] = self.get_charts_data(days=time_range)
+
+        # Quick actions come from kwargs (passed from callbacks)
+        if 'quick_actions' in kwargs:
+            context['quick_actions'] = kwargs['quick_actions']
+
+        # Navigation for time range filter
+        if 'navigation' in kwargs:
+            context['navigation'] = kwargs['navigation']
+
+        return context
+
+    def get_key_stats(self) -> Dict[str, Any]:
+        """Get key statistics."""
+        from django.contrib.auth import get_user_model
+        from django.db import connection
+
+        User = get_user_model()
+
+        # Get database count
+        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,
+        }
+
+    def get_system_health(self) -> Dict[str, Any]:
+        """Get system health metrics."""
+        import sys
+        import psutil
+
+        return {
+            'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            'cpu_percent': psutil.cpu_percent(interval=0.1),
+            'memory_percent': psutil.virtual_memory().percent,
+            'disk_percent': psutil.disk_usage('/').percent,
+        }
+
+    def get_recent_activity(self) -> list:
+        """Get recent activity items."""
+        # TODO: Implement activity tracking
+        return []
+
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """Get system metrics for progress bars."""
+        from django.db import connection
+        from django.core.cache import cache
+
+        metrics = {}
+
+        # Database metrics
+        try:
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT 1")
+                metrics["database"] = {
+                    "status": "healthy",
+                    "type": connection.settings_dict.get('ENGINE', 'Unknown').split('.')[-1],
+                    "health_percentage": 95,
+                    "description": "Connection successful",
+                }
+        except Exception as e:
+            metrics["database"] = {
+                "status": "error",
+                "type": "Database",
+                "health_percentage": 0,
+                "description": f"Connection failed: {str(e)[:50]}",
+            }
+
+        # Cache metrics
+        try:
+            cache.set("health_check", "ok", 10)
+            cache_result = cache.get("health_check")
+            if cache_result == "ok":
+                metrics["cache"] = {
+                    "status": "healthy",
+                    "type": "Memory Cache",
+                    "health_percentage": 90,
+                    "description": "Cache working properly",
+                }
+            else:
+                metrics["cache"] = {
+                    "status": "warning",
+                    "type": "Memory Cache",
+                    "health_percentage": 50,
+                    "description": "Cache response delayed",
+                }
+        except Exception as e:
+            metrics["cache"] = {
+                "status": "error",
+                "type": "Memory Cache",
+                "health_percentage": 0,
+                "description": f"Cache error: {str(e)[:50]}",
+            }
+
+        # Storage metrics
+        try:
+            import shutil
+            total, used, free = shutil.disk_usage("/")
+            usage_percentage = (used / total) * 100
+            free_percentage = 100 - usage_percentage
+
+            # Status based on free space
+            if free_percentage > 20:
+                status = "healthy"
+            elif free_percentage > 10:
+                status = "warning"
+            else:
+                status = "error"
+
+            metrics["storage"] = {
+                "status": status,
+                "type": "Disk Space",
+                "health_percentage": int(free_percentage),  # Show free space percentage
+                "description": f"{free_percentage:.1f}% free ({usage_percentage:.1f}% used)",
+            }
+        except Exception as e:
+            metrics["storage"] = {
+                "status": "error",
+                "type": "Disk Space",
+                "health_percentage": 0,
+                "description": f"Check failed: {str(e)[:50]}",
+            }
+
+        # API metrics
+        try:
+            from django.urls import get_resolver
+            resolver = get_resolver()
+            url_patterns = list(resolver.url_patterns)
+
+            metrics["api"] = {
+                "status": "healthy",
+                "type": "REST API",
+                "health_percentage": 100,
+                "description": f"{len(url_patterns)} URL patterns",
+            }
+        except Exception as e:
+            metrics["api"] = {
+                "status": "warning",
+                "type": "REST API",
+                "health_percentage": 50,
+                "description": "Unable to count URLs",
+            }
+
+        return metrics
+
+    def get_recent_users(self) -> List[Dict[str, Any]]:
+        """Get recent users for activity section."""
+        from django.contrib.auth import get_user_model
+
+        User = get_user_model()
+
+        try:
+            recent_users = User.objects.order_by('-date_joined')[:5]
+            return list(recent_users.values(
+                'id', 'username', 'email', 'is_active', 'date_joined'
+            ))
+        except Exception:
+            return []
+
+    def get_recent_users_table(self) -> Dict[str, Any]:
+        """Get recent users in table format for Unfold table component."""
+        from django.contrib.auth import get_user_model
+
+        User = get_user_model()
+
+        try:
+            recent_users = User.objects.order_by('-date_joined')[:10]
+
+            return {
+                "headers": ["Username", "Email", "Status", "Staff", "Joined"],
+                "rows": [
+                    [
+                        user.username,
+                        user.email,
+                        "✅ Active" if user.is_active else "❌ Inactive",
+                        "🛡️ Yes" if user.is_staff else "—",
+                        user.date_joined.strftime('%Y-%m-%d %H:%M')
+                    ]
+                    for user in recent_users
+                ]
+            }
+        except Exception:
+            return {"headers": [], "rows": []}
+
+    def get_activity_tracker(self) -> List[Dict[str, Any]]:
+        """
+        Get activity tracker data for GitHub-style heatmap.
+
+        Returns list of dicts with date and count for last 365 days.
+        """
+        from django.contrib.auth import get_user_model
+        from datetime import datetime, timedelta
+        from django.utils import timezone
+
+        User = get_user_model()
+
+        try:
+            # Get activity for last 365 days
+            today = timezone.now().date()
+            activity_data = []
+
+            for days_ago in range(364, -1, -1):  # 365 days, 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:
+            # Return empty on error
+            return []
+
+    def _get_activity_level(self, count: int) -> int:
+        """
+        Convert activity count to level (0-4) for heatmap colors.
+
+        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_charts_data(self, days: int = 7) -> Dict[str, Any]:
+        """Get charts data for Analytics Overview.
+
+        Args:
+            days: Number of days to include in charts (default: 7)
+        """
+        from django.contrib.auth import get_user_model
+        from datetime import datetime, timedelta
+        from django.utils import timezone
+        from django.utils.safestring import mark_safe
+        import json
+
+        User = get_user_model()
+
+        try:
+            # Get last N days of user registrations
+            today = timezone.now().date()
+            dates = [(today - timedelta(days=i)).strftime('%Y-%m-%d') for i in range(days-1, -1, -1)]
+
+            # Count users registered each day
+            registrations = []
+            for date_str in dates:
+                date_obj = datetime.strptime(date_str, '%Y-%m-%d').date()
+                count = User.objects.filter(
+                    date_joined__date=date_obj
+                ).count()
+                registrations.append(count)
+
+            # Count active users each day (last login)
+            activity = []
+            for date_str in dates:
+                date_obj = datetime.strptime(date_str, '%Y-%m-%d').date()
+                # Count users who logged in that day
+                count = User.objects.filter(
+                    last_login__date=date_obj
+                ).count() if hasattr(User, 'last_login') else 0
+                activity.append(count)
+
+            # Format for charts
+            day_labels = [d.split('-')[2] for d in dates]  # Just day numbers
+
+            # Prepare chart data structures
+            user_reg_data = {
+                'labels': day_labels,
+                'datasets': [{
+                    'label': 'New Users',
+                    'data': registrations,
+                    'backgroundColor': 'rgba(59, 130, 246, 0.5)',
+                    'borderColor': 'rgb(59, 130, 246)',
+                    'borderWidth': 2,
+                }]
+            }
+
+            user_activity_data = {
+                'labels': day_labels,
+                'datasets': [{
+                    'label': 'Active Users',
+                    'data': activity,
+                    'backgroundColor': 'rgba(34, 197, 94, 0.5)',
+                    'borderColor': 'rgb(34, 197, 94)',
+                    'borderWidth': 2,
+                }]
+            }
+
+            return {
+                # User Registrations chart
+                'user_registrations': {
+                    'labels': day_labels,
+                    'datasets': [{
+                        'label': 'New Users',
+                        'data': registrations,
+                    }]
+                },
+                # JSON string for Unfold chart component (NO mark_safe - let Django escape quotes)
+                'user_registrations_json': json.dumps(user_reg_data),
+
+                # User Activity chart
+                'user_activity': {
+                    'labels': day_labels,
+                    'datasets': [{
+                        'label': 'Active Users',
+                        'data': activity,
+                    }]
+                },
+                # JSON string for Unfold chart component (NO mark_safe - let Django escape quotes)
+                'user_activity_json': json.dumps(user_activity_data),
+            }
+        except Exception as e:
+            # Return empty chart data
+            return {}

django_cfg/dashboard/sections/stats.py

@@ -0,0 +1,48 @@
+"""Statistics section for dashboard."""
+
+from typing import Dict, Any, List
+from .base import DataSection
+
+
+class StatsSection(DataSection):
+    """
+    Statistics section showing detailed metrics.
+    """
+
+    template_name = "admin/sections/stats_section.html"
+    title = "Statistics"
+    icon = "analytics"
+
+    def get_data(self) -> Dict[str, Any]:
+        """Get statistics data."""
+        return {
+            'app_stats': self.get_app_stats(),
+            'time_series': self.get_time_series(),
+        }
+
+    def get_app_stats(self) -> List[Dict[str, Any]]:
+        """Get per-app statistics."""
+        from django.apps import apps
+        from django.contrib.contenttypes.models import ContentType
+
+        stats = []
+
+        for app_config in apps.get_app_configs():
+            if app_config.name.startswith('django.'):
+                continue
+
+            # Count models in app
+            models = [m for m in apps.get_models() if m._meta.app_label == app_config.label]
+
+            stats.append({
+                'name': app_config.verbose_name,
+                'label': app_config.label,
+                'models_count': len(models),
+            })
+
+        return stats
+
+    def get_time_series(self) -> Dict[str, Any]:
+        """Get time series data for charts."""
+        # TODO: Implement time series data
+        return {}

django_cfg/dashboard/sections/system.py

@@ -0,0 +1,73 @@
+"""System section for dashboard."""
+
+from typing import Dict, Any
+from .base import DataSection
+
+
+class SystemSection(DataSection):
+    """
+    System management section.
+    """
+
+    template_name = "admin/sections/system_section.html"
+    title = "System Management"
+    icon = "settings"
+
+    def get_data(self) -> Dict[str, Any]:
+        """Get system data."""
+        return {
+            'health': self.get_health_check(),
+            'services': self.get_services_status(),
+            'configuration': self.get_configuration(),
+        }
+
+    def get_health_check(self) -> Dict[str, Any]:
+        """Get health check status."""
+        import psutil
+
+        return {
+            'status': 'healthy',
+            'checks': {
+                'database': self.check_database(),
+                'cache': self.check_cache(),
+                'disk_space': psutil.disk_usage('/').percent < 90,
+                'memory': psutil.virtual_memory().percent < 90,
+            }
+        }
+
+    def check_database(self) -> bool:
+        """Check database connectivity."""
+        from django.db import connection
+
+        try:
+            connection.ensure_connection()
+            return True
+        except Exception:
+            return False
+
+    def check_cache(self) -> bool:
+        """Check cache availability."""
+        from django.core.cache import cache
+
+        try:
+            cache.set('health_check', True, 1)
+            return cache.get('health_check') is True
+        except Exception:
+            return False
+
+    def get_services_status(self) -> Dict[str, Any]:
+        """Get services status."""
+        # TODO: Implement services status check
+        return {}
+
+    def get_configuration(self) -> Dict[str, Any]:
+        """Get system configuration."""
+        from django_cfg.core.config import get_current_config
+
+        config = get_current_config()
+
+        return {
+            'debug': config.debug,
+            'env_mode': config.env_mode,
+            'project_name': config.project_name,
+        }