django-cfg 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

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

django_cfg/modules/django_unfold/callbacks/system.py

@@ -0,0 +1,180 @@
+"""
+System health and metrics callbacks.
+"""
+
+import logging
+import shutil
+from typing import List, Dict, Any
+
+from django.utils import timezone
+from django.db import connection
+from django.core.cache import cache
+
+from ..models.dashboard import SystemHealthItem
+
+logger = logging.getLogger(__name__)
+
+
+class SystemCallbacks:
+    """System health and metrics callbacks."""
+    
+    def get_system_health(self) -> List[SystemHealthItem]:
+        """Get system health status as Pydantic models."""
+        health_items = []
+
+        # Database health
+        try:
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT 1")
+                health_items.append(
+                    SystemHealthItem(
+                        component="database",
+                        status="healthy",
+                        description="Connection successful",
+                        last_check=timezone.now().strftime("%H:%M:%S"),
+                        health_percentage=95,
+                    )
+                )
+        except Exception as e:
+            health_items.append(
+                SystemHealthItem(
+                    component="database",
+                    status="error",
+                    description=f"Connection failed: {str(e)[:50]}",
+                    last_check=timezone.now().strftime("%H:%M:%S"),
+                    health_percentage=0,
+                )
+            )
+
+        # Cache health
+        try:
+            cache.set("health_check", "ok", 10)
+            if cache.get("health_check") == "ok":
+                health_items.append(
+                    SystemHealthItem(
+                        component="cache",
+                        status="healthy",
+                        description="Cache operational",
+                        last_check=timezone.now().strftime("%H:%M:%S"),
+                        health_percentage=90,
+                    )
+                )
+            else:
+                health_items.append(
+                    SystemHealthItem(
+                        component="cache",
+                        status="warning",
+                        description="Cache not responding",
+                        last_check=timezone.now().strftime("%H:%M:%S"),
+                        health_percentage=50,
+                    )
+                )
+        except Exception:
+            health_items.append(
+                SystemHealthItem(
+                    component="cache",
+                    status="unknown",
+                    description="Cache not configured",
+                    last_check=timezone.now().strftime("%H:%M:%S"),
+                    health_percentage=0,
+                )
+            )
+
+        # Storage health
+        try:
+            total, used, free = shutil.disk_usage("/")
+            usage_percentage = (used / total) * 100
+            free_percentage = 100 - usage_percentage
+
+            if free_percentage > 20:
+                status = "healthy"
+                desc = f"Disk space: {free_percentage:.1f}% free"
+            elif free_percentage > 10:
+                status = "warning"
+                desc = f"Low disk space: {free_percentage:.1f}% free"
+            else:
+                status = "error"
+                desc = f"Critical disk space: {free_percentage:.1f}% free"
+
+            health_items.append(
+                SystemHealthItem(
+                    component="storage",
+                    status=status,
+                    description=desc,
+                    last_check=timezone.now().strftime("%H:%M:%S"),
+                    health_percentage=int(free_percentage),
+                )
+            )
+        except Exception as e:
+            health_items.append(
+                SystemHealthItem(
+                    component="storage",
+                    status="error",
+                    description="Storage check failed",
+                    last_check=timezone.now().strftime("%H:%M:%S"),
+                    health_percentage=0,
+                )
+            )
+
+        # API health
+        health_items.append(
+            SystemHealthItem(
+                component="api",
+                status="healthy",
+                description="API server running",
+                last_check=timezone.now().strftime("%H:%M:%S"),
+                health_percentage=100,
+            )
+        )
+
+        return health_items
+
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """Get system metrics for dashboard."""
+        metrics = {}
+
+        # Database metrics
+        try:
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT 1")
+                metrics["database"] = {
+                    "status": "healthy",
+                    "type": "PostgreSQL",
+                    "health_percentage": 95,
+                    "description": "Connection successful",
+                }
+        except Exception as e:
+            metrics["database"] = {
+                "status": "error",
+                "type": "PostgreSQL",
+                "health_percentage": 0,
+                "description": f"Connection failed: {str(e)}",
+            }
+
+        # 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)}",
+            }
+
+        return metrics

django_cfg/modules/django_unfold/callbacks/users.py

