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

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,
-            }

django_cfg/modules/django_unfold/callbacks/main.py

@@ -1,322 +0,0 @@
-"""
-Main Unfold Dashboard Callbacks
-
-Combines all callback modules into a single interface.
-"""
-
-import json
-import logging
-from typing import Any, Dict
-
-from django.template.loader import render_to_string
-from django.utils import timezone
-
-from django_cfg.core.state import get_current_config
-from django_cfg.modules.django_dashboard.debug import save_dashboard_render
-from django_cfg.modules.django_dashboard.sections.commands import CommandsSection
-from django_cfg.modules.django_dashboard.sections.documentation import DocumentationSection
-
-# Import new dashboard sections
-from django_cfg.modules.django_dashboard.sections.overview import OverviewSection
-from django_cfg.modules.django_dashboard.sections.stats import StatsSection
-from django_cfg.modules.django_dashboard.sections.system import SystemSection
-from django_cfg.modules.django_dashboard.sections.widgets import WidgetsSection
-
-from ...base import BaseCfgModule
-from ..models.dashboard import DashboardData
-from .actions import ActionsCallbacks
-from .base import get_user_admin_urls
-from .charts import ChartsCallbacks
-from .commands import CommandsCallbacks
-from .apizones import OpenAPIClientCallbacks
-from .statistics import StatisticsCallbacks
-from .system import SystemCallbacks
-from .users import UsersCallbacks
-
-logger = logging.getLogger(__name__)
-
-
-class UnfoldCallbacks(
-    BaseCfgModule,
-    StatisticsCallbacks,
-    SystemCallbacks,
-    ActionsCallbacks,
-    ChartsCallbacks,
-    CommandsCallbacks,
-    OpenAPIClientCallbacks,
-    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 current config for debug and environment settings
-            config = get_current_config()
-
-            # Log debug status
-            debug_enabled = config and config.debug
-            logger.info(f"[DEBUG MODE] Dashboard rendering with debug={debug_enabled} (config.debug={getattr(config, 'debug', 'N/A')})")
-
-            # Get dashboard data first
-            user_stats = self.get_user_statistics()
-            support_stats = self.get_support_statistics()
-            system_health = self.get_system_health()
-            quick_actions = self.get_quick_actions()
-
-            # Parse time range from query parameters (default: 7 days)
-            try:
-                time_range = int(request.GET.get('range', 7))
-                # Validate range
-                if time_range not in [7, 30, 90]:
-                    time_range = 7
-            except (ValueError, TypeError):
-                time_range = 7
-
-            # Create navigation for time range filter
-            navigation = [
-                {
-                    "title": "7 Days",
-                    "link": "?range=7",
-                    "active": time_range == 7,
-                    "icon": "calendar_today"
-                },
-                {
-                    "title": "30 Days",
-                    "link": "?range=30",
-                    "active": time_range == 30,
-                    "icon": "date_range"
-                },
-                {
-                    "title": "90 Days",
-                    "link": "?range=90",
-                    "active": time_range == 90,
-                    "icon": "event"
-                },
-            ]
-
-            # Render new dashboard sections
-            try:
-                # Create overview section and pass quick_actions + time_range + navigation
-                overview_sec = OverviewSection(request)
-                # Add quick_actions, time_range, and navigation to render context
-                overview_section = overview_sec.render(
-                    quick_actions=[action.model_dump() for action in quick_actions],
-                    time_range=time_range,
-                    navigation=navigation
-                )
-            except Exception as e:
-                logger.error(f"Failed to render overview section: {e}", exc_info=True)
-                overview_section = None
-
-            try:
-                stats_section = StatsSection(request).render()
-            except Exception as e:
-                logger.error(f"Failed to render stats section: {e}", exc_info=True)
-                stats_section = None
-
-            try:
-                system_section = SystemSection(request).render()
-            except Exception as e:
-                logger.error(f"Failed to render system section: {e}", exc_info=True)
-                system_section = None
-
-            try:
-                # Generate documentation content first
-                doc_section = DocumentationSection(request)
-                doc_data = doc_section.get_data_old()  # Get markdown/HTML content
-                documentation_content = doc_data.get('documentation_content') or doc_data.get('readme_content', '')
-                documentation_section = doc_section.render()
-            except Exception as e:
-                logger.error(f"Failed to render documentation section: {e}", exc_info=True)
-                documentation_section = None
-                documentation_content = None
-
-            try:
-                # Render commands section with documentation content
-                commands_section = CommandsSection(request).render(
-                    documentation_content=documentation_content
-                )
-            except Exception as e:
-                logger.error(f"Failed to render commands section: {e}", exc_info=True)
-                commands_section = None
-
-            # Extract custom widgets from context if provided by project's dashboard_callback
-            custom_widgets = context.get('custom_widgets', [])
-            custom_metrics = {}
-
-            # Extract all metric-like variables from context for widget template resolution
-            # This allows dashboard_callback to add metrics like: context['total_users'] = 123
-            for key, value in context.items():
-                if key not in ['request', 'cards', 'system_health', 'quick_actions'] and isinstance(value, (int, float, str)):
-                    custom_metrics[key] = value
-
-            try:
-                # Render widgets section with custom widgets and metrics from callback
-                widgets_section = WidgetsSection(request).render(
-                    custom_widgets=custom_widgets,
-                    custom_metrics=custom_metrics
-                )
-            except Exception as e:
-                logger.error(f"Failed to render widgets section: {e}", exc_info=True)
-                widgets_section = None
-
-            # Combine all stat cards (data already loaded above)
-            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(config.environment, 'name', 'development') if config and hasattr(config, 'environment') else "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({
-                # New dashboard sections (rendered HTML)
-                "overview_section": overview_section,
-                "stats_section": stats_section,
-                "system_section": system_section,
-                "commands_section": commands_section,
-                "documentation_section": documentation_section,
-                "widgets_section": widgets_section,
-
-                # Documentation content for commands tab
-                "documentation_content": documentation_content,
-
-                # 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
-                },
-
-                # 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"
-                ],
-
-                # OpenAPI Client groups
-                "zones_table": {
-                    "headers": [
-                        {"label": "Zone"},
-                        {"label": "Title"},
-                        {"label": "Apps"},
-                        {"label": "Endpoints"},
-                        {"label": "Status"},
-                        {"label": "Actions"},
-                    ],
-                    "rows": OpenAPIClientCallbacks().get_openapi_groups_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)}")
-
-            # Debug: save full rendered page (only in debug mode)
-            # DISABLED: Commenting out dashboard render saving to disk
-            # if config and config.debug:
-            #     try:
-            #         full_html = render_to_string('admin/index.html', context, request)
-            #         save_dashboard_render(full_html, name='dashboard_full_page', context=context)
-            #     except Exception as e:
-            #         logger.error(f"Failed to save full dashboard render: {e}", exc_info=True)
-
-            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