django-cfg 1.3.11__py3-none-any.whl → 1.4.0__py3-none-any.whl

django_cfg/modules/django_unfold/callbacks/base.py

@@ -3,27 +3,217 @@ Base utilities and helper functions for callbacks.
 """
 
 import logging
-from typing import Dict, Any, List
+import inspect
+from typing import Dict, Any, List, Set, Optional
 from django.contrib.auth import get_user_model
 from django.core.management import get_commands
+from django.core.management.base import BaseCommand
 import importlib
 
 logger = logging.getLogger(__name__)
 
 
+# Keywords in docstring/code that indicate command should not be in web UI
+DANGEROUS_KEYWORDS: Set[str] = {
+    'questionary', 'input(', 'stdin', 'interactive',  # Requires user input
+    'destructive', 'dangerous', 'irreversible',  # Explicitly marked as dangerous
+    'runserver', 'testserver',  # Dev servers
+}
+
+# Commands that should NEVER appear (absolute blacklist)
+ABSOLUTE_BLACKLIST: Set[str] = {
+    # Destructive database commands
+    'flush', 'sqlflush', 'dbshell',
+
+    # Shell access (security risk)
+    'shell', 'shell_plus',
+
+    # Development server (not for web execution)
+    'runserver', 'testserver', 'runserver_ngrok',
+
+    # Project generation (not applicable in running app)
+    'startapp', 'startproject',
+
+    # SQL commands (direct SQL, potentially dangerous)
+    'sqlmigrate', 'sqlsequencereset',
+}
+
+
+def analyze_command_safety(command_class: BaseCommand, command_name: str) -> Dict[str, Any]:
+    """
+    Analyze command to determine if it's safe for web execution.
+
+    Checks:
+    1. Explicit metadata (web_executable, requires_input, is_destructive)
+    2. Docstring analysis for dangerous keywords
+    3. Source code analysis for interactive input
+    4. Required arguments analysis
+
+    Returns:
+        Dict with safety analysis results
+    """
+    analysis = {
+        'is_safe': True,
+        'reasons': [],
+        'requires_input': False,
+        'is_destructive': False,
+        'web_executable': None,
+    }
+
+    # Check explicit metadata (highest priority)
+    if hasattr(command_class, 'web_executable'):
+        analysis['web_executable'] = command_class.web_executable
+        if not command_class.web_executable:
+            analysis['is_safe'] = False
+            analysis['reasons'].append('Command explicitly marked as not web-executable')
+            return analysis
+
+    if hasattr(command_class, 'requires_input'):
+        analysis['requires_input'] = command_class.requires_input
+        if command_class.requires_input:
+            analysis['is_safe'] = False
+            analysis['reasons'].append('Command requires interactive input')
+            return analysis
+
+    if hasattr(command_class, 'is_destructive'):
+        analysis['is_destructive'] = command_class.is_destructive
+        if command_class.is_destructive:
+            analysis['is_safe'] = False
+            analysis['reasons'].append('Command is marked as destructive')
+            return analysis
+
+    # Analyze docstring for dangerous keywords
+    docstring = (inspect.getdoc(command_class) or '').lower()
+    for keyword in DANGEROUS_KEYWORDS:
+        if keyword in docstring:
+            analysis['is_safe'] = False
+            analysis['reasons'].append(f'Docstring contains dangerous keyword: {keyword}')
+            return analysis
+
+    # Analyze source code for interactive input
+    try:
+        source = inspect.getsource(command_class)
+        if 'questionary' in source or 'input(' in source:
+            analysis['is_safe'] = False
+            analysis['requires_input'] = True
+            analysis['reasons'].append('Command requires interactive user input')
+            return analysis
+    except Exception:
+        # Can't analyze source, be safe
+        pass
+
+    return analysis
+
+
+def is_command_allowed(command_name: str, app_name: str) -> bool:
+    """
+    Check if command should be displayed in web interface.
+
+    Priority:
+    1. Custom blacklist from settings (DJANGO_CFG_COMMANDS_BLACKLIST)
+    2. Absolute blacklist - always exclude
+    3. Custom whitelist from settings (DJANGO_CFG_COMMANDS_WHITELIST)
+    4. Command metadata analysis (web_executable, requires_input, etc.)
+    5. django_cfg apps - analyze each command
+    6. Django core - be selective (only safe utility commands)
+    7. Third party - only if explicitly whitelisted
+
+    You can customize filtering in settings.py:
+
+        DJANGO_CFG_COMMANDS_BLACKLIST = {'my_dangerous_command'}
+        DJANGO_CFG_COMMANDS_WHITELIST = {'my_safe_command'}
+
+    Or add metadata to your Command class:
+
+        class Command(BaseCommand):
+            web_executable = True  # Allow in web UI
+            requires_input = False  # Doesn't need interactive input
+            is_destructive = False  # Not destructive
+    """
+    from django.conf import settings
+
+    # Custom blacklist from settings (highest priority)
+    custom_blacklist = getattr(settings, 'DJANGO_CFG_COMMANDS_BLACKLIST', set())
+    if command_name in custom_blacklist:
+        return False
+
+    # Absolute blacklist
+    if command_name in ABSOLUTE_BLACKLIST:
+        return False
+
+    # Custom whitelist from settings
+    custom_whitelist = getattr(settings, 'DJANGO_CFG_COMMANDS_WHITELIST', set())
+    if command_name in custom_whitelist:
+        return True
+
+    # Load and analyze command
+    try:
+        # Determine module path
+        if app_name == 'django_cfg':
+            module_path = f'django_cfg.management.commands.{command_name}'
+        elif app_name.startswith('django.'):
+            module_path = f'{app_name}.management.commands.{command_name}'
+        else:
+            module_path = f'{app_name}.management.commands.{command_name}'
+
+        command_module = importlib.import_module(module_path)
+        if hasattr(command_module, 'Command'):
+            command_class = command_module.Command
+
+            # Analyze command safety
+            analysis = analyze_command_safety(command_class, command_name)
+
+            # If command has explicit web_executable metadata, use it
+            if analysis['web_executable'] is not None:
+                return analysis['web_executable']
+
+            # If analysis says it's unsafe, exclude
+            if not analysis['is_safe']:
+                logger.debug(f"Command {command_name} excluded: {', '.join(analysis['reasons'])}")
+                return False
+    except Exception as e:
+        # Can't load/analyze command
+        logger.debug(f"Could not analyze command {command_name}: {e}")
+        # Be conservative - if we can't analyze, exclude unless from trusted source
+        pass
+
+    # Django CFG commands - include if analysis passed
+    if app_name == 'django_cfg':
+        return True
+
+    # Safe Django core commands (utility/read-only)
+    safe_django_core = {
+        'check', 'diffsettings', 'showmigrations',
+        'createcachetable', 'sendtestemail',
+    }
+    if app_name.startswith('django.') and command_name in safe_django_core:
+        return True
+
+    # Exclude other Django core by default
+    if app_name.startswith('django.'):
+        return False
+
+    # Third-party apps - only whitelisted
+    return False
+
+
 def get_available_commands():
-    """Get all available Django management commands."""
+    """Get all available Django management commands (filtered for safety)."""
     commands_dict = get_commands()
     commands_list = []
-    
+
     for command_name, app_name in commands_dict.items():
+        # Filter out unsafe/unwanted commands
+        if not is_command_allowed(command_name, app_name):
+            continue
+
         try:
             # Try to get command description
             if app_name == 'django_cfg':
                 module_path = f'django_cfg.management.commands.{command_name}'
             else:
                 module_path = f'{app_name}.management.commands.{command_name}'
-            
+
             try:
                 command_module = importlib.import_module(module_path)
                 if hasattr(command_module, 'Command'):
@@ -33,7 +223,7 @@ def get_available_commands():
                     description = f'{command_name} command'
             except ImportError:
                 description = f'{command_name} command'
-            
+
             commands_list.append({
                 'name': command_name,
                 'app': app_name,
@@ -41,10 +231,11 @@ def get_available_commands():
                 'is_core': app_name.startswith('django.'),
                 'is_custom': app_name == 'django_cfg',
             })
-        except Exception:
+        except Exception as e:
             # Skip problematic commands
+            logger.debug(f"Skipping command {command_name}: {e}")
             continue
-    
+
     return commands_list
 
 

django_cfg/modules/django_unfold/callbacks/main.py

@@ -9,10 +9,10 @@ import json
 from typing import Dict, Any
 
 from django.utils import timezone
-from django.conf import settings
 
 from ...base import BaseCfgModule
 from ..models.dashboard import DashboardData
+from django_cfg.core.state import get_current_config
 
 from .statistics import StatisticsCallbacks
 from .system import SystemCallbacks
@@ -23,6 +23,13 @@ from .revolution import RevolutionCallbacks
 from .users import UsersCallbacks
 from .base import get_user_admin_urls
 
+# Import new dashboard sections
+from django_cfg.dashboard.sections.overview import OverviewSection
+from django_cfg.dashboard.sections.stats import StatsSection
+from django_cfg.dashboard.sections.system import SystemSection
+from django_cfg.dashboard.sections.commands import CommandsSection
+from django_cfg.dashboard.debug import save_section_render
+
 logger = logging.getLogger(__name__)
 
 
@@ -50,13 +57,95 @@ class UnfoldCallbacks(
         Returns all dashboard data as Pydantic models for type safety.
         """
         try:
