django-cfg 1.4.110__py3-none-any.whl → 1.4.113__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.110"
+__version__ = "1.4.113"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/dashboard/serializers/__init__.py

@@ -22,6 +22,11 @@ from .commands import (
     CommandHelpResponseSerializer,
 )
 from .apizones import APIZoneSerializer, APIZonesSummarySerializer
+from .crontab import (
+    CrontabJobSerializer,
+    CrontabJobsSerializer,
+    CrontabStatusSerializer,
+)
 
 __all__ = [
     # Base
@@ -59,4 +64,9 @@ __all__ = [
     # API Zones
     'APIZoneSerializer',
     'APIZonesSummarySerializer',
+
+    # Crontab
+    'CrontabJobSerializer',
+    'CrontabJobsSerializer',
+    'CrontabStatusSerializer',
 ]

django_cfg/apps/dashboard/serializers/crontab.py

@@ -0,0 +1,84 @@
+"""
+Crontab Serializers
+
+Serializers for crontab monitoring endpoints.
+"""
+
+from rest_framework import serializers
+
+
+class CrontabJobSerializer(serializers.Serializer):
+    """
+    Serializer for individual cron job configuration.
+
+    Maps to CrontabJobConfig Pydantic model.
+    """
+
+    name = serializers.CharField(help_text="Job identifier name")
+    job_type = serializers.ChoiceField(
+        choices=['command', 'callable'],
+        help_text="Job type: Django command or Python callable"
+    )
+    command = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Management command name (for command type jobs)"
+    )
+    callable_path = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Python callable path (for callable type jobs)"
+    )
+    command_args = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        help_text="Command positional arguments"
+    )
+    command_kwargs = serializers.DictField(
+        required=False,
+        help_text="Command keyword arguments"
+    )
+    minute = serializers.CharField(help_text="Cron minute field")
+    hour = serializers.CharField(help_text="Cron hour field")
+    day_of_month = serializers.CharField(help_text="Cron day of month field")
+    month_of_year = serializers.CharField(help_text="Cron month field")
+    day_of_week = serializers.CharField(help_text="Cron day of week field")
+    enabled = serializers.BooleanField(help_text="Whether job is enabled")
+    comment = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Optional job description"
+    )
+    schedule_display = serializers.CharField(
+        required=False,
+        help_text="Human-readable schedule description"
+    )
+
+
+class CrontabJobsSerializer(serializers.Serializer):
+    """Serializer for list of all cron jobs."""
+
+    enabled = serializers.BooleanField(help_text="Whether crontab is enabled")
+    jobs_count = serializers.IntegerField(help_text="Total number of jobs")
+    enabled_jobs_count = serializers.IntegerField(help_text="Number of enabled jobs")
+    jobs = CrontabJobSerializer(many=True, help_text="List of all cron jobs")
+
+
+class CrontabStatusSerializer(serializers.Serializer):
+    """Serializer for crontab configuration status."""
+
+    enabled = serializers.BooleanField(help_text="Whether crontab is enabled")
+    jobs_count = serializers.IntegerField(help_text="Total number of jobs")
+    enabled_jobs_count = serializers.IntegerField(help_text="Number of enabled jobs")
+    lock_jobs = serializers.BooleanField(help_text="Whether job locking is enabled")
+    command_prefix = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Command prefix for all jobs"
+    )
+    comment = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Crontab configuration comment"
+    )
+    timestamp = serializers.CharField(help_text="Status check timestamp (ISO format)")

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 .crontab_service import CrontabService
 
 __all__ = [
     'StatisticsService',
@@ -19,4 +20,5 @@ __all__ = [
     'CommandsService',
     'APIZonesService',
     'OverviewService',
+    'CrontabService',
 ]

django_cfg/apps/dashboard/services/crontab_service.py

@@ -0,0 +1,210 @@
+"""
+Crontab Service
+
+Business logic for crontab/scheduled jobs monitoring and information.
+"""
+
+import logging
+from datetime import datetime
+from typing import Any, Dict, List
+
+logger = logging.getLogger(__name__)
+
+
+class CrontabService:
+    """
+    Service for crontab monitoring and information.
+
+    %%PRIORITY:HIGH%%
+    %%AI_HINT: Provides information about scheduled cron jobs%%
+
+    TAGS: crontab, scheduling, monitoring, service
+    DEPENDS_ON: [django_cfg.core.config]
+    """
+
+    def __init__(self):
+        """Initialize crontab service."""
+        self.logger = logger
+
+    def _get_schedule_display(self, job) -> str:
+        """
+        Generate human-readable schedule description.
+
+        Args:
+            job: CrontabJobConfig instance
+
+        Returns:
+            Human-readable schedule string
+        """
+        parts = []
+
+        # Minute
+        if job.minute == "*":
+            parts.append("every minute")
+        elif job.minute.startswith("*/"):
+            interval = job.minute[2:]
+            parts.append(f"every {interval} minutes")
+        else:
+            parts.append(f"at minute {job.minute}")
+
+        # Hour
+        if job.hour == "*":
+            parts.append("of every hour")
+        elif job.hour.startswith("*/"):
+            interval = job.hour[2:]
+            parts.append(f"every {interval} hours")
+        else:
+            parts.append(f"at {job.hour}:00")
+
+        # Day of month
+        if job.day_of_month != "*":
+            parts.append(f"on day {job.day_of_month}")
+
+        # Month
+        if job.month_of_year != "*":
+            months = {
+                "1": "January", "2": "February", "3": "March", "4": "April",
+                "5": "May", "6": "June", "7": "July", "8": "August",
+                "9": "September", "10": "October", "11": "November", "12": "December"
+            }
+            month_name = months.get(job.month_of_year, job.month_of_year)
+            parts.append(f"in {month_name}")
+
+        # Day of week
+        if job.day_of_week != "*":
+            days = {
+                "0": "Sunday", "1": "Monday", "2": "Tuesday", "3": "Wednesday",
+                "4": "Thursday", "5": "Friday", "6": "Saturday"
+            }
+            if "-" in job.day_of_week:
+                parts.append(f"on weekdays ({job.day_of_week})")
+            else:
+                day_name = days.get(job.day_of_week, job.day_of_week)
+                parts.append(f"on {day_name}")
+
+        return " ".join(parts)
+
+    def _format_job(self, job) -> Dict[str, Any]:
+        """
+        Format a single job for API response.
+
+        Args:
+            job: CrontabJobConfig instance
+
+        Returns:
+            Formatted job dictionary
+        """
+        job_data = {
+            'name': job.name,
+            'job_type': job.job_type,
+            'minute': job.minute,
+            'hour': job.hour,
+            'day_of_month': job.day_of_month,
+            'month_of_year': job.month_of_year,
+            'day_of_week': job.day_of_week,
+            'enabled': job.enabled,
+            'schedule_display': self._get_schedule_display(job),
+        }
+
+        # Add command or callable info
+        if job.job_type == 'command':
+            job_data['command'] = job.command
+            if job.command_args:
+                job_data['command_args'] = job.command_args
+            if job.command_kwargs:
+                job_data['command_kwargs'] = job.command_kwargs
+        else:
+            job_data['callable_path'] = job.callable_path
+
+        # Add comment if present
+        if job.comment:
+            job_data['comment'] = job.comment
+
+        return job_data
+
+    def get_all_jobs(self) -> Dict[str, Any]:
+        """
+        Get all configured cron jobs.
+
+        Returns:
+            Dictionary with jobs list and summary
+
+        USED_BY: CrontabViewSet.jobs endpoint
+        """
+        try:
+            from django_cfg.core.config import get_current_config
+
+            config = get_current_config()
+
+            # Check if crontab is configured
+            if not hasattr(config, 'crontab') or not config.crontab:
+                return {
+                    'enabled': False,
+                    'jobs_count': 0,
+                    'enabled_jobs_count': 0,
+                    'jobs': []
+                }
+
+            crontab_config = config.crontab
+
+            # Format all jobs
+            jobs = [self._format_job(job) for job in crontab_config.jobs]
+
+            # Count enabled jobs
+            enabled_jobs_count = sum(1 for job in crontab_config.jobs if job.enabled)
+
+            return {
+                'enabled': crontab_config.enabled,
+                'jobs_count': len(jobs),
+                'enabled_jobs_count': enabled_jobs_count,
+                'jobs': jobs
+            }
+
+        except Exception as e:
+            self.logger.error(f"Failed to get cron jobs: {e}", exc_info=True)
+            raise
+
+    def get_status(self) -> Dict[str, Any]:
+        """
+        Get crontab configuration status and summary.
+
+        Returns:
+            Dictionary with crontab configuration status
+
+        USED_BY: CrontabViewSet.crontab_status endpoint
+        """
+        try:
+            from django_cfg.core.config import get_current_config
+
+            config = get_current_config()
+
+            # Check if crontab is configured
+            if not hasattr(config, 'crontab') or not config.crontab:
+                return {
+                    'enabled': False,
+                    'jobs_count': 0,
+                    'enabled_jobs_count': 0,
+                    'lock_jobs': False,
+                    'command_prefix': None,
+                    'comment': None,
+                    'timestamp': datetime.now().isoformat(),
+                }
+
+            crontab_config = config.crontab
+
+            # Count enabled jobs
+            enabled_jobs_count = sum(1 for job in crontab_config.jobs if job.enabled)
+
+            return {
+                'enabled': crontab_config.enabled,
+                'jobs_count': len(crontab_config.jobs),
+                'enabled_jobs_count': enabled_jobs_count,
+                'lock_jobs': crontab_config.lock_jobs,
+                'command_prefix': crontab_config.command_prefix,
+                'comment': crontab_config.comment,
+                'timestamp': datetime.now().isoformat(),
+            }
+
+        except Exception as e:
+            self.logger.error(f"Failed to get crontab status: {e}", exc_info=True)
+            raise

django_cfg/apps/dashboard/services/system_health_service.py

@@ -191,6 +191,77 @@ class SystemHealthService:
                 'health_percentage': 0,
             }
 
