django-cfg 1.4.111__py3-none-any.whl → 1.4.114__py3-none-any.whl

django_cfg/__init__.py

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

django_cfg/apps/dashboard/serializers/__init__.py

@@ -22,6 +22,12 @@ from .commands import (
     CommandHelpResponseSerializer,
 )
 from .apizones import APIZoneSerializer, APIZonesSummarySerializer
+from .django_q2 import (
+    DjangoQ2ScheduleSerializer,
+    DjangoQ2TaskSerializer,
+    DjangoQ2StatusSerializer,
+    DjangoQ2SummarySerializer,
+)
 
 __all__ = [
     # Base
@@ -59,4 +65,10 @@ __all__ = [
     # API Zones
     'APIZoneSerializer',
     'APIZonesSummarySerializer',
+
+    # Django-Q2
+    'DjangoQ2ScheduleSerializer',
+    'DjangoQ2TaskSerializer',
+    'DjangoQ2StatusSerializer',
+    'DjangoQ2SummarySerializer',
 ]

django_cfg/apps/dashboard/serializers/django_q2.py

@@ -0,0 +1,50 @@
+"""
+Django-Q2 Task Serializers
+
+Serializers for displaying Django-Q2 scheduled tasks and task history.
+"""
+
+from rest_framework import serializers
+
+
+class DjangoQ2ScheduleSerializer(serializers.Serializer):
+    """Serializer for Django-Q2 scheduled tasks."""
+
+    id = serializers.IntegerField(read_only=True)
+    name = serializers.CharField(max_length=255)
+    func = serializers.CharField(max_length=512)
+    schedule_type = serializers.CharField(max_length=24)
+    repeats = serializers.IntegerField()
+    next_run = serializers.DateTimeField(allow_null=True)
+    last_run = serializers.DateTimeField(allow_null=True)
+
+
+class DjangoQ2TaskSerializer(serializers.Serializer):
+    """Serializer for Django-Q2 task execution history."""
+
+    id = serializers.CharField(max_length=32)
+    name = serializers.CharField(max_length=255)
+    func = serializers.CharField(max_length=512)
+    started = serializers.DateTimeField()
+    stopped = serializers.DateTimeField(allow_null=True)
+    success = serializers.BooleanField()
+    result = serializers.CharField(allow_null=True)
+
+
+class DjangoQ2StatusSerializer(serializers.Serializer):
+    """Serializer for Django-Q2 cluster status."""
+
+    cluster_running = serializers.BooleanField()
+    total_schedules = serializers.IntegerField()
+    active_schedules = serializers.IntegerField()
+    recent_tasks = serializers.IntegerField()
+    successful_tasks = serializers.IntegerField()
+    failed_tasks = serializers.IntegerField()
+
+
+class DjangoQ2SummarySerializer(serializers.Serializer):
+    """Summary serializer for Django-Q2 dashboard."""
+
+    status = DjangoQ2StatusSerializer()
+    schedules = DjangoQ2ScheduleSerializer(many=True)
+    recent_tasks = DjangoQ2TaskSerializer(many=True)

django_cfg/apps/dashboard/serializers/overview.py

@@ -5,30 +5,41 @@ Serializers for dashboard overview endpoint.
 """
 
 from rest_framework import serializers
+from .statistics import StatCardSerializer, UserStatisticsSerializer, AppStatisticsSerializer
+from .system import SystemHealthSerializer, SystemMetricsSerializer
+from .activity import QuickActionSerializer, ActivityEntrySerializer
 
 
 class DashboardOverviewSerializer(serializers.Serializer):
     """
     Main serializer for dashboard overview endpoint.
-    Uses DictField to avoid allOf generation in OpenAPI.
+    Uses typed serializers for proper OpenAPI schema generation.
     """
 
-    stat_cards = serializers.ListField(
-        child=serializers.DictField(),
+    stat_cards = StatCardSerializer(
+        many=True,
         help_text="Dashboard statistics cards"
     )
-    system_health = serializers.ListField(
-        child=serializers.DictField(),
+    system_health = SystemHealthSerializer(
         help_text="System health status"
     )
-    quick_actions = serializers.ListField(
-        child=serializers.DictField(),
+    quick_actions = QuickActionSerializer(
+        many=True,
         help_text="Quick action buttons"
     )
-    recent_activity = serializers.ListField(
-        child=serializers.DictField(),
+    recent_activity = ActivityEntrySerializer(
+        many=True,
         help_text="Recent activity entries"
     )
-    system_metrics = serializers.DictField(help_text="System performance metrics")
-    user_statistics = serializers.DictField(help_text="User statistics")
+    system_metrics = SystemMetricsSerializer(
+        help_text="System performance metrics"
+    )
+    user_statistics = UserStatisticsSerializer(
+        help_text="User statistics"
+    )
+    app_statistics = AppStatisticsSerializer(
+        many=True,
+        required=False,
+        help_text="Application statistics"
+    )
     timestamp = serializers.CharField(help_text="Data timestamp (ISO format)")

django_cfg/apps/dashboard/services/__init__.py

@@ -11,6 +11,7 @@ from .charts_service import ChartsService
 from .commands_service import CommandsService
 from .apizones_service import APIZonesService
 from .overview_service import OverviewService
+from .django_q2_service import DjangoQ2Service
 
 __all__ = [
     'StatisticsService',
@@ -19,4 +20,5 @@ __all__ = [
     'CommandsService',
     'APIZonesService',
     'OverviewService',
+    'DjangoQ2Service',
 ]

django_cfg/apps/dashboard/services/django_q2_service.py

@@ -0,0 +1,159 @@
+"""
+Django-Q2 Service
+
+Business logic for collecting Django-Q2 task data.
+"""
+
+from typing import Dict, List, Any
+
+
+class DjangoQ2Service:
+    """Service for aggregating Django-Q2 task information."""
+
+    @staticmethod
+    def get_schedules() -> List[Dict[str, Any]]:
+        """
+        Get all scheduled tasks from Django-Q2.
+
+        Returns:
+            List of scheduled tasks with their configurations
+        """
+        try:
+            from django_q.models import Schedule
+
+            schedules = Schedule.objects.all().order_by('-next_run')
+            return [
+                {
+                    'id': schedule.id,
+                    'name': schedule.name,
+                    'func': schedule.func,
+                    'schedule_type': schedule.schedule_type,
+                    'repeats': schedule.repeats,
+                    'next_run': schedule.next_run,
+                    'last_run': getattr(schedule, 'last_run', None),
+                }
+                for schedule in schedules
+            ]
+        except ImportError:
+            # django-q2 not installed
+            return []
+        except Exception:
+            # Database error or table doesn't exist yet
+            return []
+
+    @staticmethod
+    def get_recent_tasks(limit: int = 20) -> List[Dict[str, Any]]:
+        """
+        Get recent task executions from Django-Q2.
+
+        Args:
+            limit: Maximum number of tasks to return
+
+        Returns:
+            List of recent task executions with their results
+        """
+        try:
+            from django_q.models import Task
+
+            tasks = Task.objects.all().order_by('-started')[:limit]
+            return [
+                {
+                    'id': task.id,
+                    'name': task.name,
+                    'func': task.func,
+                    'started': task.started,
+                    'stopped': task.stopped,
+                    'success': task.success,
+                    'result': str(task.result) if task.result else None,
+                }
+                for task in tasks
+            ]
+        except ImportError:
+            # django-q2 not installed
+            return []
+        except Exception:
+            # Database error or table doesn't exist yet
+            return []
+
+    @staticmethod
+    def get_cluster_status() -> Dict[str, Any]:
+        """
+        Get Django-Q2 cluster status.
+
+        Returns:
+            Dictionary with cluster status information
+        """
+        try:
+            from django_q.models import Schedule, Task
+            from django_q.cluster import Cluster
+
+            # Count schedules
+            total_schedules = Schedule.objects.count()
+            active_schedules = Schedule.objects.filter(repeats__gt=0).count()
+
+            # Count recent tasks (last 24 hours)
+            from django.utils import timezone
+            from datetime import timedelta
+
+            last_24h = timezone.now() - timedelta(hours=24)
+            recent_tasks = Task.objects.filter(started__gte=last_24h).count()
+            successful_tasks = Task.objects.filter(
+                started__gte=last_24h, success=True
+            ).count()
+            failed_tasks = Task.objects.filter(
+                started__gte=last_24h, success=False
+            ).count()
+
+            # Check if cluster is running
+            cluster_running = False
+            try:
+                # Check for recent task activity as proxy for cluster status
+                recent_task = Task.objects.filter(
+                    started__gte=timezone.now() - timedelta(minutes=5)
+                ).exists()
+                cluster_running = recent_task
+            except Exception:
+                pass
+
+            return {
+                'cluster_running': cluster_running,
+                'total_schedules': total_schedules,
+                'active_schedules': active_schedules,
+                'recent_tasks': recent_tasks,
+                'successful_tasks': successful_tasks,
+                'failed_tasks': failed_tasks,
+            }
+        except ImportError:
+            # django-q2 not installed
+            return {
+                'cluster_running': False,
+                'total_schedules': 0,
+                'active_schedules': 0,
+                'recent_tasks': 0,
+                'successful_tasks': 0,
+                'failed_tasks': 0,
+            }
+        except Exception:
+            # Database error or table doesn't exist yet
+            return {
+                'cluster_running': False,
+                'total_schedules': 0,
+                'active_schedules': 0,
+                'recent_tasks': 0,
+                'successful_tasks': 0,
+                'failed_tasks': 0,
+            }
+
+    @classmethod
+    def get_summary(cls) -> Dict[str, Any]:
+        """
+        Get complete Django-Q2 summary for dashboard.
+
+        Returns:
+            Dictionary with status, schedules, and recent tasks
+        """
+        return {
+            'status': cls.get_cluster_status(),
+            'schedules': cls.get_schedules(),
+            'recent_tasks': cls.get_recent_tasks(limit=10),
+        }

django_cfg/apps/dashboard/services/system_health_service.py

@@ -191,6 +191,90 @@ class SystemHealthService:
                 'health_percentage': 0,
             }
 
+    def check_django_q2_health(self) -> Dict[str, Any]:
+        """
+        Check Django-Q2 task scheduling configuration and status.
+
+        Returns:
+            Health status dictionary with schedule count and cluster status
+        """
+        try:
+            from django_cfg.core.config import get_current_config
+
+            config = get_current_config()
+
+            # Check if django_q2 is configured
+            if not hasattr(config, 'django_q2') or not config.django_q2:
+                return {
+                    'component': 'django_q2',
+                    'status': 'info',
+                    'description': 'Django-Q2 scheduling not configured',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 100,
+                    'details': {
+                        'enabled': False,
+                        'schedules_count': 0,
+                    }
+                }
+
+            django_q2_config = config.django_q2
+
+            # Check if enabled
+            if not django_q2_config.enabled:
+                return {
+                    'component': 'django_q2',
+                    'status': 'warning',
+                    'description': 'Django-Q2 scheduling is disabled',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 50,
+                    'details': {
+                        'enabled': False,
+                        'schedules_count': len(django_q2_config.schedules) if django_q2_config.schedules else 0,
+                    }
+                }
+
+            # Count schedules
+            schedules_count = len(django_q2_config.schedules) if django_q2_config.schedules else 0
+
+            # Try to check cluster status from database
+            cluster_running = False
+            try:
+                from django_q.models import Schedule, Task
+                from django.utils import timezone
+                from datetime import timedelta
+
+                # Check for recent task activity
+                recent_task = Task.objects.filter(
+                    started__gte=timezone.now() - timedelta(minutes=5)
+                ).exists()
+                cluster_running = recent_task
+            except Exception:
+                pass
+
+            return {
+                'component': 'django_q2',
+                'status': 'healthy',
+                'description': f'{schedules_count} schedule(s) configured, cluster {"running" if cluster_running else "idle"}',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 100,
+                'details': {
+                    'enabled': True,
+                    'schedules_count': schedules_count,
+                    'cluster_running': cluster_running,
+                    'workers': django_q2_config.workers,
+                }
+            }
+
+        except Exception as e:
+            self.logger.error(f"Django-Q2 health check failed: {e}")
+            return {
+                'component': 'django_q2',
+                'status': 'error',
+                'description': f'Django-Q2 check error: {str(e)}',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 0,
+            }
+
     def get_all_health_checks(self) -> List[Dict[str, Any]]:
         """
         Run all health checks and return aggregated results.
@@ -205,6 +289,7 @@ class SystemHealthService:
             self.check_cache_health(),
             self.check_queue_health(),
             self.check_storage_health(),
+            self.check_django_q2_health(),
         ]
 
         return checks

