django-cfg 1.2.6__py3-none-any.whl → 1.2.8__py3-none-any.whl

django_cfg/modules/django_unfold/callbacks/commands.py

@@ -0,0 +1,40 @@
+"""
+Django commands callbacks.
+"""
+
+import logging
+from typing import Dict, Any
+
+from .base import get_available_commands, get_commands_by_category
+
+logger = logging.getLogger(__name__)
+
+
+class CommandsCallbacks:
+    """Django commands callbacks."""
+    
+    def get_django_commands(self) -> Dict[str, Any]:
+        """Get Django management commands information."""
+        try:
+            commands = get_available_commands()
+            categorized = get_commands_by_category()
+
+            return {
+                "commands": commands,
+                "categorized": categorized,
+                "total_commands": len(commands),
+                "categories": list(categorized.keys()),
+                "core_commands": len([cmd for cmd in commands if cmd['is_core']]),
+                "custom_commands": len([cmd for cmd in commands if cmd['is_custom']]),
+            }
+        except Exception as e:
+            logger.error(f"Error getting Django commands: {e}")
+            # Return safe fallback to prevent dashboard from breaking
+            return {
+                "commands": [],
+                "categorized": {},
+                "total_commands": 0,
+                "categories": [],
+                "core_commands": 0,
+                "custom_commands": 0,
+            }

django_cfg/modules/django_unfold/callbacks/main.py

