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

django_cfg/dashboard/components.py

@@ -0,0 +1,308 @@
+"""
+Dashboard Component Classes
+
+Uses Unfold's Component Class system for data preprocessing.
+Separates business logic from presentation templates.
+"""
+
+from typing import Dict, Any
+from unfold.components import BaseComponent, register_component
+
+
+@register_component
+class SystemMetricsComponent(BaseComponent):
+    """
+    System metrics component for dashboard.
+
+    Provides health metrics for database, cache, storage, and API.
+    """
+
+    def get_context_data(self, **kwargs):
+        """Prepare system metrics data."""
+        context = super().get_context_data(**kwargs)
+        context.update({
+            "data": self.get_system_metrics()
+        })
+        return context
+
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """Fetch system health metrics."""
+        from django.db import connection
+        from django.core.cache import cache
+        import shutil
+
+        metrics = {}
+
+        # Database Health
+        try:
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT 1")
+                metrics["database"] = {
+                    "value": 95,
+                    "title": "Database Health",
+                    "description": "Connection successful",
+                }
+        except Exception as e:
+            metrics["database"] = {
+                "value": 0,
+                "title": "Database Health",
+                "description": f"Error: {str(e)[:50]}",
+            }
+
+        # Cache Performance
+        try:
+            cache.set("health_check", "ok", 10)
+            if cache.get("health_check") == "ok":
+                metrics["cache"] = {
+                    "value": 90,
+                    "title": "Cache Performance",
+                    "description": "Cache working properly",
+                }
+            else:
+                metrics["cache"] = {
+                    "value": 50,
+                    "title": "Cache Performance",
+                    "description": "Cache response delayed",
+                }
+        except Exception as e:
+            metrics["cache"] = {
+                "value": 0,
+                "title": "Cache Performance",
+                "description": f"Error: {str(e)[:50]}",
+            }
+
+        # Storage Space
+        try:
+            total, used, free = shutil.disk_usage("/")
+            free_percentage = int((free / total) * 100)
+            usage_percentage = 100 - free_percentage
+
+            metrics["storage"] = {
+                "value": free_percentage,
+                "title": "Disk Space",
+                "description": f"{free_percentage}% free ({usage_percentage}% used)",
+            }
+        except Exception as e:
+            metrics["storage"] = {
+                "value": 0,
+                "title": "Disk Space",
+                "description": f"Error: {str(e)[:50]}",
+            }
+
+        # API Health
+        try:
+            from django.urls import get_resolver
+            resolver = get_resolver()
+            url_patterns = list(resolver.url_patterns)
+
+            metrics["api"] = {
+                "value": 100,
+                "title": "REST API",
+                "description": f"{len(url_patterns)} URL patterns",
+            }
+        except Exception as e:
+            metrics["api"] = {
+                "value": 50,
+                "title": "REST API",
+                "description": "Unable to count URLs",
+            }
+
+        return metrics
+
+
+@register_component
+class RecentUsersComponent(BaseComponent):
+    """
+    Recent users table component.
+
+    Provides formatted table data for displaying recent user registrations.
+    """
+
+    def get_context_data(self, **kwargs):
+        """Prepare recent users table data."""
+        context = super().get_context_data(**kwargs)
+
+        from django.contrib.auth import get_user_model
+        User = get_user_model()
+
+        try:
+            recent_users = User.objects.order_by('-date_joined')[:10]
+
+            context.update({
+                "data": {
+                    "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:
+            context.update({
+                "data": {
+                    "headers": [],
+                    "rows": []
+                }
+            })
+
+        return context
+
+
+@register_component
+class ChartsComponent(BaseComponent):
+    """
+    Charts data component for analytics.
+
+    Provides chart data for user registrations and activity.
+    Supports time range filtering (7/30/90 days).
+    """
+
+    def get_context_data(self, **kwargs):
+        """Prepare charts data."""
+        context = super().get_context_data(**kwargs)
+
+        # Get time range from kwargs (default: 7 days)
+        days = kwargs.get('days', 7)
+
+        from django.contrib.auth import get_user_model
+        from datetime import datetime, timedelta
+        from django.utils import timezone
+        import json
+
+        User = get_user_model()
+
+        try:
+            # Get last N days
+            today = timezone.now().date()
+            dates = [(today - timedelta(days=i)).strftime('%Y-%m-%d')
+                     for i in range(days-1, -1, -1)]
+
+            # User registrations
+            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)
+
+            # User activity (last login)
+            activity = []
+            for date_str in dates:
+                date_obj = datetime.strptime(date_str, '%Y-%m-%d').date()
+                count = User.objects.filter(
+                    last_login__date=date_obj
+                ).count() if hasattr(User, 'last_login') else 0
+                activity.append(count)
+
+            # Format labels
+            day_labels = [d.split('-')[2] for d in dates]
+
+            # 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,
+                }]
+            }
+
+            context.update({
+                "data": {
+                    "registrations": json.dumps(user_reg_data),
+                    "activity": json.dumps(user_activity_data),
+                }
+            })
+        except Exception:
+            context.update({
+                "data": {}
+            })
+
+        return context
+
+
+@register_component
+class ActivityTrackerComponent(BaseComponent):
+    """
+    Activity tracker component for GitHub-style heatmap.
+
+    Provides 365 days of user activity data with level indicators.
+    """
+
+    def get_context_data(self, **kwargs):
+        """Prepare activity tracker data."""
+        context = super().get_context_data(**kwargs)
+
+        from django.contrib.auth import get_user_model
+        from datetime import timedelta
+        from django.utils import timezone
+
+        User = get_user_model()
+
+        try:
+            today = timezone.now().date()
+            activity_data = []
+
+            for days_ago in range(364, -1, -1):  # 365 days
+                date = today - timedelta(days=days_ago)
+
+                # Count registrations
+                registrations = User.objects.filter(
+                    date_joined__date=date
+                ).count()
+
+                # Count logins
+                logins = 0
+                if hasattr(User, 'last_login'):
+                    logins = User.objects.filter(
+                        last_login__date=date
+                    ).count()
+
+                total_activity = registrations + logins
+
+                activity_data.append({
+                    'date': date.isoformat(),
+                    'count': total_activity,
+                    'level': self._get_activity_level(total_activity),
+                })
+
+            context.update({
+                "data": activity_data
+            })
+        except Exception:
+            context.update({
+                "data": []
+            })
+
+        return context
+
+    def _get_activity_level(self, count: int) -> int:
+        """Convert activity count to level (0-4) for heatmap colors."""
+        if count == 0:
+            return 0
+        elif count <= 2:
+            return 1
+        elif count <= 5:
+            return 2
+        elif count <= 10:
+            return 3
+        else:
+            return 4