django_cfg/apps/dashboard/urls.py

@@ -21,6 +21,7 @@ from .views import (
     ChartsViewSet,
     CommandsViewSet,
     APIZonesViewSet,
+    DjangoQ2ViewSet,
 )
 
 app_name = 'django_cfg_dashboard'
@@ -34,6 +35,7 @@ router.register(r'activity', ActivityViewSet, basename='activity')
 router.register(r'charts', ChartsViewSet, basename='charts')
 router.register(r'commands', CommandsViewSet, basename='commands')
 router.register(r'zones', APIZonesViewSet, basename='zones')
+router.register(r'django_q2', DjangoQ2ViewSet, basename='django_q2')
 
 urlpatterns = [
     # RESTful API endpoints using ViewSets

django_cfg/apps/dashboard/views/__init__.py

@@ -11,6 +11,7 @@ from .activity_views import ActivityViewSet
 from .charts_views import ChartsViewSet
 from .commands_views import CommandsViewSet
 from .apizones_views import APIZonesViewSet
+from .django_q2_views import DjangoQ2ViewSet
 
 __all__ = [
     'OverviewViewSet',
@@ -20,4 +21,5 @@ __all__ = [
     'ChartsViewSet',
     'CommandsViewSet',
     'APIZonesViewSet',
+    'DjangoQ2ViewSet',
 ]

django_cfg/apps/dashboard/views/django_q2_views.py

@@ -0,0 +1,79 @@
+"""
+Django-Q2 ViewSet
+
+API endpoints for Django-Q2 task monitoring.
+"""
+
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+
+from ..services.django_q2_service import DjangoQ2Service
+from ..serializers.django_q2 import (
+    DjangoQ2ScheduleSerializer,
+    DjangoQ2TaskSerializer,
+    DjangoQ2StatusSerializer,
+    DjangoQ2SummarySerializer,
+)
+
+
+class DjangoQ2ViewSet(viewsets.ViewSet):
+    """
+    ViewSet for Django-Q2 task monitoring.
+
+    Provides endpoints for:
+    - Scheduled tasks list
+    - Recent task executions
+    - Cluster status
+    - Complete summary
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    @action(detail=False, methods=['get'])
+    def schedules(self, request):
+        """
+        Get all scheduled tasks.
+
+        GET /api/django_q2/schedules/
+        """
+        schedules = DjangoQ2Service.get_schedules()
+        serializer = DjangoQ2ScheduleSerializer(schedules, many=True)
+        return Response(serializer.data)
+
+    @action(detail=False, methods=['get'])
+    def tasks(self, request):
+        """
+        Get recent task executions.
+
+        GET /api/django_q2/tasks/
+        Query params:
+            - limit: Number of tasks to return (default: 20)
+        """
+        limit = int(request.query_params.get('limit', 20))
+        tasks = DjangoQ2Service.get_recent_tasks(limit=limit)
+        serializer = DjangoQ2TaskSerializer(tasks, many=True)
+        return Response(serializer.data)
+
+    @action(detail=False, methods=['get'])
+    def status(self, request):
+        """
+        Get Django-Q2 cluster status.
+
+        GET /api/django_q2/status/
+        """
+        status_data = DjangoQ2Service.get_cluster_status()
+        serializer = DjangoQ2StatusSerializer(status_data)
+        return Response(serializer.data)
+
+    def list(self, request):
+        """
+        Get complete Django-Q2 summary.
+
+        GET /api/django_q2/
+        Returns status, schedules, and recent tasks.
+        """
+        summary = DjangoQ2Service.get_summary()
+        serializer = DjangoQ2SummarySerializer(summary)
+        return Response(serializer.data)

django_cfg/apps/dashboard/views/overview_views.py

@@ -56,14 +56,28 @@ class OverviewViewSet(AdminAPIMixin, viewsets.GenericViewSet):
             health_service = SystemHealthService()
             charts_service = ChartsService()
 
+            # Get app statistics and convert to list format
+            app_stats_dict = stats_service.get_app_statistics()
+            app_statistics_list = [
+                {
+                    'app_name': app_label,
+                    'statistics': {
+                        'name': app_data.get('name', ''),
+                        'total_records': app_data.get('total_records', 0),
+                        'model_count': app_data.get('model_count', 0),
+                    }
+                }
+                for app_label, app_data in app_stats_dict.get('apps', {}).items()
+            ]
+
             data = {
                 # Statistics
                 'stat_cards': stats_service.get_stat_cards(),
                 'user_statistics': stats_service.get_user_statistics(),
-                'app_statistics': stats_service.get_app_statistics(),
+                'app_statistics': app_statistics_list,
 
                 # System
-                'system_health': health_service.get_all_health_checks(),
+                'system_health': health_service.get_overall_health_status(),
                 'system_metrics': stats_service.get_system_metrics(),
 
                 # Activity

django_cfg/apps/tasks/migrations/0002_delete_tasklog.py

@@ -0,0 +1,16 @@
+# Generated by Django 5.2.7 on 2025-10-31 05:54
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("tasks", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.DeleteModel(
+            name="TaskLog",
+        ),
+    ]

django_cfg/config.py

@@ -12,15 +12,14 @@ from .modules.django_unfold.models.dropdown import SiteDropdownItem
 # Library configuration
 LIB_NAME = "django-cfg"
 LIB_SITE_URL = "https://djangocfg.com"
-LIB_DOCS_URL = "https://docs.djangocfg.com"
 LIB_GITHUB_URL = "https://github.com/django-cfg/django-cfg"
-LIB_SUPPORT_URL = "https://djangocfg.com/support"
+LIB_SUPPORT_URL = "https://demo.djangocfg.com"
 LIB_HEALTH_URL = "/cfg/health/"
 
 def get_maintenance_url(domain: str) -> str:
     """Get the maintenance URL for the current site."""
     # return f"{LIB_SITE_URL}/maintenance/{domain}/"
-    return f"{LIB_DOCS_URL}/maintenance?site={domain}"
+    return f"{LIB_SITE_URL}/maintenance?site={domain}"
 
 def get_default_dropdown_items() -> List[SiteDropdownItem]:
     """Get default dropdown menu items for Unfold admin."""
@@ -28,7 +27,7 @@ def get_default_dropdown_items() -> List[SiteDropdownItem]:
         SiteDropdownItem(
             title="Documentation",
             icon=Icons.HELP_OUTLINE,
-            link=LIB_DOCS_URL,
+            link=LIB_SITE_URL,
         ),
         SiteDropdownItem(
             title="GitHub",

django_cfg/core/base/config_model.py

@@ -20,6 +20,7 @@ from ...models import (
     ApiKeys,
     AxesConfig,
     CacheConfig,
+    DjangoQ2Config,
     CryptoFieldsConfig,
     DatabaseConfig,
     DRFConfig,
@@ -216,9 +217,19 @@ class DjangoConfig(BaseModel):
     )
 
     # === Cache Configuration ===
+    # Redis URL - used for automatic cache configuration if cache_default is not set
+    redis_url: Optional[str] = Field(
+        default=None,
+        description=(
+            "Redis connection URL (redis://host:port/db). "
+            "If set and cache_default is None, automatically creates RedisCache backend. "
+            "Also used by tasks (ReArq, Django-Q2) if they don't specify broker_url."
+        ),
+    )
+
     cache_default: Optional[CacheConfig] = Field(
         default=None,
-        description="Default cache backend",
+        description="Default cache backend (auto-created from redis_url if not set)",
     )
 
     cache_sessions: Optional[CacheConfig] = Field(
@@ -318,6 +329,12 @@ class DjangoConfig(BaseModel):
         description="Background task processing configuration (ReArq)",
     )
 
+    # === Django-Q2 Task Scheduling ===
+    django_q2: Optional[DjangoQ2Config] = Field(
+        default=None,
+        description="Django-Q2 task scheduling and queue configuration",
+    )
+
     # === Centrifugo Configuration ===
     centrifugo: Optional[DjangoCfgCentrifugoConfig] = Field(
         default=None,

django_cfg/core/builders/apps_builder.py

@@ -163,6 +163,10 @@ class InstalledAppsBuilder:
             # No external app needed - ReArq is embedded
             apps.append("django_cfg.apps.tasks")
 
+        # Add django-q2 if enabled
+        if hasattr(self.config, "django_q2") and self.config.django_q2 and self.config.django_q2.enabled:
+            apps.append("django_q")
+
         # Add DRF Tailwind theme module (uses Tailwind via CDN)
         if self.config.enable_drf_tailwind:
             apps.append("django_cfg.modules.django_drf_theme.apps.DjangoDRFThemeConfig")