@@ -0,0 +1,191 @@
+"""
+Main Unfold Dashboard Callbacks
+
+Combines all callback modules into a single interface.
+"""
+
+import logging
+import json
+from typing import Dict, Any
+
+from django.utils import timezone
+from django.conf import settings
+
+from ...base import BaseCfgModule
+from ..models.dashboard import DashboardData
+
+from .statistics import StatisticsCallbacks
+from .system import SystemCallbacks
+from .actions import ActionsCallbacks
+from .charts import ChartsCallbacks
+from .commands import CommandsCallbacks
+from .revolution import RevolutionCallbacks
+from .users import UsersCallbacks
+from .base import get_user_admin_urls
+
+logger = logging.getLogger(__name__)
+
+
+class UnfoldCallbacks(
+    BaseCfgModule,
+    StatisticsCallbacks,
+    SystemCallbacks,
+    ActionsCallbacks,
+    ChartsCallbacks,
+    CommandsCallbacks,
+    RevolutionCallbacks,
+    UsersCallbacks
+):
+    """
+    Main Unfold dashboard callbacks with full system monitoring.
+    
+    Combines all callback modules using multiple inheritance for
+    clean separation of concerns while maintaining a single interface.
+    """
+    
+    def main_dashboard_callback(self, request, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Main dashboard callback function with comprehensive system data.
+
+        Returns all dashboard data as Pydantic models for type safety.
+        """
+        try:
+            # Get dashboard data using Pydantic models
+            user_stats = self.get_user_statistics()
+            support_stats = self.get_support_statistics()
+            system_health = self.get_system_health()
+            quick_actions = self.get_quick_actions()
+            
+            # Combine all stat cards
+            all_stats = user_stats + support_stats
+
+            dashboard_data = DashboardData(
+                stat_cards=all_stats,
+                system_health=system_health,
+                quick_actions=quick_actions,
+                last_updated=timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
+                environment=getattr(settings, "ENVIRONMENT", "development"),
+            )
+
+            # Convert to template context (using to_dict for Unfold compatibility)
+            cards_data = [card.to_dict() for card in dashboard_data.stat_cards]
+
+            context.update({
+                # Statistics cards
+                "cards": cards_data,
+                "user_stats": [card.to_dict() for card in user_stats],
+                "support_stats": [card.to_dict() for card in support_stats],
+                
+                # System health (convert to dict for template)
+                "system_health": {
+                    item.component + "_status": item.status
+                    for item in dashboard_data.system_health
+                },
+                
+                # System metrics
+                "system_metrics": self.get_system_metrics(),
+                
+                # Quick actions
+                "quick_actions": [
+                    action.model_dump() for action in dashboard_data.quick_actions
+                ],
+                
+                # Additional categorized actions
+                "admin_actions": [
+                    action.model_dump()
+                    for action in dashboard_data.quick_actions
+                    if action.category == "admin"
+                ],
+                "support_actions": [
+                    action.model_dump()
+                    for action in dashboard_data.quick_actions
+                    if action.category == "support"
+                ],
+                "system_actions": [
+                    action.model_dump()
+                    for action in dashboard_data.quick_actions
+                    if action.category == "system"
+                ],
+                
+                # Revolution zones
+                "zones_table": {
+                    "headers": [
+                        {"label": "Zone"},
+                        {"label": "Title"},
+                        {"label": "Apps"},
+                        {"label": "Endpoints"},
+                        {"label": "Status"},
+                        {"label": "Actions"},
+                    ],
+                    "rows": self.get_revolution_zones_data()[0],
+                },
+                
+                # Recent users
+                "recent_users": self.get_recent_users(),
+                "user_admin_urls": get_user_admin_urls(),
+                
+                # App statistics
+                "app_statistics": self.get_app_statistics(),
+                
+                # Django commands
+                "django_commands": self.get_django_commands(),
+                
+                   # Charts data - serialize to JSON for JavaScript
+                   "charts": {
+                       "user_registrations_json": json.dumps(self.get_user_registration_chart_data()),
+                       "user_activity_json": json.dumps(self.get_user_activity_chart_data()),
+                       "user_registrations": self.get_user_registration_chart_data(),
+                       "user_activity": self.get_user_activity_chart_data(),
+                   },
+                   
+                   # Activity tracker data
+                   "activity_tracker": self.get_activity_tracker_data(),
+                
+                
+                # Meta information
+                "last_updated": dashboard_data.last_updated,
+                "environment": dashboard_data.environment,
+                "dashboard_title": "Django CFG Dashboard",
+            })
+
+            # Log charts data for debugging
+            charts_data = context.get('charts', {})
+            logger.info(f"Charts data added to context: {list(charts_data.keys())}")
+            if 'user_registrations' in charts_data:
+                reg_data = charts_data['user_registrations']
+                logger.info(f"Registration chart labels: {reg_data.get('labels', [])}")
+            if 'user_activity' in charts_data:
+                act_data = charts_data['user_activity']
+                logger.info(f"Activity chart labels: {act_data.get('labels', [])}")
+            
+            # Log recent users data for debugging
+            recent_users_data = context.get('recent_users', [])
+            logger.info(f"Recent users data count: {len(recent_users_data)}")
+            if recent_users_data:
+                logger.info(f"First user: {recent_users_data[0].get('username', 'N/A')}")
+            
+            # Log activity tracker data for debugging
+            activity_tracker_data = context.get('activity_tracker', [])
+            logger.info(f"Activity tracker data count: {len(activity_tracker_data)}")
+
+            return context
+
+        except Exception as e:
+            logger.error(f"Dashboard callback error: {e}")
+            # Return minimal safe defaults
+            context.update({
+                "cards": [
+                    {
+                        "title": "System Error",
+                        "value": "N/A",
+                        "icon": "error",
+                        "color": "danger",
+                        "description": "Dashboard data unavailable"
+                    }
+                ],
+                "system_health": {},
+                "quick_actions": [],
+                "last_updated": timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "error": f"Dashboard error: {str(e)}",
+            })
+            return context

django_cfg/modules/django_unfold/callbacks/revolution.py

@@ -0,0 +1,76 @@
+"""
+Django Revolution integration callbacks.
+"""
+
+import logging
+from typing import Dict, Any, List, Tuple
+
+from django.conf import settings
+
+logger = logging.getLogger(__name__)
+
+
+class RevolutionCallbacks:
+    """Django Revolution integration callbacks."""
+    
+    def get_revolution_zones_data(self) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        """Get Django Revolution zones data."""
+        try:
+            # Try to get revolution config from Django settings
+            revolution_config = getattr(settings, "DJANGO_REVOLUTION", {})
+            zones = revolution_config.get("zones", {})
+            api_prefix = revolution_config.get("api_prefix", "apix")
+
+            zones_data = []
+            total_apps = 0
+            total_endpoints = 0
+
+            for zone_name, zone_config in zones.items():
+                # Handle both dict and object access
+                if isinstance(zone_config, dict):
+                    title = zone_config.get("title", zone_name.title())
+                    description = zone_config.get("description", f"{zone_name} zone")
+                    apps = zone_config.get("apps", [])
+                    public = zone_config.get("public", False)
+                    auth_required = zone_config.get("auth_required", True)
+                else:
+                    # Handle object access (for ZoneConfig instances)
+                    title = getattr(zone_config, "title", zone_name.title())
+                    description = getattr(zone_config, "description", f"{zone_name} zone")
+                    apps = getattr(zone_config, "apps", [])
+                    public = getattr(zone_config, "public", False)
+                    auth_required = getattr(zone_config, "auth_required", True)
+
+                # Count actual endpoints by checking URL patterns (simplified estimate)
+                endpoint_count = len(apps) * 3  # Conservative estimate
+
+                zones_data.append({
+                    "name": zone_name,
+                    "title": title,
+                    "description": description,
+                    "app_count": len(apps),
+                    "endpoint_count": endpoint_count,
+                    "status": "active",
+                    "public": public,
+                    "auth_required": auth_required,
+                    "schema_url": f"/schema/{zone_name}/schema/",
+                    "swagger_url": f"/schema/{zone_name}/schema/swagger/",
+                    "redoc_url": f"/schema/{zone_name}/redoc/",
+                    "api_url": f"/{api_prefix}/{zone_name}/",
+                })
+
+                total_apps += len(apps)
+                total_endpoints += endpoint_count
+
+            return zones_data, {
+                "total_apps": total_apps,
+                "total_endpoints": total_endpoints,
+                "total_zones": len(zones),
+            }
+        except Exception as e:
+            logger.error(f"Error getting revolution zones: {e}")
+            return [], {
+                "total_apps": 0,
+                "total_endpoints": 0,
+                "total_zones": 0,
+            }

django_cfg/modules/django_unfold/callbacks/statistics.py

@@ -0,0 +1,240 @@
+"""
+Statistics callbacks for dashboard.
+"""
+
+import logging
+from typing import List, Dict, Any
+from datetime import timedelta
+
+from django.db.models import Count
+from django.utils import timezone
+from django.contrib.auth import get_user_model
+from django.apps import apps
+
+from ..models.dashboard import StatCard
+from ..icons import Icons
+
+logger = logging.getLogger(__name__)
+
+
+class StatisticsCallbacks:
+    """Statistics-related callbacks."""
+    
+    def _get_user_model(self):
+        """Get the user model safely."""
+        return get_user_model()
+    
+    def get_user_statistics(self) -> List[StatCard]:
+        """Get user-related statistics as Pydantic models."""
+        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()
+            staff_users = User.objects.filter(is_staff=True).count()
+
+            return [
+                StatCard(
+                    title="Total Users",
+                    value=f"{total_users:,}",
+                    icon=Icons.PEOPLE,
+                    change=f"+{new_users_7d}" if new_users_7d > 0 else None,
+                    change_type="positive" if new_users_7d > 0 else "neutral",
+                    description="Registered users",
+                ),
+                StatCard(
+                    title="Active Users",
+                    value=f"{active_users:,}",
+                    icon=Icons.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"
+                    ),
+                    description="Currently active",
+                ),
+                StatCard(
+                    title="New This Week",
+                    value=f"{new_users_7d:,}",
+                    icon=Icons.PERSON_ADD,
+                    change_type="positive" if new_users_7d > 0 else "neutral",
+                    description="Last 7 days",
+                ),
+                StatCard(
+                    title="Staff Members",
+                    value=f"{staff_users:,}",
+                    icon=Icons.ADMIN_PANEL_SETTINGS,
+                    change=(
+                        f"{(staff_users/total_users*100):.1f}%" if total_users > 0 else "0%"
+                    ),
+                    change_type="neutral",
+                    description="Administrative access",
+                ),
+            ]
+        except Exception as e:
+            logger.error(f"Error getting user statistics: {e}")
+            return [
+                StatCard(
+                    title="Users",
+                    value="N/A",
+                    icon=Icons.PEOPLE,
+                    description="Data unavailable",
+                )
+            ]
+
+    def get_support_statistics(self) -> List[StatCard]:
+        """Get support ticket statistics as Pydantic models."""
+        try:
+            # Check if support is enabled
+            if not self.is_support_enabled():
+                return []
+                
+            from django_cfg.apps.support.models import Ticket
+            
+            total_tickets = Ticket.objects.count()
+            open_tickets = Ticket.objects.filter(status='open').count()
+            resolved_tickets = Ticket.objects.filter(status='resolved').count()
+            new_tickets_7d = Ticket.objects.filter(
+                created_at__gte=timezone.now() - timedelta(days=7)
+            ).count()
+            
+            return [
+                StatCard(
+                    title="Total Tickets",
+                    value=f"{total_tickets:,}",
+                    icon=Icons.SUPPORT_AGENT,
+                    change=f"+{new_tickets_7d}" if new_tickets_7d > 0 else None,
+                    change_type="positive" if new_tickets_7d > 0 else "neutral",
+                    description="All support tickets",
+                ),
+                StatCard(
+                    title="Open Tickets",
+                    value=f"{open_tickets:,}",
+                    icon=Icons.PENDING,
+                    change=(
+                        f"{(open_tickets/total_tickets*100):.1f}%"
+                        if total_tickets > 0
+                        else "0%"
+                    ),
+                    change_type=(
+                        "negative" if open_tickets > total_tickets * 0.3 
+                        else "positive" if open_tickets == 0 
+                        else "neutral"
+                    ),
+                    description="Awaiting response",
+                ),
+                StatCard(
+                    title="Resolved",
+                    value=f"{resolved_tickets:,}",
+                    icon=Icons.CHECK_CIRCLE,
+                    change=(
+                        f"{(resolved_tickets/total_tickets*100):.1f}%"
+                        if total_tickets > 0
+                        else "0%"
+                    ),
+                    change_type="positive",
+                    description="Successfully resolved",
+                ),
+                StatCard(
+                    title="New This Week",
+                    value=f"{new_tickets_7d:,}",
+                    icon=Icons.NEW_RELEASES,
+                    change_type="positive" if new_tickets_7d > 0 else "neutral",
+                    description="Last 7 days",
+                ),
+            ]
+        except Exception as e:
+            logger.error(f"Error getting support statistics: {e}")
+            return [
+                StatCard(
+                    title="Support",
+                    value="N/A",
+                    icon=Icons.SUPPORT_AGENT,
+                    description="Data unavailable",
+                )
+            ]
+
+    def get_app_statistics(self) -> Dict[str, Any]:
+        """Get statistics for all apps and their models."""
+        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
+
+    def _get_app_stats(self, app_label: str) -> 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) -> 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 is_support_enabled(self) -> bool:
+        """Check if support module is enabled."""
+        try:
+            from django_cfg.apps.support.models import Ticket
+            return True
+        except ImportError:
+            return False