+    def check_crontab_health(self) -> Dict[str, Any]:
+        """
+        Check crontab/scheduled jobs configuration and status.
+
+        Returns:
+            Health status dictionary with job count and configuration details
+        """
+        try:
+            from django_cfg.core.config import get_current_config
+
+            config = get_current_config()
+
+            # Check if crontab is configured
+            if not hasattr(config, 'crontab') or not config.crontab:
+                return {
+                    'component': 'crontab',
+                    'status': 'info',
+                    'description': 'Crontab scheduling not configured',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 100,
+                    'details': {
+                        'enabled': False,
+                        'jobs_count': 0,
+                    }
+                }
+
+            crontab_config = config.crontab
+
+            # Check if enabled
+            if not crontab_config.enabled:
+                return {
+                    'component': 'crontab',
+                    'status': 'warning',
+                    'description': 'Crontab scheduling is disabled',
+                    'last_check': datetime.now().isoformat(),
+                    'health_percentage': 50,
+                    'details': {
+                        'enabled': False,
+                        'jobs_count': len(crontab_config.jobs),
+                    }
+                }
+
+            # Count enabled jobs
+            enabled_jobs = [job for job in crontab_config.jobs if job.enabled]
+            jobs_count = len(enabled_jobs)
+
+            return {
+                'component': 'crontab',
+                'status': 'healthy',
+                'description': f'{jobs_count} scheduled job(s) configured',
+                'last_check': datetime.now().isoformat(),
+                'health_percentage': 100,
+                'details': {
+                    'enabled': True,
+                    'jobs_count': jobs_count,
+                    'total_jobs': len(crontab_config.jobs),
+                    'lock_jobs': crontab_config.lock_jobs,
+                    'comment': crontab_config.comment,
+                }
+            }
+
+        except Exception as e:
+            self.logger.error(f"Crontab health check failed: {e}")
+            return {
+                'component': 'crontab',
+                'status': 'error',
+                'description': f'Crontab 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 +276,7 @@ class SystemHealthService:
             self.check_cache_health(),
             self.check_queue_health(),
             self.check_storage_health(),
+            self.check_crontab_health(),
         ]
 
         return checks

