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

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.2.7"
+__version__ = "1.2.9"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/urls.py

@@ -45,8 +45,8 @@ def get_django_cfg_urlpatterns() -> List[URLPattern]:
         #     patterns.append(path('leads/', include('django_cfg.apps.leads.urls')))
         
         # Tasks app - enabled when knowbase or agents are enabled
-        if base_module.is_tasks_enabled():
-            patterns.append(path('tasks/', include('django_cfg.apps.tasks.urls')))
+        # if base_module.is_tasks_enabled():
+        #     patterns.append(path('tasks/', include('django_cfg.apps.tasks.urls')))
             
     except Exception:
         # Fallback: include all URLs if config is not available

django_cfg/modules/django_unfold/callbacks/__init__.py

@@ -0,0 +1,9 @@
+"""
+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

@@ -0,0 +1,50 @@
+"""
+Quick actions callbacks.
+"""
+
+import logging
+from typing import List
+
+from ..models.dashboard import QuickAction
+from ..icons import Icons
+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/base.py

@@ -0,0 +1,98 @@
+"""
+Base utilities and helper functions for callbacks.
+"""
+
+import logging
+from typing import Dict, Any, List
+from django.contrib.auth import get_user_model
+from django.core.management import get_commands
+import importlib
+
+logger = logging.getLogger(__name__)
+
+
+def get_available_commands():
+    """Get all available Django management commands."""
+    commands_dict = get_commands()
+    commands_list = []
+    
+    for command_name, app_name in commands_dict.items():
+        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'):
+                    command_class = command_module.Command
+                    description = getattr(command_class, 'help', f'{command_name} command')
+                else:
+                    description = f'{command_name} command'
+            except ImportError:
+                description = f'{command_name} command'
+            
+            commands_list.append({
+                'name': command_name,
+                'app': app_name,
+                'description': description,
+                'is_core': app_name.startswith('django.'),
+                'is_custom': app_name == 'django_cfg',
+            })
+        except Exception:
+            # Skip problematic commands
+            continue
+    
+    return commands_list
+
+
+def get_commands_by_category():
+    """Get commands categorized by type."""
+    commands = get_available_commands()
+    
+    categorized = {
+        'django_cfg': [],
+        'django_core': [],
+        'third_party': [],
+        'project': [],
+    }
+    
+    for cmd in commands:
+        if cmd['app'] == 'django_cfg':
+            categorized['django_cfg'].append(cmd)
+        elif cmd['app'].startswith('django.'):
+            categorized['django_core'].append(cmd)
+        elif cmd['app'].startswith(('src.', 'api.', 'accounts.')):
+            categorized['project'].append(cmd)
+        else:
+            categorized['third_party'].append(cmd)
+    
+    return categorized
+
+
+def get_user_admin_urls():
+    """Get admin URLs for user model."""
+    try:
+        User = get_user_model()
+        
+        app_label = User._meta.app_label
+        model_name = User._meta.model_name
+        
+        return {
+            'changelist': f'admin:{app_label}_{model_name}_changelist',
+            'add': f'admin:{app_label}_{model_name}_add',
+            'change': f'admin:{app_label}_{model_name}_change/{{id}}/',
+            'delete': f'admin:{app_label}_{model_name}_delete/{{id}}/',
+            'view': f'admin:{app_label}_{model_name}_view/{{id}}/',
+        }
+    except Exception:
+        # Universal fallback - return admin index for all actions
+        return {
+            'changelist': 'admin:index',
+            'add': 'admin:index',
+            'change': 'admin:index',
+            'delete': 'admin:index',
+            'view': 'admin:index',
+        }

django_cfg/modules/django_unfold/callbacks/charts.py

@@ -0,0 +1,224 @@
+"""
+Charts data callbacks.
+"""
+
+import logging
+import random
+from typing import Dict, Any, List
+from datetime import timedelta
+
+from django.db.models import Count
+from django.utils import timezone
+from django.contrib.auth import get_user_model
+
+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

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

@@ -0,0 +1,191 @@
+"""
+Main Unfold Dashboard Callbacks
+
+Combines all callback modules into a single interface.
+"""
+
+import logging
+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 .statistics import StatisticsCallbacks
+from .system import SystemCallbacks
+from .actions import ActionsCallbacks
+from .charts import ChartsCallbacks
+from .commands import CommandsCallbacks
+from .revolution import RevolutionCallbacks
+from .users import UsersCallbacks
+from .base import get_user_admin_urls
+
+logger = logging.getLogger(__name__)
+
+
+class UnfoldCallbacks(
+    BaseCfgModule,
+    StatisticsCallbacks,
+    SystemCallbacks,
+    ActionsCallbacks,
+    ChartsCallbacks,
+    CommandsCallbacks,
+    RevolutionCallbacks,
+    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 dashboard data using Pydantic models
+            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
+            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(settings, "ENVIRONMENT", "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({
+                # 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
+                ],
+                
+                # 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"
+                ],
+                
+                # Revolution zones
+                "zones_table": {
+                    "headers": [
+                        {"label": "Zone"},
+                        {"label": "Title"},
+                        {"label": "Apps"},
+                        {"label": "Endpoints"},
+                        {"label": "Status"},
+                        {"label": "Actions"},
+                    ],
+                    "rows": self.get_revolution_zones_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)}")
+
+            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