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

django_cfg/modules/django_dashboard/sections/widgets.py

@@ -1,222 +0,0 @@
-"""Widgets section for dashboard.
-
-Automatically renders widgets from DashboardManager.get_widgets_config()
-"""
-
-from datetime import timedelta
-from typing import Any, Dict, List
-
-import psutil
-from django.db.models import Avg
-from django.template import Context, Template
-from django.utils import timezone
-
-from .base import DataSection
-
-
-class WidgetsSection(DataSection):
-    """
-    Widgets section showing automatically generated dashboard widgets.
-
-    Widgets are defined in DashboardManager.get_widgets_config() and
-    can include:
-    - System metrics (CPU, Memory, Disk)
-    - RPC monitoring stats
-    - Custom application widgets
-    """
-
-    template_name = "admin/sections/widgets_section.html"
-    title = "Dashboard Widgets"
-    icon = "widgets"
-
-    def get_data(self) -> Dict[str, Any]:
-        """Get widgets configuration from DashboardManager."""
-        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
-
-        dashboard_manager = get_dashboard_manager()
-
-        # Get widgets from dashboard manager (base system widgets)
-        widgets = dashboard_manager.get_widgets_config()
-
-        return {
-            'widgets': widgets,
-            'widgets_count': len(widgets),
-            'has_widgets': len(widgets) > 0,
-        }
-
-    def merge_custom_widgets(self, widgets: List[Dict], custom_widgets: List[Any]) -> List[Dict]:
-        """
-        Merge custom widgets from dashboard_callback.
-
-        Allows projects to add widgets via dashboard_callback:
-            context["custom_widgets"] = [
-                StatsCardsWidget(...),
-                ...
-            ]
-        """
-        if not custom_widgets:
-            return widgets
-
-        # Convert custom widgets to dicts if they are Pydantic models
-        for widget in custom_widgets:
-            if hasattr(widget, 'to_dict'):
-                widgets.append(widget.to_dict())
-            elif hasattr(widget, 'model_dump'):
-                widgets.append(widget.model_dump())
-            elif isinstance(widget, dict):
-                widgets.append(widget)
-
-        return widgets
-
-    def get_context_data(self, **kwargs) -> Dict[str, Any]:
-        """Add additional context for widget rendering."""
-        context = super().get_context_data(**kwargs)
-
-        # Get base widgets from DashboardManager
-        widgets = context['data']['widgets']
-
-        # Merge custom widgets from dashboard_callback if provided
-        custom_widgets_from_callback = kwargs.get('custom_widgets', [])
-        if custom_widgets_from_callback:
-            widgets = self.merge_custom_widgets(widgets, custom_widgets_from_callback)
-            # Update count
-            context['data']['widgets_count'] = len(widgets)
-            context['data']['has_widgets'] = len(widgets) > 0
-
-        # Get metrics data first
-        metrics_data = {}
-        metrics_data.update(self.get_system_metrics())
-
-        # Add Centrifugo metrics if enabled
-        dashboard_manager = self._get_dashboard_manager()
-        if dashboard_manager.is_centrifugo_enabled():
-            metrics_data.update(self.get_centrifugo_metrics())
-
-        # Also merge any custom metrics from kwargs
-        custom_metrics = kwargs.get('custom_metrics', {})
-        if custom_metrics:
-            metrics_data.update(custom_metrics)
-
-        # Process widgets and resolve template variables
-        processed_stats_widgets = []
-        for widget in widgets:
-            if widget.get('type') == 'stats_cards':
-                processed_widget = self._process_stats_widget(widget, metrics_data)
-                processed_stats_widgets.append(processed_widget)
-
-        chart_widgets = [w for w in widgets if w.get('type') == 'chart']
-        custom_widgets = [w for w in widgets if w.get('type') not in ['stats_cards', 'chart']]
-
-        # Add processed widgets
-        context.update({
-            'stats_widgets': processed_stats_widgets,
-            'chart_widgets': chart_widgets,
-            'custom_widgets': custom_widgets,
-        })
-
-        # Also add metrics for direct access
-        context.update(metrics_data)
-
-        return context
-
-    def _get_dashboard_manager(self):
-        """Get dashboard manager instance (lazy import to avoid circular dependencies)."""
-        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
-        return get_dashboard_manager()
-
-    def _process_stats_widget(self, widget: Dict[str, Any], context_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Process StatsCardsWidget and resolve template variables in cards."""
-        processed_widget = widget.copy()
-        processed_cards = []
-
-        for card in widget.get('cards', []):
-            processed_card = card.copy()
-
-            # Resolve value_template using Django template engine
-            value_template = card.get('value_template', '')
-            if '{{' in value_template:
-                try:
-                    template = Template(value_template)
-                    context = Context(context_data)
-                    resolved_value = template.render(context)
-                    processed_card['value_template'] = resolved_value
-                except Exception:
-                    # Keep original if rendering fails
-                    pass
-
-            # Also resolve change field if it has template variables
-            change_template = card.get('change', '')
-            if change_template and '{{' in change_template:
-                try:
-                    template = Template(change_template)
-                    context = Context(context_data)
-                    resolved_change = template.render(context)
-                    processed_card['change'] = resolved_change
-                except Exception:
-                    # Keep original if rendering fails
-                    pass
-
-            processed_cards.append(processed_card)
-
-        processed_widget['cards'] = processed_cards
-        return processed_widget
-
-    def get_system_metrics(self) -> Dict[str, Any]:
-        """Get system metrics for widgets."""
-        return {
-            'cpu_percent': round(psutil.cpu_percent(interval=0.1), 1),
-            'memory_percent': round(psutil.virtual_memory().percent, 1),
-            'disk_percent': round(psutil.disk_usage('/').percent, 1),
-        }
-
-    def get_centrifugo_metrics(self) -> Dict[str, Any]:
-        """Get Centrifugo metrics for widgets."""
-        try:
-            from django_cfg.apps.centrifugo.models import CentrifugoLog
-
-            # Get stats for last 24 hours
-            since = timezone.now() - timedelta(hours=24)
-
-            logs = CentrifugoLog.objects.filter(created_at__gte=since)
-
-            total_publishes = logs.count()
-            successful_publishes = logs.filter(status='success').count()
-            failed_publishes = logs.filter(status='failed').count()
-            timeout_publishes = logs.filter(status='timeout').count()
-
-            success_rate = round((successful_publishes / total_publishes * 100) if total_publishes > 0 else 0, 1)
-
-            avg_duration = logs.filter(
-                duration_ms__isnull=False
-            ).aggregate(
-                avg=Avg('duration_ms')
-            )['avg']
-
-            avg_duration = round(avg_duration, 1) if avg_duration else 0  # Already in ms
-
-            avg_acks = logs.filter(
-                acks_received__isnull=False
-            ).aggregate(
-                avg=Avg('acks_received')
-            )['avg']
-
-            avg_acks = round(avg_acks, 1) if avg_acks else 0
-
-            return {
-                'centrifugo_total_publishes': total_publishes,
-                'centrifugo_success_rate': success_rate,
-                'centrifugo_avg_duration': avg_duration,
-                'centrifugo_failed_publishes': failed_publishes,
-                'centrifugo_timeout_publishes': timeout_publishes,
-                'centrifugo_avg_acks': avg_acks,
-            }
-        except Exception as e:
-            # Return zeros if Centrifugo models not available
-            return {
-                'centrifugo_total_publishes': 0,
-                'centrifugo_success_rate': 0,
-                'centrifugo_avg_duration': 0,
-                'centrifugo_failed_publishes': 0,
-                'centrifugo_timeout_publishes': 0,
-                'centrifugo_avg_acks': 0,
-            }

django_cfg/modules/django_unfold/callbacks/__init__.py

@@ -1,9 +0,0 @@
-"""
-Django CFG Unfold Callbacks Module
-
-Modular callback system for Django Unfold dashboard.
-"""
-
-from .main import UnfoldCallbacks
-
-__all__ = ['UnfoldCallbacks']

django_cfg/modules/django_unfold/callbacks/actions.py

@@ -1,51 +0,0 @@
-"""
-Quick actions callbacks.
-"""
-
-import logging
-from typing import List
-
-from django_cfg.modules.django_admin.icons import Icons
-
-from ..models.dashboard import QuickAction
-from .base import get_user_admin_urls
-
-logger = logging.getLogger(__name__)
-
-
-class ActionsCallbacks:
-    """Quick actions callbacks."""
-
-    def get_quick_actions(self) -> List[QuickAction]:
-        """Get quick action buttons as Pydantic models."""
-        # Get user admin URLs dynamically based on AUTH_USER_MODEL
-        user_admin_urls = get_user_admin_urls()
-
-        actions = [
-            QuickAction(
-                title="Add User",
-                description="Create new user account",
-                icon=Icons.PERSON_ADD,
-                link=user_admin_urls["add"],
-                color="primary",
-                category="admin",
-            ),
-            QuickAction(
-                title="Support Tickets",
-                description="Manage support tickets",
-                icon=Icons.SUPPORT_AGENT,
-                link="admin:django_cfg_support_ticket_changelist",
-                color="primary",
-                category="support",
-            ),
-            QuickAction(
-                title="Health Check",
-                description="System health status",
-                icon=Icons.HEALTH_AND_SAFETY,
-                link="/cfg/health/",
-                color="success",
-                category="system",
-            ),
-        ]
-
-        return actions

django_cfg/modules/django_unfold/callbacks/apizones.py

@@ -1,122 +0,0 @@
-"""
-Django Client (OpenAPI) integration callbacks.
-"""
-
-import logging
-from typing import Any, Dict, List, Tuple
-
-from django.conf import settings
-
-logger = logging.getLogger(__name__)
-
-
-class OpenAPIClientCallbacks:
-    """Django Client (OpenAPI) integration callbacks."""
-
-    def get_openapi_groups_data(self) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
-        """Get Django Client (OpenAPI) groups data."""
-        try:
-            # Get groups from OpenAPI service (includes default cfg group)
-            from django_cfg.modules.django_client.core import get_openapi_service
-
-            service = get_openapi_service()
-            if not service.config:
-                return [], {"total_apps": 0, "total_endpoints": 0, "total_groups": 0}
-
-            # Get groups with defaults (includes cfg group automatically)
-            groups_dict = service.get_groups()
-            groups_list = list(groups_dict.values())
-            api_prefix = getattr(service.config, "api_prefix", "api")
-
-            # Ensure urlconf modules AND URL patterns are created for all groups with apps
-            try:
-                from django.urls import path
-                from drf_spectacular.views import SpectacularAPIView
-                from django_cfg.modules.django_client.core.groups import GroupManager
-                from django_cfg.modules.django_client import urls as client_urls
-
-                manager = GroupManager(service.config)
-                for group in groups_list:
-                    group_name = getattr(group, "name", "unknown") if not isinstance(group, dict) else group.get("name", "unknown")
-                    apps = getattr(group, "apps", []) if not isinstance(group, dict) else group.get("apps", [])
-                    group_version = getattr(group, "version", "1.0.0") if not isinstance(group, dict) else group.get("version", "1.0.0")
-
-                    if apps:
-                        try:
-                            # Create urlconf module
-                            manager.create_urlconf_module(group_name)
-
-                            # Check if URL pattern already exists
-                            url_name = f'openapi-schema-{group_name}'
-                            url_exists = any(
-                                hasattr(pattern, 'name') and pattern.name == url_name
-                                for pattern in client_urls.urlpatterns
-                            )
-
-                            # Add URL pattern if it doesn't exist
-                            if not url_exists:
-                                new_pattern = path(
-                                    f'{group_name}/schema/',
-                                    SpectacularAPIView.as_view(
-                                        urlconf=f'_django_client_urlconf_{group_name}',
-                                        api_version=group_version,
-                                    ),
-                                    name=url_name,
-                                )
-                                client_urls.urlpatterns.append(new_pattern)
-                        except Exception:
-                            pass  # Silently skip if already exists or fails
-            except Exception:
-                pass  # Silently skip if GroupManager fails
-
-            groups_data = []
-            total_apps = 0
-            total_endpoints = 0
-
-            for group in groups_list:
-                # Handle both dict and object access
-                if isinstance(group, dict):
-                    group_name = group.get("name", "unknown")
-                    title = group.get("title", group_name.title())
-                    description = group.get("description", f"{group_name} group")
-                    apps = group.get("apps", [])
-                else:
-                    # Handle object access (for OpenAPIGroupConfig instances)
-                    group_name = getattr(group, "name", "unknown")
-                    title = getattr(group, "title", group_name.title())
-                    description = getattr(group, "description", f"{group_name} group")
-                    apps = getattr(group, "apps", [])
-
-                # Count actual endpoints by checking URL patterns (simplified estimate)
-                endpoint_count = len(apps) * 3  # Conservative estimate
-
-                groups_data.append({
-                    "name": group_name,
-                    "title": title,
-                    "description": description,
-                    "app_count": len(apps),
-                    "endpoint_count": endpoint_count,
-                    "status": "active",
-                    "schema_url": f"/cfg/openapi/{group_name}/schema/",
-                    "api_url": f"/{api_prefix}/{group_name}/",
-                })
-
-                total_apps += len(apps)
-                total_endpoints += endpoint_count
-
-            return groups_data, {
-                "total_apps": total_apps,
-                "total_endpoints": total_endpoints,
-                "total_groups": len(groups_list),
-            }
-        except Exception as e:
-            logger.error(f"Error getting OpenAPI groups: {e}")
-            return [], {
-                "total_apps": 0,
-                "total_endpoints": 0,
-                "total_groups": 0,
-            }
-
-
-# Keep backward compatibility alias
-RevolutionCallbacks = OpenAPIClientCallbacks

django_cfg/modules/django_unfold/callbacks/charts.py

@@ -1,223 +0,0 @@
-"""
-Charts data callbacks.
-"""
-
-import logging
-from datetime import timedelta
-from typing import Any, Dict, List
-
-from django.contrib.auth import get_user_model
-from django.db.models import Count
-from django.utils import timezone
-
-from ..models.dashboard import ChartData, ChartDataset
-
-logger = logging.getLogger(__name__)
-
-
-class ChartsCallbacks:
-    """Charts data callbacks."""
-
-    def _get_user_model(self):
-        """Get the user model safely."""
-        return get_user_model()
-
-    def _get_empty_chart_data(self, label: str) -> Dict[str, Any]:
-        """Get empty chart data structure."""
-        return ChartData(
-            labels=["No Data"],
-            datasets=[
-                ChartDataset(
-                    label=label,
-                    data=[0],
-                    backgroundColor="rgba(156, 163, 175, 0.1)",
-                    borderColor="rgb(156, 163, 175)",
-                    tension=0.4
-                )
-            ]
-        ).model_dump()
-
-    def get_user_registration_chart_data(self) -> Dict[str, Any]:
-        """Get user registration chart data."""
-        try:
-            # Avoid database access during app initialization
-            from django.apps import apps
-            if not apps.ready:
-                return self._get_empty_chart_data("New Users")
-
-            User = self._get_user_model()
-
-            # Get last 7 days of registration data
-            end_date = timezone.now().date()
-            start_date = end_date - timedelta(days=6)
-
-            # Generate date range
-            date_range = []
-            current_date = start_date
-            while current_date <= end_date:
-                date_range.append(current_date)
-                current_date += timedelta(days=1)
-
-            # Get registration counts by date
-            registration_data = (
-                User.objects.filter(date_joined__date__gte=start_date)
-                .extra({'date': "date(date_joined)"})
-                .values('date')
-                .annotate(count=Count('id'))
-                .order_by('date')
-            )
-
-            # Create data dictionary for easy lookup
-            data_dict = {item['date']: item['count'] for item in registration_data}
-
-            # Build chart data
-            labels = [date.strftime("%m/%d") for date in date_range]
-            data_points = [data_dict.get(date, 0) for date in date_range]
-
-            chart_data = ChartData(
-                labels=labels,
-                datasets=[
-                    ChartDataset(
-                        label="New Users",
-                        data=data_points,
-                        backgroundColor="rgba(59, 130, 246, 0.1)",
-                        borderColor="rgb(59, 130, 246)",
-                        tension=0.4
-                    )
-                ]
-            )
-
-            return chart_data.model_dump()
-
-        except Exception as e:
-            logger.error(f"Error getting user registration chart data: {e}")
-            return self._get_empty_chart_data("New Users")
-
-    def get_user_activity_chart_data(self) -> Dict[str, Any]:
-        """Get user activity chart data."""
-        try:
-            # Avoid database access during app initialization
-            from django.apps import apps
-            if not apps.ready:
-                return self._get_empty_chart_data("Active Users")
-
-            User = self._get_user_model()
-
-            # Get activity data for last 7 days
-            end_date = timezone.now().date()
-            start_date = end_date - timedelta(days=6)
-
-            # Generate date range
-            date_range = []
-            current_date = start_date
-            while current_date <= end_date:
-                date_range.append(current_date)
-                current_date += timedelta(days=1)
-
-            # Get login activity (users who logged in each day)
-            activity_data = (
-                User.objects.filter(last_login__date__gte=start_date, last_login__isnull=False)
-                .extra({'date': "date(last_login)"})
-                .values('date')
-                .annotate(count=Count('id'))
-                .order_by('date')
-            )
-
-            # Create data dictionary for easy lookup
-            data_dict = {item['date']: item['count'] for item in activity_data}
-
-            # Build chart data
-            labels = [date.strftime("%m/%d") for date in date_range]
-            data_points = [data_dict.get(date, 0) for date in date_range]
-
-            chart_data = ChartData(
-                labels=labels,
-                datasets=[
-                    ChartDataset(
-                        label="Active Users",
-                        data=data_points,
-                        backgroundColor="rgba(34, 197, 94, 0.1)",
-                        borderColor="rgb(34, 197, 94)",
-                        tension=0.4
-                    )
-                ]
-            )
-
-            return chart_data.model_dump()
-
-        except Exception as e:
-            logger.error(f"Error getting user activity chart data: {e}")
-            return self._get_empty_chart_data("Active Users")
-
-    def get_activity_tracker_data(self) -> List[Dict[str, str]]:
-        """Get activity tracker data for the last 52 weeks (GitHub-style)."""
-        try:
-            # Avoid database access during app initialization
-            from django.apps import apps
-            if not apps.ready:
-                return self._get_empty_tracker_data()
-
-            User = self._get_user_model()
-
-            # Get data for last 52 weeks (365 days)
-            end_date = timezone.now().date()
-            start_date = end_date - timedelta(days=364)  # 52 weeks * 7 days - 1
-
-            # Get activity data by date
-            activity_data = (
-                User.objects.filter(last_login__date__gte=start_date, last_login__isnull=False)
-                .extra({'date': "date(last_login)"})
-                .values('date')
-                .annotate(count=Count('id'))
-                .order_by('date')
-            )
-
-            # Create data dictionary for easy lookup
-            data_dict = {item['date']: item['count'] for item in activity_data}
-
-            # Generate tracker data for each day
-            tracker_data = []
-            current_date = start_date
-
-            while current_date <= end_date:
-                activity_count = data_dict.get(current_date, 0)
-
-                # Determine color based on activity level
-                if activity_count == 0:
-                    color = "bg-base-200 dark:bg-base-700"
-                    level = "No activity"
-                elif activity_count <= 2:
-                    color = "bg-green-200 dark:bg-green-800"
-                    level = "Low activity"
-                elif activity_count <= 5:
-                    color = "bg-green-400 dark:bg-green-600"
-                    level = "Medium activity"
-                elif activity_count <= 10:
-                    color = "bg-green-600 dark:bg-green-500"
-                    level = "High activity"
-                else:
-                    color = "bg-green-800 dark:bg-green-400"
-                    level = "Very high activity"
-
-                tracker_data.append({
-                    "color": color,
-                    "tooltip": f"{current_date.strftime('%Y-%m-%d')}: {activity_count} active users ({level})"
-                })
-
-                current_date += timedelta(days=1)
-
-            return tracker_data
-
-        except Exception as e:
-            logger.error(f"Error getting activity tracker data: {e}")
-            return self._get_empty_tracker_data()
-
-    def _get_empty_tracker_data(self) -> List[Dict[str, str]]:
-        """Get empty tracker data (365 days of no activity)."""
-        tracker_data = []
-        for i in range(365):
-            tracker_data.append({
-                "color": "bg-base-200 dark:bg-base-700",
-                "tooltip": f"Day {i + 1}: No data available"
-            })
-        return tracker_data

django_cfg/modules/django_unfold/callbacks/commands.py

@@ -1,40 +0,0 @@
-"""
-Django commands callbacks.
-"""
-
-import logging
-from typing import Any, Dict
-
-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,
-            }