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

django_cfg/apps/maintenance/admin/scheduled_admin.py

@@ -1,41 +1,51 @@
 """
-Admin interface for ScheduledMaintenance with Unfold styling.
+ScheduledMaintenance admin using Django Admin Utilities.
 
-Provides comprehensive management of scheduled maintenance events.
+Enhanced scheduled maintenance management with Material Icons and optimized queries.
 """
 
-from django.contrib import admin
-from django.utils.html import format_html
+from django.contrib import admin, messages
 from django.http import HttpRequest, HttpResponse
 from django.shortcuts import redirect
-from django.contrib import messages
 from django.utils import timezone
 from django.urls import path, reverse
 from django.template.response import TemplateResponse
+from django.db import models
+from django.db.models import Count, Q
 from typing import Any
-
 from unfold.admin import ModelAdmin
-from unfold.decorators import display, action
-from unfold.enums import ActionVariant
+
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    StatusBadgeConfig,
+    DateTimeDisplayConfig,
+    Icons,
+    ActionVariant,
+    display,
+    action
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
 
 from ..models import ScheduledMaintenance, CloudflareSite
 
 
 @admin.register(ScheduledMaintenance)
-class ScheduledMaintenanceAdmin(ModelAdmin):
-    """Admin for ScheduledMaintenance with Unfold styling."""
+class ScheduledMaintenanceAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Admin for ScheduledMaintenance using Django Admin Utilities."""
     
     list_display = [
         "status_display",
-        "title",
-        "scheduled_start",
+        "title_display",
+        "scheduled_start_display",
         "duration_display",
         "sites_count",
-        "priority_badge",
-        "auto_flags",
-        "created_at",
+        "priority_display",
+        "auto_flags_display",
+        "created_at_display",
     ]
-    list_display_links = ["title"]
+    list_display_links = ["title_display"]
+    ordering = ["-scheduled_start"]
     search_fields = ["title", "description", "maintenance_message"]
     list_filter = [
         "status", 
@@ -45,346 +55,247 @@ class ScheduledMaintenanceAdmin(ModelAdmin):
         "scheduled_start",
         "created_at"
     ]
-    ordering = ["-scheduled_start"]
     
     fieldsets = [
-        ("Basic Information", {
-            'fields': ['title', 'description', 'priority', 'created_by']
+        ("📋 Basic Information", {
+            "fields": ["title", "description"],
+            "classes": ("tab",)
         }),
-        ("Scheduling", {
-            'fields': ['scheduled_start', 'estimated_duration', 'scheduled_end']
+        ("⏰ Scheduling", {
+            "fields": ["scheduled_start", "duration_minutes"],
+            "classes": ("tab",)
         }),
-        ("Sites", {
-            'fields': ['sites']
+        ("🌐 Sites", {
+            "fields": ["sites"],
+            "classes": ("tab",)
         }),
-        ("Configuration", {
-            'fields': ['maintenance_message', 'template', 'auto_enable', 'auto_disable']
+        ("⚙️ Settings", {
+            "fields": ["priority", "auto_enable", "auto_disable"],
+            "classes": ("tab",)
         }),
-        ("Notifications", {
-            'fields': ['notify_before', 'notify_on_start', 'notify_on_complete'],
-            'classes': ['collapse']
+        ("💬 Messages", {
+            "fields": ["maintenance_message"],
+            "classes": ("tab", "collapse")
         }),
-        ("Execution Status", {
-            'fields': ['status', 'actual_start', 'actual_end'],
-            'classes': ['collapse']
+        ("📊 Status", {
+            "fields": ["status"],
+            "classes": ("tab",)
         }),
-        ("Execution Log", {
-            'fields': ['execution_log'],
-            'classes': ['collapse']
+        ("⏰ Timestamps", {
+            "fields": ["created_at", "updated_at"],
+            "classes": ("tab", "collapse")
         }),
     ]
     
-    readonly_fields = ['scheduled_end', 'actual_start', 'actual_end', 'execution_log']
-    
-    filter_horizontal = ['sites']
+    filter_horizontal = ["sites"]
     
     actions = [
-        'start_maintenance_action',
-        'complete_maintenance_action', 
-        'cancel_maintenance_action',
-        'duplicate_maintenance_action'
+        "execute_maintenance_action",
+        "cancel_maintenance_action",
+        "reschedule_maintenance_action"
     ]
     
-    def get_urls(self):
-        """Add custom admin URLs."""
-        urls = super().get_urls()
-        custom_urls = [
-            path(
-                'calendar/',
-                self.admin_site.admin_view(self.calendar_view),
-                name='scheduled_maintenance_calendar'
-            ),
-            path(
-                '<int:object_id>/start/',
-                self.admin_site.admin_view(self.start_maintenance_view),
-                name='scheduled_maintenance_start'
-            ),
-            path(
-                '<int:object_id>/complete/',
-                self.admin_site.admin_view(self.complete_maintenance_view),
-                name='scheduled_maintenance_complete'
-            ),
-        ]
-        return custom_urls + urls
-    
     @display(description="Status")
     def status_display(self, obj: ScheduledMaintenance) -> str:
-        """Display status with colored badge and timing info."""
-        status_config = {
-            ScheduledMaintenance.Status.SCHEDULED: {
-                'emoji': '📅',
-                'color': 'blue',
-                'text': 'Scheduled'
-            },
-            ScheduledMaintenance.Status.ACTIVE: {
-                'emoji': '🔧',
-                'color': 'orange',
-                'text': 'Active'
-            },
-            ScheduledMaintenance.Status.COMPLETED: {
-                'emoji': '✅',
-                'color': 'green',
-                'text': 'Completed'
-            },
-            ScheduledMaintenance.Status.CANCELLED: {
-                'emoji': '❌',
-                'color': 'red',
-                'text': 'Cancelled'
-            },
-            ScheduledMaintenance.Status.FAILED: {
-                'emoji': '💥',
-                'color': 'red',
-                'text': 'Failed'
-            },
+        """Display status with badge."""
+        status_variants = {
+            ScheduledMaintenance.Status.SCHEDULED: 'warning',
+            ScheduledMaintenance.Status.ACTIVE: 'info',
+            ScheduledMaintenance.Status.COMPLETED: 'success',
+            ScheduledMaintenance.Status.CANCELLED: 'secondary',
+            ScheduledMaintenance.Status.FAILED: 'danger'
         }
+        variant = status_variants.get(obj.status, 'secondary')
         
-        config = status_config.get(obj.status, {
-            'emoji': '❓',
-            'color': 'gray',
-            'text': obj.get_status_display()
-        })
-        
-        # Add timing info
-        timing_info = ""
-        if obj.status == ScheduledMaintenance.Status.SCHEDULED:
-            if obj.is_due:
-                timing_info = " <small>(Due now!)</small>"
-            elif obj.time_until_start:
-                hours = int(obj.time_until_start.total_seconds() // 3600)
-                if hours < 24:
-                    timing_info = f" <small>(in {hours}h)</small>"
-        elif obj.status == ScheduledMaintenance.Status.ACTIVE:
-            if obj.is_overdue:
-                timing_info = " <small>(Overdue!)</small>"
-            elif obj.time_until_end:
-                hours = int(obj.time_until_end.total_seconds() // 3600)
-                minutes = int((obj.time_until_end.total_seconds() % 3600) // 60)
-                timing_info = f" <small>({hours}h {minutes}m left)</small>"
+        status_icons = {
+            ScheduledMaintenance.Status.SCHEDULED: Icons.SCHEDULE,
+            ScheduledMaintenance.Status.ACTIVE: Icons.PLAY_ARROW,
+            ScheduledMaintenance.Status.COMPLETED: Icons.CHECK_CIRCLE,
+            ScheduledMaintenance.Status.CANCELLED: Icons.CANCEL,
+            ScheduledMaintenance.Status.FAILED: Icons.ERROR
+        }
+        icon = status_icons.get(obj.status, Icons.HELP)
         
-        return format_html(
-            '<span style="color: {};">{} {}</span>{}',
-            config['color'],
-            config['emoji'],
-            config['text'],
-            timing_info
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=obj.get_status_display(),
+            variant=variant,
+            config=config
         )
     
+    @display(description="Title", ordering="title")
+    def title_display(self, obj: ScheduledMaintenance) -> str:
+        """Display maintenance title."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.EVENT)
+        return StatusBadge.create(
+            text=obj.title,
+            variant="primary",
+            config=config
+        )
+    
+    @display(description="Scheduled Start")
+    def scheduled_start_display(self, obj: ScheduledMaintenance) -> str:
+        """Display scheduled start time."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'scheduled_start', config)
+    
     @display(description="Duration")
     def duration_display(self, obj: ScheduledMaintenance) -> str:
-        """Display estimated vs actual duration."""
-        estimated_hours = obj.estimated_duration.total_seconds() / 3600
-        
-        if obj.actual_duration:
-            actual_hours = obj.actual_duration.total_seconds() / 3600
-            return format_html(
-                '{:.1f}h <small>(actual: {:.1f}h)</small>',
-                estimated_hours,
-                actual_hours
-            )
-        
-        return f"{estimated_hours:.1f}h"
+        """Display maintenance duration."""
+        if obj.duration_minutes < 60:
+            return f"{obj.duration_minutes} min"
+        else:
+            hours = obj.duration_minutes // 60
+            minutes = obj.duration_minutes % 60
+            if minutes == 0:
+                return f"{hours}h"
+            else:
+                return f"{hours}h {minutes}m"
     
     @display(description="Sites")
     def sites_count(self, obj: ScheduledMaintenance) -> str:
-        """Display sites count with link."""
-        count = obj.affected_sites_count
+        """Display count of affected sites."""
+        count = obj.sites.count()
         if count == 0:
-            return format_html('<span style="color: red;">No sites</span>')
-        
-        return format_html(
-            '<span class="badge badge-info">{} sites</span>',
-            count
-        )
+            return "No sites"
+        elif count == 1:
+            return "1 site"
+        else:
+            return f"{count} sites"
     
     @display(description="Priority")
-    def priority_badge(self, obj: ScheduledMaintenance) -> str:
-        """Display priority badge."""
-        priority_config = {
-            'low': {'color': 'green', 'emoji': '🟢'},
-            'normal': {'color': 'blue', 'emoji': '🟡'},
-            'high': {'color': 'orange', 'emoji': '🟠'},
-            'critical': {'color': 'red', 'emoji': '🔴'},
+    def priority_display(self, obj: ScheduledMaintenance) -> str:
+        """Display priority with badge."""
+        priority_variants = {
+            ScheduledMaintenance.Priority.LOW: 'secondary',
+            ScheduledMaintenance.Priority.MEDIUM: 'info',
+            ScheduledMaintenance.Priority.HIGH: 'warning',
+            ScheduledMaintenance.Priority.CRITICAL: 'danger'
         }
+        variant = priority_variants.get(obj.priority, 'secondary')
         
-        config = priority_config.get(obj.priority, {'color': 'gray', 'emoji': '⚪'})
+        priority_icons = {
+            ScheduledMaintenance.Priority.LOW: Icons.KEYBOARD_ARROW_DOWN,
+            ScheduledMaintenance.Priority.MEDIUM: Icons.REMOVE,
+            ScheduledMaintenance.Priority.HIGH: Icons.KEYBOARD_ARROW_UP,
+            ScheduledMaintenance.Priority.CRITICAL: Icons.PRIORITY_HIGH
+        }
+        icon = priority_icons.get(obj.priority, Icons.HELP)
         
-        return format_html(
-            '<span style="color: {};">{} {}</span>',
-            config['color'],
-            config['emoji'],
-            obj.get_priority_display()
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=obj.get_priority_display(),
+            variant=variant,
+            config=config
         )
     
-    @display(description="Auto")
-    def auto_flags(self, obj: ScheduledMaintenance) -> str:
-        """Display automation flags."""
+    @display(description="Auto Flags")
+    def auto_flags_display(self, obj: ScheduledMaintenance) -> str:
+        """Display auto enable/disable flags."""
         flags = []
-        
         if obj.auto_enable:
-            flags.append('<span style="color: green;">▶️ Start</span>')
-        
+            flags.append("Auto Enable")
         if obj.auto_disable:
-            flags.append('<span style="color: blue;">⏹️ Stop</span>')
+            flags.append("Auto Disable")
         
         if not flags:
-            return '<span style="color: gray;">Manual</span>'
+            return "Manual"
         
-        return format_html(' '.join(flags))
+        return " | ".join(flags)
     
-    @action(description="Start Maintenance", variant=ActionVariant.SUCCESS)
-    def start_maintenance_action(self, request: HttpRequest, queryset: Any) -> None:
-        """Start selected maintenance events."""
-        started = 0
-        failed = 0
-        
-        for maintenance in queryset:
-            if maintenance.status == ScheduledMaintenance.Status.SCHEDULED:
-                try:
-                    result = maintenance.start_maintenance()
-                    if result['success']:
-                        started += 1
-                    else:
-                        failed += 1
-                except Exception as e:
-                    failed += 1
-                    messages.error(request, f"Failed to start {maintenance.title}: {e}")
-        
-        if started > 0:
-            messages.success(request, f"Started {started} maintenance events")
-        if failed > 0:
-            messages.error(request, f"Failed to start {failed} maintenance events")
+    @display(description="Created")
+    def created_at_display(self, obj: ScheduledMaintenance) -> str:
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
     
-    @action(description="Complete Maintenance", variant=ActionVariant.PRIMARY)
-    def complete_maintenance_action(self, request: HttpRequest, queryset: Any) -> None:
-        """Complete selected maintenance events."""
-        completed = 0
-        failed = 0
+    @action(description="Execute maintenance", variant=ActionVariant.WARNING)
+    def execute_maintenance_action(self, request: HttpRequest, queryset) -> None:
+        """Execute selected maintenance tasks."""
+        scheduled_count = queryset.filter(status=ScheduledMaintenance.Status.SCHEDULED).count()
+        if scheduled_count == 0:
+            messages.error(request, "No scheduled maintenance tasks selected.")
+            return
         
-        for maintenance in queryset:
-            if maintenance.status == ScheduledMaintenance.Status.ACTIVE:
-                try:
-                    result = maintenance.complete_maintenance()
-                    if result['success']:
-                        completed += 1
-                    else:
-                        failed += 1
-                except Exception as e:
-                    failed += 1
-                    messages.error(request, f"Failed to complete {maintenance.title}: {e}")
+        # Update status to active
+        queryset.filter(status=ScheduledMaintenance.Status.SCHEDULED).update(
+            status=ScheduledMaintenance.Status.ACTIVE
+        )
         
-        if completed > 0:
-            messages.success(request, f"Completed {completed} maintenance events")
-        if failed > 0:
-            messages.error(request, f"Failed to complete {failed} maintenance events")
+        messages.success(request, f"Started execution of {scheduled_count} maintenance tasks.")
     
-    @action(description="Cancel Maintenance", variant=ActionVariant.DANGER)
-    def cancel_maintenance_action(self, request: HttpRequest, queryset: Any) -> None:
-        """Cancel selected maintenance events."""
-        cancelled = 0
-        
-        for maintenance in queryset:
-            if maintenance.status in [ScheduledMaintenance.Status.SCHEDULED, ScheduledMaintenance.Status.ACTIVE]:
-                try:
-                    result = maintenance.cancel_maintenance(reason="Cancelled via admin")
-                    if result['success']:
-                        cancelled += 1
-                except Exception as e:
-                    messages.error(request, f"Failed to cancel {maintenance.title}: {e}")
+    @action(description="Cancel maintenance", variant=ActionVariant.DANGER)
+    def cancel_maintenance_action(self, request: HttpRequest, queryset) -> None:
+        """Cancel selected maintenance tasks."""
+        cancelable_count = queryset.filter(
+            status__in=[ScheduledMaintenance.Status.SCHEDULED, ScheduledMaintenance.Status.ACTIVE]
+        ).count()
         
-        if cancelled > 0:
-            messages.success(request, f"Cancelled {cancelled} maintenance events")
-    
-    @action(description="Duplicate Maintenance")
-    def duplicate_maintenance_action(self, request: HttpRequest, queryset: Any) -> None:
-        """Duplicate selected maintenance events."""
-        duplicated = 0
+        if cancelable_count == 0:
+            messages.error(request, "No cancelable maintenance tasks selected.")
+            return
         
-        for maintenance in queryset:
-            try:
-                # Create duplicate with new start time (1 week later)
-                new_start = maintenance.scheduled_start + timezone.timedelta(weeks=1)
-                
-                duplicate = ScheduledMaintenance.objects.create(
-                    title=f"{maintenance.title} (Copy)",
-                    description=maintenance.description,
-                    scheduled_start=new_start,
-                    estimated_duration=maintenance.estimated_duration,
-                    maintenance_message=maintenance.maintenance_message,
-                    template=maintenance.template,
-                    priority=maintenance.priority,
-                    auto_enable=maintenance.auto_enable,
-                    auto_disable=maintenance.auto_disable,
-                    notify_before=maintenance.notify_before,
-                    created_by=f"{maintenance.created_by} (duplicate)"
-                )
-                
-                # Copy sites
-                duplicate.sites.set(maintenance.sites.all())
-                duplicated += 1
-                
-            except Exception as e:
-                messages.error(request, f"Failed to duplicate {maintenance.title}: {e}")
+        queryset.filter(
+            status__in=[ScheduledMaintenance.Status.SCHEDULED, ScheduledMaintenance.Status.ACTIVE]
+        ).update(status=ScheduledMaintenance.Status.CANCELLED)
         
-        if duplicated > 0:
-            messages.success(request, f"Duplicated {duplicated} maintenance events")
+        messages.warning(request, f"Cancelled {cancelable_count} maintenance tasks.")
     
-    def calendar_view(self, request: HttpRequest) -> TemplateResponse:
-        """Calendar view for scheduled maintenances."""
-        from ..services.scheduled_maintenance_service import scheduled_maintenance_service
+    @action(description="Reschedule maintenance", variant=ActionVariant.INFO)
+    def reschedule_maintenance_action(self, request: HttpRequest, queryset) -> None:
+        """Reschedule selected maintenance tasks."""
+        reschedulable_count = queryset.filter(
+            status__in=[ScheduledMaintenance.Status.CANCELLED, ScheduledMaintenance.Status.FAILED]
+        ).count()
         
-        calendar_data = scheduled_maintenance_service.get_maintenance_calendar(days=30)
+        if reschedulable_count == 0:
+            messages.error(request, "No reschedulable maintenance tasks selected.")
+            return
         
-        context = {
-            'title': 'Maintenance Calendar',
-            'calendar_data': calendar_data,
-            'opts': self.model._meta,
-        }
+        # Reset to scheduled status
+        queryset.filter(
+            status__in=[ScheduledMaintenance.Status.CANCELLED, ScheduledMaintenance.Status.FAILED]
+        ).update(status=ScheduledMaintenance.Status.SCHEDULED)
         
-        return TemplateResponse(
-            request,
-            'admin/maintenance/scheduled_maintenance_calendar.html',
-            context
-        )
+        messages.info(request, f"Reset {reschedulable_count} maintenance tasks to scheduled.")
     
-    def start_maintenance_view(self, request: HttpRequest, object_id: int) -> HttpResponse:
-        """Start specific maintenance event."""
-        maintenance = self.get_object(request, object_id)
+    def changelist_view(self, request, extra_context=None):
+        """Add maintenance statistics to changelist."""
+        extra_context = extra_context or {}
         
-        if maintenance.status != ScheduledMaintenance.Status.SCHEDULED:
-            messages.error(request, f"Cannot start maintenance in {maintenance.status} status")
-        else:
-            try:
-                result = maintenance.start_maintenance()
-                if result['success']:
-                    messages.success(
-                        request, 
-                        f"Started maintenance '{maintenance.title}' affecting {result['sites_affected']} sites"
-                    )
-                else:
-                    messages.error(request, f"Failed to start maintenance: {result.get('error')}")
-            except Exception as e:
-                messages.error(request, f"Error starting maintenance: {e}")
+        queryset = self.get_queryset(request)
+        stats = queryset.aggregate(
+            total_maintenance=Count('id'),
+            scheduled_maintenance=Count('id', filter=Q(status=ScheduledMaintenance.Status.SCHEDULED)),
+            active_maintenance=Count('id', filter=Q(status=ScheduledMaintenance.Status.ACTIVE)),
+            completed_maintenance=Count('id', filter=Q(status=ScheduledMaintenance.Status.COMPLETED)),
+            failed_maintenance=Count('id', filter=Q(status=ScheduledMaintenance.Status.FAILED)),
+            cancelled_maintenance=Count('id', filter=Q(status=ScheduledMaintenance.Status.CANCELLED))
+        )
         
-        return redirect('admin:maintenance_scheduledmaintenance_change', object_id)
-    
-    def complete_maintenance_view(self, request: HttpRequest, object_id: int) -> HttpResponse:
-        """Complete specific maintenance event."""
-        maintenance = self.get_object(request, object_id)
+        # Priority breakdown
+        priority_counts = dict(
+            queryset.values_list('priority').annotate(
+                count=Count('id')
+            )
+        )
         
-        if maintenance.status != ScheduledMaintenance.Status.ACTIVE:
-            messages.error(request, f"Cannot complete maintenance in {maintenance.status} status")
-        else:
-            try:
-                result = maintenance.complete_maintenance()
-                if result['success']:
-                    duration = result.get('actual_duration', 0) / 3600
-                    messages.success(
-                        request, 
-                        f"Completed maintenance '{maintenance.title}' (duration: {duration:.1f}h)"
-                    )
-                else:
-                    messages.error(request, f"Failed to complete maintenance: {result.get('error')}")
-            except Exception as e:
-                messages.error(request, f"Error completing maintenance: {e}")
+        # Upcoming maintenance (next 7 days)
+        upcoming_maintenance = queryset.filter(
+            scheduled_start__gte=timezone.now(),
+            scheduled_start__lte=timezone.now() + timezone.timedelta(days=7),
+            status=ScheduledMaintenance.Status.SCHEDULED
+        ).count()
+        
+        extra_context['maintenance_stats'] = {
+            'total_maintenance': stats['total_maintenance'] or 0,
+            'scheduled_maintenance': stats['scheduled_maintenance'] or 0,
+            'active_maintenance': stats['active_maintenance'] or 0,
+            'completed_maintenance': stats['completed_maintenance'] or 0,
+            'failed_maintenance': stats['failed_maintenance'] or 0,
+            'cancelled_maintenance': stats['cancelled_maintenance'] or 0,
+            'priority_counts': priority_counts,
+            'upcoming_maintenance': upcoming_maintenance
+        }
         
-        return redirect('admin:maintenance_scheduledmaintenance_change', object_id)
+        return super().changelist_view(request, extra_context)