@@ -0,0 +1,65 @@
+"""
+Users data callbacks.
+"""
+
+import logging
+from typing import List, Dict, Any
+
+from django.contrib.auth import get_user_model
+
+from .base import get_user_admin_urls
+
+logger = logging.getLogger(__name__)
+
+
+class UsersCallbacks:
+    """Users data callbacks."""
+    
+    def _get_user_model(self):
+        """Get the user model safely."""
+        return get_user_model()
+    
+    def get_recent_users(self) -> List[Dict[str, Any]]:
+        """Get recent users data for template."""
+        try:
+            # Avoid database access during app initialization
+            from django.apps import apps
+            if not apps.ready:
+                return []
+                
+            User = self._get_user_model()
+            recent_users = User.objects.select_related().order_by("-date_joined")[:10]
+
+            # Get admin URLs for user model
+            user_admin_urls = get_user_admin_urls()
+
+            return [
+                {
+                    "id": user.id,
+                    "username": user.username,
+                    "email": user.email or "No email",
+                    "date_joined": (
+                        user.date_joined.strftime("%Y-%m-%d")
+                        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,
+                    "admin_urls": {
+                        "change": (
+                            user_admin_urls["change"].format(id=user.id)
+                            if user.id
+                            else None
+                        ),
+                        "view": (
+                            user_admin_urls["view"].format(id=user.id) if user.id else None
+                        ),
+                    },
+                }
+                for user in recent_users
+            ]
+        except Exception as e:
+            logger.error(f"Error getting recent users: {e}")
+            return []

django_cfg/modules/django_unfold/models/config.py

@@ -467,21 +467,28 @@ class UnfoldConfig(BaseModel):
         if self.tab_configurations:
             unfold_settings["TABS"] = self.tab_configurations
         
-        # Command interface
+        # Command interface - Enhanced for better UX
         unfold_settings["COMMAND"] = {
             "search_models": True,
             "show_history": True,
+            "search_callback": None,  # Can be customized per project
         }
 
-        # Inject universal CSS variables (includes object-tools flex)
+        # Inject universal CSS variables and custom styles
         if "STYLES" not in unfold_settings:
             unfold_settings["STYLES"] = []
         
         # Add our CSS as inline data URI
         try:
-            from ..tailwind import get_css_variables
+            from ..tailwind import get_css_variables, get_modal_fix_css
             import base64
+            
+            # Base CSS variables
             css_content = get_css_variables()
+            
+            # Add modal scroll fix CSS
+            css_content += get_modal_fix_css()
+            
             css_b64 = base64.b64encode(css_content.encode('utf-8')).decode('utf-8')
             data_uri = f"data:text/css;base64,{css_b64}"
             unfold_settings["STYLES"].append(lambda request: data_uri)

django_cfg/modules/django_unfold/tailwind.py

@@ -198,6 +198,74 @@ def get_css_variables() -> str:
 """
 
 
+def get_modal_fix_css() -> str:
+    """
+    Get CSS fixes for modal scroll issues and other UI improvements.
+    
+    Returns:
+        str: CSS fixes as string
+    """
+    return """
+/* Modal scroll fixes and UI improvements */
+
+/* Ensure proper modal scroll behavior */
+.modal-scrollable {
+    max-height: calc(80vh - 8rem);
+    overflow-y: auto;
+}
+
+/* Command modal specific fixes */
+#commandModal .overflow-y-auto {
+    scrollbar-width: thin;
+    scrollbar-color: rgb(156, 163, 175) transparent;
+}
+
+#commandModal .overflow-y-auto::-webkit-scrollbar {
+    width: 8px;
+}
+
+#commandModal .overflow-y-auto::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+#commandModal .overflow-y-auto::-webkit-scrollbar-thumb {
+    background-color: rgb(156, 163, 175);
+    border-radius: 4px;
+}
+
+#commandModal .overflow-y-auto::-webkit-scrollbar-thumb:hover {
+    background-color: rgb(107, 114, 128);
+}
+
+/* Dark theme scrollbar */
+.dark #commandModal .overflow-y-auto {
+    scrollbar-color: rgb(75, 85, 99) transparent;
+}
+
+.dark #commandModal .overflow-y-auto::-webkit-scrollbar-thumb {
+    background-color: rgb(75, 85, 99);
+}
+
+.dark #commandModal .overflow-y-auto::-webkit-scrollbar-thumb:hover {
+    background-color: rgb(107, 114, 128);
+}
+
+/* Improved focus states */
+.focus-visible\\:outline-primary-600:focus-visible {
+    outline: 2px solid rgb(37, 99, 235);
+    outline-offset: 2px;
+}
+
+/* Better button transitions */
+.transition-colors {
+    transition-property: color, background-color, border-color;
+    transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+    transition-duration: 150ms;
+}
+
+"""
+
+
 def get_unfold_colors() -> Dict[str, Any]:
     """
     Get color configuration for Unfold settings.