django_cfg/apps/dashboard/urls.py

@@ -21,6 +21,7 @@ from .views import (
     ChartsViewSet,
     CommandsViewSet,
     APIZonesViewSet,
+    CrontabViewSet,
 )
 
 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'crontab', CrontabViewSet, basename='crontab')
 
 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 .crontab_views import CrontabViewSet
 
 __all__ = [
     'OverviewViewSet',
@@ -20,4 +21,5 @@ __all__ = [
     'ChartsViewSet',
     'CommandsViewSet',
     'APIZonesViewSet',
+    'CrontabViewSet',
 ]

django_cfg/apps/dashboard/views/crontab_views.py

@@ -0,0 +1,72 @@
+"""
+Crontab ViewSet
+
+Endpoints for cron job monitoring:
+- GET /crontab/jobs/ - List all configured cron jobs
+- GET /crontab/status/ - Crontab configuration status
+"""
+
+import logging
+
+from drf_spectacular.utils import extend_schema
+from rest_framework import status, viewsets
+
+from django_cfg.mixins import AdminAPIMixin
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..services import CrontabService
+from ..serializers import CrontabJobsSerializer, CrontabStatusSerializer
+
+logger = logging.getLogger(__name__)
+
+
+class CrontabViewSet(AdminAPIMixin, viewsets.GenericViewSet):
+    """
+    Crontab Monitoring ViewSet
+
+    Provides endpoints for monitoring scheduled cron jobs.
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    serializer_class = CrontabJobsSerializer
+
+    @extend_schema(
+        summary="Get all cron jobs",
+        description="Retrieve list of all configured cron jobs with schedules and details",
+        responses={200: CrontabJobsSerializer},
+        tags=["Dashboard - Crontab"]
+    )
+    @action(detail=False, methods=['get'], url_path='jobs', serializer_class=CrontabJobsSerializer)
+    def jobs(self, request):
+        """Get all configured cron jobs."""
+        try:
+            crontab_service = CrontabService()
+            jobs_data = crontab_service.get_all_jobs()
+            return Response(jobs_data)
+
+        except Exception as e:
+            logger.error(f"Crontab jobs API error: {e}", exc_info=True)
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @extend_schema(
+        summary="Get crontab status",
+        description="Retrieve crontab configuration status and summary",
+        responses={200: CrontabStatusSerializer},
+        tags=["Dashboard - Crontab"]
+    )
+    @action(detail=False, methods=['get'], url_path='status', serializer_class=CrontabStatusSerializer)
+    def crontab_status(self, request):
+        """Get crontab configuration status."""
+        try:
+            crontab_service = CrontabService()
+            status_data = crontab_service.get_status()
+            return Response(status_data)
+
+        except Exception as e:
+            logger.error(f"Crontab status API error: {e}", exc_info=True)
+            return Response({
+                'error': str(e)
+            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

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/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,
+    CrontabConfig,
     CryptoFieldsConfig,
     DatabaseConfig,
     DRFConfig,
@@ -318,6 +319,12 @@ class DjangoConfig(BaseModel):
         description="Background task processing configuration (ReArq)",
     )
 
+    # === Crontab Scheduling ===
+    crontab: Optional[CrontabConfig] = Field(
+        default=None,
+        description="Crontab scheduling configuration (django-crontab integration)",
+    )
+
     # === 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-crontab if enabled
+        if hasattr(self.config, "crontab") and self.config.crontab and self.config.crontab.enabled:
+            apps.append("django_crontab")
+
         # 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")