django-cfg 1.4.88__py3-none-any.whl → 1.4.89__py3-none-any.whl

django_cfg/modules/django_unfold/callbacks/statistics.py

@@ -1,240 +0,0 @@
-"""
-Statistics callbacks for dashboard.
-"""
-
-import logging
-from datetime import timedelta
-from typing import Any, Dict, List
-
-from django.apps import apps
-from django.contrib.auth import get_user_model
-from django.utils import timezone
-
-from django_cfg.modules.django_admin.icons import Icons
-
-from ..models.dashboard import StatCard
-
-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

@@ -1,180 +0,0 @@
-"""
-System health and metrics callbacks.
-"""
-
-import logging
-import shutil
-from typing import Any, Dict, List
-
-from django.core.cache import cache
-from django.db import connection
-from django.utils import timezone
-
-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:
-            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

@@ -1,65 +0,0 @@
-"""
-Users data callbacks.
-"""
-
-import logging
-from typing import Any, Dict, List
-
-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/dashboard.py

@@ -1,207 +0,0 @@
-"""
-Dashboard Components Models for Unfold
-
-Pydantic models for dashboard components like stat cards, health items, etc.
-"""
-
-from typing import Any, Dict, List, Literal, Optional
-
-from pydantic import BaseModel, ConfigDict, Field, computed_field
-
-
-class StatCard(BaseModel):
-    """Dashboard statistics card model."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    title: str = Field(..., description="Card title")
-    value: str = Field(..., description="Main value to display")
-    icon: str = Field(..., description="Material icon name")
-    change: Optional[str] = Field(None, description="Change indicator (e.g., '+12%')")
-    change_type: Literal["positive", "negative", "neutral"] = Field(default="neutral", description="Change type")
-    description: Optional[str] = Field(None, description="Additional description")
-    color: str = Field("primary", description="Card color theme")
-
-    @computed_field
-    @property
-    def css_classes(self) -> Dict[str, str]:
-        """Get CSS classes for different states."""
-        return {
-            "positive": "text-emerald-600 bg-emerald-100 dark:bg-emerald-900/20 dark:text-emerald-400",
-            "negative": "text-red-600 bg-red-100 dark:bg-red-900/20 dark:text-red-400",
-            "neutral": "text-slate-600 bg-slate-100 dark:bg-slate-700 dark:text-slate-400"
-        }
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for Unfold dashboard widgets."""
-        return {
-            "title": self.title,
-            "value_template": self.value,
-            "icon": self.icon,
-            "color": self.color,
-            "change": self.change,
-            "change_type": self.change_type,
-            "description": self.description,
-        }
-
-
-class SystemHealthItem(BaseModel):
-    """System health status item."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    component: str = Field(..., description="Component name")
-    status: Literal["healthy", "warning", "error", "unknown"] = Field(..., description="Health status")
-    description: str = Field(..., description="Status description")
-    last_check: str = Field(..., description="Last check time")
-    health_percentage: Optional[int] = Field(None, description="Health percentage (0-100)")
-
-    @computed_field
-    @property
-    def icon(self) -> str:
-        """Get icon based on component type."""
-        icons = {
-            "database": "storage",
-            "cache": "memory",
-            "queue": "queue",
-            "storage": "folder",
-            "api": "api",
-        }
-        return icons.get(self.component.lower(), "info")
-
-    @computed_field
-    @property
-    def status_icon(self) -> str:
-        """Get status icon."""
-        icons = {
-            "healthy": "check_circle",
-            "warning": "warning",
-            "error": "error",
-            "unknown": "help"
-        }
-        return icons.get(self.status, "help")
-
-
-class QuickAction(BaseModel):
-    """Quick action button model."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    title: str = Field(..., description="Action title")
-    description: str = Field(..., description="Action description")
-    icon: str = Field(..., description="Material icon name")
-    link: str = Field(..., description="Action URL or URL name")
-    color: Literal["primary", "success", "warning", "danger", "secondary"] = Field(default="primary", description="Button color theme")
-    category: str = Field("general", description="Action category (admin, user, system)")
-
-    def get_resolved_url(self) -> str:
-        """
-        Resolve URL name to full URL if needed.
-
-        Returns:
-            Full URL string - either the original link if it's already a URL,
-            or the resolved URL if it's a URL name.
-        """
-        # If link starts with '/' or 'http', it's already a full URL
-        if self.link.startswith(("/", "http")):
-            return self.link
-
-        # Try to resolve as URL name
-        try:
-            from django.urls import reverse
-            from django.urls.exceptions import NoReverseMatch
-            return reverse(self.link)
-        except (NoReverseMatch, ImportError, Exception):
-            # If reverse fails, return the original link
-            return self.link
-
-    def model_dump(self, **kwargs) -> dict:
-        """Override model_dump to include resolved URL."""
-        data = super().model_dump(**kwargs)
-        # Replace link with resolved URL
-        data["link"] = self.get_resolved_url()
-        return data
-
-
-class DashboardWidget(BaseModel):
-    """Dashboard widget configuration."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    title: str = Field(..., description="Widget title")
-    template: Optional[str] = Field(None, description="Custom template path")
-    callback: Optional[str] = Field(None, description="Callback function path")
-    width: int = Field(12, description="Widget width (1-12)")
-    order: int = Field(0, description="Widget order")
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for Unfold dashboard widgets."""
-        return {
-            "title": self.title,
-            "template": self.template,
-            "callback": self.callback,
-            "width": self.width,
-            "order": self.order,
-        }
-
-
-class StatsCardsWidget(BaseModel):
-    """Stats cards widget for dashboard."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    type: Literal["stats_cards"] = Field(default="stats_cards", description="Widget type")
-    title: str = Field(..., description="Widget title")
-    cards: List[StatCard] = Field(default_factory=list, description="Statistics cards")
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for Unfold dashboard widgets."""
-        return {
-            "type": self.type,
-            "title": self.title,
-            "cards": [card.to_dict() for card in self.cards],
-        }
-
-
-class ChartDataset(BaseModel):
-    """Chart dataset for dashboard charts."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    label: str = Field(..., description="Dataset label")
-    data: List[int] = Field(default_factory=list, description="Data points")
-    backgroundColor: str = Field(..., description="Background color")
-    borderColor: str = Field(..., description="Border color")
-    tension: float = Field(0.4, description="Line tension")
-
-
-class ChartData(BaseModel):
-    """Chart data structure."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    labels: List[str] = Field(default_factory=list, description="Chart labels")
-    datasets: List[ChartDataset] = Field(default_factory=list, description="Chart datasets")
-
-
-class DashboardData(BaseModel):
-    """Main dashboard data container."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-    # Statistics cards
-    stat_cards: List[StatCard] = Field(default_factory=list, description="Dashboard statistics cards")
-
-    # System health
-    system_health: List[SystemHealthItem] = Field(default_factory=list, description="System health items")
-
-    # Quick actions
-    quick_actions: List[QuickAction] = Field(default_factory=list, description="Quick action buttons")
-
-    # Additional data
-    last_updated: str = Field(..., description="Last update timestamp")
-    environment: str = Field("development", description="Current environment")
-
-    @computed_field
-    @property
-    def total_users(self) -> int:
-        """Get total users from stat cards."""
-        for card in self.stat_cards:
-            if "user" in card.title.lower():
-                try:
-                    return int(card.value.replace(",", ""))
-                except (ValueError, AttributeError):
-                    pass
-        return 0