django_cfg/dashboard/debug.py

@@ -0,0 +1,176 @@
+"""
+Debug utilities for dashboard rendering.
+
+Saves rendered HTML to disk for inspection and comparison.
+"""
+
+import os
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any
+from django.conf import settings
+
+
+class DashboardDebugger:
+    """Save dashboard renders for debugging."""
+
+    def __init__(self, output_dir: Optional[Path] = None):
+        """
+        Initialize debugger.
+
+        Args:
+            output_dir: Directory to save renders (default: django_cfg/debug/dashboard/)
+        """
+        if output_dir is None:
+            # Use django_cfg package directory
+            django_cfg_root = Path(__file__).parent.parent
+            output_dir = django_cfg_root / 'debug' / 'dashboard'
+
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def save_render(
+        self,
+        html: str,
+        name: str = 'dashboard',
+        context: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Path:
+        """
+        Save rendered HTML with metadata.
+
+        Args:
+            html: Rendered HTML content
+            name: Base name for files
+            context: Template context data
+            metadata: Additional metadata
+
+        Returns:
+            Path to saved HTML file
+        """
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        base_name = f"{name}_{timestamp}"
+
+        # Save HTML
+        html_path = self.output_dir / f"{base_name}.html"
+        html_path.write_text(html, encoding='utf-8')
+
+        # Save context as JSON
+        if context:
+            context_path = self.output_dir / f"{base_name}_context.json"
+            # Convert context to JSON-serializable format
+            serializable_context = self._make_serializable(context)
+            context_path.write_text(
+                json.dumps(serializable_context, indent=2, ensure_ascii=False),
+                encoding='utf-8'
+            )
+
+        # Save metadata
+        meta = {
+            'timestamp': timestamp,
+            'name': name,
+            'html_size': len(html),
+            'html_lines': html.count('\n'),
+        }
+
+        if metadata:
+            meta.update(metadata)
+
+        meta_path = self.output_dir / f"{base_name}_meta.json"
+        meta_path.write_text(
+            json.dumps(meta, indent=2, ensure_ascii=False),
+            encoding='utf-8'
+        )
+
+        print(f"✅ Saved dashboard render: {html_path}")
+        print(f"   Context: {context_path if context else 'N/A'}")
+        print(f"   Metadata: {meta_path}")
+
+        return html_path
+
+    def _make_serializable(self, obj: Any) -> Any:
+        """Convert object to JSON-serializable format."""
+        if isinstance(obj, dict):
+            return {k: self._make_serializable(v) for k, v in obj.items()}
+        elif isinstance(obj, (list, tuple)):
+            return [self._make_serializable(item) for item in obj]
+        elif isinstance(obj, (str, int, float, bool, type(None))):
+            return obj
+        else:
+            # For non-serializable objects, use string representation
+            return str(obj)
+
+    def save_section_render(
+        self,
+        section_name: str,
+        html: str,
+        section_data: Optional[Dict[str, Any]] = None
+    ) -> Path:
+        """
+        Save individual section render.
+
+        Args:
+            section_name: Name of section (overview, stats, etc.)
+            html: Rendered HTML
+            section_data: Section-specific data
+
+        Returns:
+            Path to saved file
+        """
+        return self.save_render(
+            html=html,
+            name=f"section_{section_name}",
+            context=section_data,
+            metadata={'section': section_name}
+        )
+
+    def compare_with_archive(self, current_html: str, archive_path: Path) -> Dict[str, Any]:
+        """
+        Compare current render with archived version.
+
+        Args:
+            current_html: Current rendered HTML
+            archive_path: Path to archived HTML
+
+        Returns:
+            Comparison results
+        """
+        if not archive_path.exists():
+            return {
+                'error': f"Archive not found: {archive_path}"
+            }
+
+        archive_html = archive_path.read_text(encoding='utf-8')
+
+        return {
+            'current_size': len(current_html),
+            'archive_size': len(archive_html),
+            'size_diff': len(current_html) - len(archive_html),
+            'current_lines': current_html.count('\n'),
+            'archive_lines': archive_html.count('\n'),
+            'lines_diff': current_html.count('\n') - archive_html.count('\n'),
+            'identical': current_html == archive_html,
+        }
+
+
+# Global instance
+_debugger: Optional[DashboardDebugger] = None
+
+
+def get_debugger() -> DashboardDebugger:
+    """Get or create global debugger instance."""
+    global _debugger
+    if _debugger is None:
+        _debugger = DashboardDebugger()
+    return _debugger
+
+
+def save_dashboard_render(html: str, **kwargs) -> Path:
+    """Convenience function to save dashboard render."""
+    return get_debugger().save_render(html, **kwargs)
+
+
+def save_section_render(section_name: str, html: str, **kwargs) -> Path:
+    """Convenience function to save section render."""
+    return get_debugger().save_section_render(section_name, html, **kwargs)

django_cfg/dashboard/management/commands/debug_dashboard.py

@@ -0,0 +1,109 @@
+"""
+Management command to debug dashboard rendering.
+
+Renders all dashboard sections and saves them for inspection.
+"""
+
+from django.core.management.base import BaseCommand
+from django.test import RequestFactory
+from django.contrib.auth import get_user_model
+
+from django_cfg.dashboard.sections.overview import OverviewSection
+from django_cfg.dashboard.sections.stats import StatsSection
+from django_cfg.dashboard.sections.system import SystemSection
+from django_cfg.dashboard.sections.commands import CommandsSection
+from django_cfg.dashboard.debug import get_debugger
+
+
+class Command(BaseCommand):
+    help = "Debug dashboard rendering - saves all sections to disk"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--section',
+            type=str,
+            choices=['overview', 'stats', 'system', 'commands', 'all'],
+            default='all',
+            help='Which section to render (default: all)'
+        )
+        parser.add_argument(
+            '--user',
+            type=str,
+            help='Username to use for request (default: first superuser)'
+        )
+
+    def handle(self, *args, **options):
+        # Create mock request
+        factory = RequestFactory()
+        request = factory.get('/admin/')
+
+        # Get user for request
+        User = get_user_model()
+        username = options.get('user')
+
+        if username:
+            try:
+                user = User.objects.get(username=username)
+            except User.DoesNotExist:
+                self.stdout.write(
+                    self.style.ERROR(f"User '{username}' not found")
+                )
+                return
+        else:
+            # Use first superuser
+            user = User.objects.filter(is_superuser=True).first()
+            if not user:
+                self.stdout.write(
+                    self.style.WARNING("No superuser found, using anonymous request")
+                )
+
+        if user:
+            request.user = user
+            self.stdout.write(f"Using user: {user.username}")
+
+        # Get debugger
+        debugger = get_debugger()
+        self.stdout.write(f"Saving renders to: {debugger.output_dir}")
+
+        section_choice = options['section']
+        sections = {
+            'overview': OverviewSection,
+            'stats': StatsSection,
+            'system': SystemSection,
+            'commands': CommandsSection,
+        }
+
+        if section_choice == 'all':
+            sections_to_render = sections.items()
+        else:
+            sections_to_render = [(section_choice, sections[section_choice])]
+
+        # Render sections
+        for name, SectionClass in sections_to_render:
+            self.stdout.write(f"\nRendering {name} section...")
+
+            try:
+                section = SectionClass(request)
+                html = section.render()
+
+                # Save render
+                path = debugger.save_section_render(
+                    section_name=name,
+                    html=html,
+                    section_data=section.get_context_data() if hasattr(section, 'get_context_data') else None
+                )
+
+                self.stdout.write(
+                    self.style.SUCCESS(f"✅ {name}: {len(html)} bytes, saved to {path.name}")
+                )
+
+            except Exception as e:
+                self.stdout.write(
+                    self.style.ERROR(f"❌ {name}: {e}")
+                )
+                import traceback
+                traceback.print_exc()
+
+        self.stdout.write(
+            self.style.SUCCESS(f"\n✅ Done! Check renders in: {debugger.output_dir}")
+        )

django_cfg/dashboard/sections/__init__.py

@@ -0,0 +1 @@
+"""Dashboard sections package."""