-            # Get dashboard data using Pydantic models
+            # 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()
-            
-            # Combine all stat cards
+
+            # 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
+                )
+                # Debug: save render (only in debug mode)
+                if config and config.debug:
+                    save_section_render('overview', overview_section)
+            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()
+                # Debug: save render (only in debug mode)
+                if config and config.debug:
+                    save_section_render('stats', stats_section)
+            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()
+                # Debug: save render (only in debug mode)
+                if config and config.debug:
+                    save_section_render('system', system_section)
+            except Exception as e:
+                logger.error(f"Failed to render system section: {e}", exc_info=True)
+                system_section = None
+
+            try:
+                commands_section = CommandsSection(request).render()
+                # Debug: save render (only in debug mode)
+                if config and config.debug:
+                    save_section_render('commands', commands_section)
+            except Exception as e:
+                logger.error(f"Failed to render commands section: {e}", exc_info=True)
+                commands_section = None
+
+            # Combine all stat cards (data already loaded above)
             all_stats = user_stats + support_stats
 
             dashboard_data = DashboardData(
@@ -64,27 +153,30 @@ class UnfoldCallbacks(
                 system_health=system_health,
                 quick_actions=quick_actions,
                 last_updated=timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
-                environment=getattr(settings, "ENVIRONMENT", "development"),
+                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,
+
                 # Statistics cards
                 "cards": cards_data,
                 "user_stats": [card.to_dict() for card in user_stats],
                 "support_stats": [card.to_dict() for card in support_stats],
-                
+
                 # System health (convert to dict for template)
                 "system_health": {
                     item.component + "_status": item.status
                     for item in dashboard_data.system_health
                 },
-                
-                # System metrics
-                "system_metrics": self.get_system_metrics(),
-                
+
                 # Quick actions
                 "quick_actions": [
                     action.model_dump() for action in dashboard_data.quick_actions

django_cfg/modules/django_unfold/dashboard.py

@@ -19,16 +19,33 @@ class DashboardManager(BaseCfgModule):
     Dashboard configuration manager for Unfold.    
     """
     
-    def __init__(self):
+    def __init__(self, config=None):
         """Initialize dashboard manager."""
         super().__init__()
-        self.config = self.get_config()
-    
-    def _get_default_dropdown_items(self) -> List[Dict[str, Any]]:
+        # Lazy load config to avoid circular import during settings generation
+        self._config = config
+        self._config_loaded = config is not None
+
+    @property
+    def config(self):
+        """Lazy load config on first access."""
+        if not self._config_loaded:
+            try:
+                self._config = self.get_config()
+            except Exception:
+                # Config cannot be loaded (e.g., during settings generation)
+                # Set to None and mark as loaded to avoid repeated attempts
+                self._config = None
+            finally:
+                self._config_loaded = True
+        return self._config
+
+    @staticmethod
+    def _get_default_dropdown_items() -> List[Dict[str, Any]]:
         """Get default dropdown menu items for Unfold admin (lazy import to avoid circular imports)."""
         from django_cfg.config import get_default_dropdown_items
         dropdown_items = get_default_dropdown_items()
-        
+
         # Convert SiteDropdownItem objects to dictionaries for Unfold
         return [item.to_dict() for item in dropdown_items]
     
@@ -47,6 +64,37 @@ class DashboardManager(BaseCfgModule):
                 ]
             ),
         ]
+
+        # Add Operations section (System & Monitoring tools)
+        operations_items = []
+
+        # RPC Dashboard (if enabled)
+        if self.is_rpc_enabled():
+            operations_items.append(
+                NavigationItem(title="RPC Dashboard", icon=Icons.MONITOR_HEART, link="/cfg/admin/rpc/")
+            )
+
+        # Background Tasks (if enabled)
+        if self.should_enable_tasks():
+            operations_items.extend([
+                NavigationItem(title="Background Tasks", icon=Icons.TASK, link="/admin/django_dramatiq/task/"),
+                NavigationItem(title="Task Dashboard", icon=Icons.SETTINGS_APPLICATIONS, link="/cfg/admin/django_cfg_tasks/admin/dashboard/"),
+            ])
+
+        # Maintenance Mode (if enabled)
+        if self.is_maintenance_enabled():
+            operations_items.append(
+                NavigationItem(title="Maintenance", icon=Icons.BUILD, link="/admin/maintenance/cloudflaresite/")
+            )
+
+        # Add Operations section if there are any items
+        if operations_items:
+            navigation_sections.append(NavigationSection(
+                title="Operations",
+                separator=True,
+                collapsible=True,
+                items=operations_items
+            ))
         
         # Add Accounts section if enabled
         if self.is_accounts_enabled():
@@ -134,46 +182,20 @@ class DashboardManager(BaseCfgModule):
                     NavigationItem(title="Chat Messages", icon=Icons.MESSAGE, link="/admin/django_cfg_knowbase/chatmessage/"),
                 ]
             ))
-        
-        # Add Tasks section if knowbase or agents are enabled
-        if self.should_enable_tasks():
-            navigation_sections.append(NavigationSection(
-                title="Background Tasks",
-                separator=True,
-                collapsible=True,
-                items=[
-                    NavigationItem(title="Task Queue", icon=Icons.QUEUE, link="/admin/django_dramatiq/task/"),
-                    NavigationItem(title="Task Dashboard", icon=Icons.SETTINGS_APPLICATIONS, link="/cfg/admin/django_cfg_tasks/admin/dashboard/"),
-                ]
-            ))
-        
-        # Add Maintenance section if enabled
-        if self.is_maintenance_enabled():
-            navigation_sections.append(NavigationSection(
-                title="Maintenance Mode",
-                separator=True,
-                collapsible=True,
-                items=[
-                    NavigationItem(title="Cloudflare Sites", icon=Icons.CLOUD, link="/admin/maintenance/cloudflaresite/"),
-                    NavigationItem(title="API Keys", icon=Icons.KEY, link="/admin/maintenance/cloudflareapikey/"),
-                    NavigationItem(title="Maintenance Logs", icon=Icons.HISTORY, link="/admin/maintenance/maintenancelog/"),
-                    NavigationItem(title="Scheduled Maintenance", icon=Icons.SCHEDULE, link="/admin/maintenance/scheduledmaintenance/"),
-                ]
-            ))
-        
+
         # Add Payments section if enabled
         if self.is_payments_enabled():
             try:
                 from django_cfg.models.payments import PaymentsConfig
                 config = PaymentsConfig.get_current_config()
-                
+
                 payments_items = []
-                
+
                 # Main dashboard (always show if payments app enabled)
                 payments_items.append(
                     NavigationItem(title="Payment Dashboard", icon=Icons.DASHBOARD, link="/cfg/admin/django_cfg_payments/admin/")
                 )
-                
+
                 # Always show basic admin models (even if payments functionality is disabled)
                 payments_items.extend([
                     NavigationItem(title="Universal Payments", icon=Icons.ACCOUNT_BALANCE, link="/admin/payments/universalpayment/"),
@@ -181,7 +203,7 @@ class DashboardManager(BaseCfgModule):
                     NavigationItem(title="Networks", icon=Icons.LINK, link="/admin/payments/network/"),
                     NavigationItem(title="Provider Currencies", icon=Icons.ACCOUNT_CIRCLE, link="/admin/payments/providercurrency/"),
                 ])
-                
+
                 # Add advanced features only if payments functionality is enabled
                 if config.enabled:
                     # payments_items.append(
@@ -193,7 +215,7 @@ class DashboardManager(BaseCfgModule):
                     # payments_items.append(
                     #     NavigationItem(title="Currency Converter", icon=Icons.CURRENCY_EXCHANGE, link="/cfg/admin/django_cfg_payments/admin/tools/converter/")
                     # )
-                    
+
                     # Show subscription features only if enabled
                     if config.show_subscription_management():
                         payments_items.extend([
@@ -201,39 +223,39 @@ class DashboardManager(BaseCfgModule):
                             NavigationItem(title="Tariffs", icon=Icons.PRICE_CHANGE, link="/admin/payments/tariff/"),
                             NavigationItem(title="Tariff Endpoint Groups", icon=Icons.GROUP, link="/admin/payments/tariffendpointgroup/"),
                         ])
-                    
+
                     # Show API management only if enabled
                     if config.show_api_management():
                         payments_items.extend([
                             NavigationItem(title="API Keys", icon=Icons.KEY, link="/admin/payments/apikey/"),
                             NavigationItem(title="Endpoint Groups", icon=Icons.GROUP, link="/admin/payments/endpointgroup/"),
                         ])
-                    
+
                     # Show balance/transaction features only if enabled
                     if config.show_balance_management():
                         payments_items.append(
                             NavigationItem(title="Balances", icon=Icons.ACCOUNT_BALANCE_WALLET, link="/admin/payments/userbalance/")
                         )
-                    
+
                     if config.show_transaction_history():
                         payments_items.append(
                             NavigationItem(title="Transactions", icon=Icons.RECEIPT_LONG, link="/admin/payments/transaction/")
                         )
-                
+
             except Exception:
                 # Fallback
                 payments_items = [
                     NavigationItem(title="Payment Dashboard", icon=Icons.DASHBOARD, link="/cfg/admin/django_cfg_payments/admin/"),
                     NavigationItem(title="Universal Payments", icon=Icons.ACCOUNT_BALANCE, link="/admin/payments/universalpayment/"),
                 ]
-            
+
             navigation_sections.append(NavigationSection(
                 title="Payments",
                 separator=True,
                 collapsible=True,
                 items=payments_items
             ))
-        
+
         # Convert all NavigationSection objects to dictionaries
         return [section.to_dict() for section in navigation_sections]
         

django_cfg/modules/django_unfold/models/config.py

@@ -165,7 +165,7 @@ class UnfoldConfig(BaseModel):
     
     # Site branding
     site_title: str = Field(
-        default="ConfigToolkit Admin",
+        default="Django-CFG Admin",
         description="Site title shown in admin"
     )
     
@@ -423,19 +423,21 @@ class UnfoldConfig(BaseModel):
             "show_all_applications": self.show_all_applications,
         }
         
-        # Get default navigation from dashboard manager
+        # Get default navigation from dashboard manager first
+        nav_items = []
         try:
             from ..dashboard import DashboardManager
             dashboard = DashboardManager()
             nav_items = dashboard.get_navigation_config()
-        except ImportError:
-            nav_items = []
-        
-        # Add custom navigation from project (if defined)
+        except Exception as e:
+            # Catch all exceptions including circular imports during settings generation
+            # During settings generation, config discovery may fail - use empty nav
+            pass
+
+        # Add custom navigation from project (if defined) - appears after default
         if self.navigation:
-            # Project has custom navigation - add it first
             nav_items.extend([group.to_dict() for group in self.navigation])
-        
+
         # Add legacy navigation_items if configured
         if self.navigation_items:
             nav_items.extend(self.navigation_items)
@@ -445,13 +447,12 @@ class UnfoldConfig(BaseModel):
         
         # Add site dropdown - combine default from dashboard + project dropdown
         dropdown_items = []
-        
+
         # First add default dropdown from dashboard manager
         try:
             from ..dashboard import DashboardManager
-            dashboard = DashboardManager()
-            dropdown_items.extend(dashboard._get_default_dropdown_items())
-        except ImportError:
+            dropdown_items.extend(DashboardManager._get_default_dropdown_items())
+        except (ImportError, Exception):
             pass
         
         # Then add project-specific dropdown items

django_cfg/modules/django_unfold/models/navigation.py

@@ -55,19 +55,24 @@ class NavigationItem(BaseModel):
 class NavigationSection(BaseModel):
     """Navigation section configuration."""
     model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
+
     title: str = Field(..., min_length=1, description="Section title")
     separator: bool = Field(default=True, description="Show separator")
     collapsible: bool = Field(default=True, description="Section is collapsible")
+    open: bool = Field(default=False, description="Section is open by default")
     items: List[NavigationItem] = Field(default_factory=list, description="Navigation items")
-    
+
     def to_dict(self) -> dict:
         """Convert to dictionary for Unfold admin."""
-        return {
+        result = {
             "title": self.title,
             "separator": self.separator,
             "collapsible": self.collapsible,
             "items": [item.to_dict() for item in self.items],
         }
+        # Add open only if True (to avoid breaking existing navigation)
+        if self.open:
+            result["open"] = True
+        return result