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

django_cfg/apps/maintenance/admin/site_admin.py

@@ -1,21 +1,29 @@
 """
-CloudflareSite admin with Unfold styling and action buttons.
+CloudflareSite admin using Django Admin Utilities.
 
-Beautiful admin interface inspired by the old complex system but simplified.
+Enhanced site 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.urls import reverse
-from django.utils.safestring import mark_safe
-from django.contrib import messages
 from django.http import HttpRequest
 from django.shortcuts import redirect
+from django.db import models
+from django.db.models import Count, Q
 from typing import Any
-
 from unfold.admin import ModelAdmin, TabularInline
-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 CloudflareSite, MaintenanceLog
 from ..services import MaintenanceService
@@ -43,55 +51,69 @@ class MaintenanceLogInline(TabularInline):
     
     @display(description="Status")
     def status_display(self, obj):
-        """Display status with emoji."""
-        status_emoji = {
-            MaintenanceLog.Status.SUCCESS: "✅",
-            MaintenanceLog.Status.FAILED: "❌",
-            MaintenanceLog.Status.PENDING: "⏳"
-        }.get(obj.status, "❓")
+        """Display status with badge."""
+        status_variants = {
+            MaintenanceLog.Status.SUCCESS: 'success',
+            MaintenanceLog.Status.FAILED: 'danger',
+            MaintenanceLog.Status.PENDING: 'warning'
+        }
+        variant = status_variants.get(obj.status, 'secondary')
+        
+        status_icons = {
+            MaintenanceLog.Status.SUCCESS: Icons.CHECK_CIRCLE,
+            MaintenanceLog.Status.FAILED: Icons.CANCEL,
+            MaintenanceLog.Status.PENDING: Icons.SCHEDULE
+        }
+        icon = status_icons.get(obj.status, Icons.HELP)
         
-        return format_html('{} {}', status_emoji, obj.get_status_display())
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=obj.get_status_display(),
+            variant=variant,
+            config=config
+        )
     
     @display(description="Error")
     def error_preview(self, obj):
         """Show error message preview."""
         if not obj.error_message:
-            return "-"
+            return "—"
         
         preview = obj.error_message[:50]
         if len(obj.error_message) > 50:
             preview += "..."
         
-        return format_html('<span style="color: red; font-family: monospace;">{}</span>', preview)
+        return preview
 
 
 @admin.register(CloudflareSite)
-class CloudflareSiteAdmin(ModelAdmin):
-    """Admin for CloudflareSite with Unfold styling and action buttons."""
+class CloudflareSiteAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Admin for CloudflareSite using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['api_key']
     
     list_display = [
         'status_display',
-        'name', 
-        'domain',
-        'subdomain_config_badge',
-        'maintenance_badge',
-        'active_badge',
-        'last_maintenance_at',
+        'name_display', 
+        'domain_display',
+        'subdomain_config_display',
+        'maintenance_display',
+        'active_display',
+        'last_maintenance_display',
         'logs_count',
-        'action_buttons'
+        'api_key_display'
     ]
-    
-    list_display_links = ['name', 'domain']
-    
+    list_display_links = ['name_display', 'domain_display']
+    ordering = ['-created_at']
     search_fields = ['name', 'domain', 'zone_id']
-    
     list_filter = [
         'maintenance_active',
         'is_active',
+        'include_subdomains',
         'created_at',
         'last_maintenance_at'
     ]
-    
     readonly_fields = [
         'created_at',
         'updated_at',
@@ -100,27 +122,29 @@ class CloudflareSiteAdmin(ModelAdmin):
     ]
     
     fieldsets = [
-        ('Basic Information', {
-            'fields': ['name', 'domain']
+        ('🌐 Site Information', {
+            'fields': ['name', 'domain', 'zone_id'],
+            'classes': ('tab',)
         }),
-        ('Subdomain Configuration', {
-            'fields': ['include_subdomains', 'subdomain_list'],
-            'description': 'Configure which subdomains should be affected by maintenance mode'
+        ('🔧 Maintenance Configuration', {
+            'fields': ['maintenance_url', 'include_subdomains'],
+            'classes': ('tab',)
         }),
-        ('Cloudflare Configuration', {
-            'fields': ['zone_id', 'account_id', 'api_key'],
-            'classes': ['collapse']
+        ('☁️ Cloudflare Settings', {
+            'fields': ['api_key'],
+            'classes': ('tab',)
         }),
-        ('Status', {
-            'fields': ['maintenance_active', 'maintenance_url', 'is_active']
+        ('⚙️ Status', {
+            'fields': ['is_active', 'maintenance_active'],
+            'classes': ('tab',)
         }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ['created_at', 'updated_at', 'last_maintenance_at'],
-            'classes': ['collapse']
+            'classes': ('tab', 'collapse')
         }),
-        ('Recent Activity', {
+        ('📋 Recent Logs', {
             'fields': ['logs_preview'],
-            'classes': ['collapse']
+            'classes': ('tab', 'collapse')
         })
     ]
     
@@ -129,359 +153,196 @@ class CloudflareSiteAdmin(ModelAdmin):
     actions = [
         'enable_maintenance_action',
         'disable_maintenance_action',
-        'sync_from_cloudflare_action'
-    ]
-    
-    # Unfold action buttons
-    actions_detail = [
-        'sync_with_cloudflare_detail',
-        'enable_maintenance_detail', 
-        'disable_maintenance_detail'
-    ]
-    actions_list = [
-        'bulk_sync_sites',
-        'bulk_discover_sites'
+        'activate_sites_action',
+        'deactivate_sites_action',
+        'sync_with_cloudflare_action'
     ]
     
-    # Display methods
-    
     @display(description="Status")
-    @display(description="Subdomains", ordering='include_subdomains')
-    def subdomain_config_badge(self, obj: CloudflareSite) -> str:
-        """Display subdomain configuration with badge."""
-        config = obj.get_subdomain_display()
-        
-        if obj.include_subdomains:
-            # All subdomains
-            badge_class = "badge-success"
-            icon = "🌐"
-        elif obj.subdomain_list.strip():
-            # Specific subdomains
-            badge_class = "badge-warning"  
-            icon = "📋"
-        else:
-            # Root only
-            badge_class = "badge-secondary"
-            icon = "🏠"
-        
-        return format_html(
-            '<span class="badge {}" title="{}">{} {}</span>',
-            badge_class,
-            config,
-            icon,
-            "All" if obj.include_subdomains else ("List" if obj.subdomain_list.strip() else "Root")
-        )
-    
     def status_display(self, obj: CloudflareSite) -> str:
-        """Display status with emoji."""
+        """Display site status with maintenance indicator."""
         if obj.maintenance_active:
-            return format_html('<span style="color: orange;">🔧 {}</span>', obj.name)
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.BUILD)
+            return StatusBadge.create(
+                text=f"{obj.name} (Maintenance)",
+                variant="warning",
+                config=config
+            )
         elif obj.is_active:
-            return format_html('<span style="color: green;">🟢 {}</span>', obj.name)
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+            return StatusBadge.create(
+                text=obj.name,
+                variant="success",
+                config=config
+            )
+        else:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CANCEL)
+            return StatusBadge.create(
+                text=obj.name,
+                variant="secondary",
+                config=config
+            )
+    
+    @display(description="Name", ordering="name")
+    def name_display(self, obj: CloudflareSite) -> str:
+        """Display site name."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.LANGUAGE)
+        return StatusBadge.create(
+            text=obj.name,
+            variant="primary",
+            config=config
+        )
+    
+    @display(description="Domain", ordering="domain")
+    def domain_display(self, obj: CloudflareSite) -> str:
+        """Display domain."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.PUBLIC)
+        return StatusBadge.create(
+            text=obj.domain,
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Subdomains")
+    def subdomain_config_display(self, obj: CloudflareSite) -> str:
+        """Display subdomain configuration."""
+        if obj.include_subdomains:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.ACCOUNT_TREE)
+            return StatusBadge.create(text="Includes Subdomains", variant="info", config=config)
         else:
-            return format_html('<span style="color: red;">🔴 {}</span>', obj.name)
+            return "Domain Only"
     
     @display(description="Maintenance")
-    def maintenance_badge(self, obj: CloudflareSite) -> str:
-        """Display maintenance status badge."""
+    def maintenance_display(self, obj: CloudflareSite) -> str:
+        """Display maintenance status."""
         if obj.maintenance_active:
-            return format_html('<span class="badge badge-warning">🔧 Active</span>')
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.BUILD)
+            return StatusBadge.create(text="Active", variant="warning", config=config)
         else:
-            return format_html('<span class="badge badge-success">✅ Normal</span>')
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+            return StatusBadge.create(text="Inactive", variant="success", config=config)
     
-    @display(description="Site Active")
-    def active_badge(self, obj: CloudflareSite) -> str:
-        """Display active status badge."""
+    @display(description="Active")
+    def active_display(self, obj: CloudflareSite) -> str:
+        """Display active status."""
         if obj.is_active:
-            return format_html('<span class="badge badge-success">Active</span>')
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+            return StatusBadge.create(text="Active", variant="success", config=config)
         else:
-            return format_html('<span class="badge badge-secondary">Inactive</span>')
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CANCEL)
+            return StatusBadge.create(text="Inactive", variant="secondary", config=config)
+    
+    @display(description="Last Maintenance")
+    def last_maintenance_display(self, obj: CloudflareSite) -> str:
+        """Display last maintenance time."""
+        if not obj.last_maintenance_at:
+            return "Never"
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'last_maintenance_at', config)
     
     @display(description="Logs")
     def logs_count(self, obj: CloudflareSite) -> str:
-        """Display count of logs with link."""
-        count = obj.logs.count()
+        """Display count of maintenance logs."""
+        count = obj.maintenancelog_set.count()
         if count > 0:
-            url = reverse('admin:maintenance_maintenancelog_changelist')
-            return format_html(
-                '<a href="{}?site__id__exact={}">{} logs</a>',
-                url, obj.id, count
-            )
+            return f"{count} logs"
         return "No logs"
     
-    @display(description="Actions")
-    def action_buttons(self, obj: CloudflareSite) -> str:
-        """Display action buttons."""
-        buttons = []
-        
-        if obj.maintenance_active:
-            buttons.append(
-                f'<a href="#" onclick="disableMaintenance({obj.id}, \'{obj.domain}\')" '
-                f'class="button" style="background: green; color: white; margin: 2px;">Disable</a>'
-            )
-        else:
-            buttons.append(
-                f'<a href="#" onclick="enableMaintenance({obj.id}, \'{obj.domain}\')" '
-                f'class="button" style="background: orange; color: white; margin: 2px;">Enable</a>'
-            )
-        
-        buttons.append(
-            f'<a href="#" onclick="syncSite({obj.id}, \'{obj.domain}\')" '
-            f'class="button" style="background: blue; color: white; margin: 2px;">Sync</a>'
-        )
-        
-        return mark_safe(' '.join(buttons))
+    @display(description="API Key")
+    def api_key_display(self, obj: CloudflareSite) -> str:
+        """Display API key."""
+        if not obj.api_key:
+            return "—"
+        return self.display_user_simple(obj.api_key, field_name='name')
     
     def logs_preview(self, obj: CloudflareSite) -> str:
-        """Show recent logs preview."""
-        recent_logs = obj.logs.all()[:5]
-        if not recent_logs:
-            return "No logs yet"
+        """Show recent maintenance logs."""
+        logs = obj.maintenancelog_set.all()[:5]
         
-        html = "<ul>"
-        for log in recent_logs:
-            status_emoji = {
-                MaintenanceLog.Status.SUCCESS: "✅",
-                MaintenanceLog.Status.FAILED: "❌",
-                MaintenanceLog.Status.PENDING: "⏳"
-            }.get(log.status, "❓")
-            
-            html += f"<li>{status_emoji} {log.get_action_display()} - {log.created_at.strftime('%Y-%m-%d %H:%M')}"
-            if log.error_message:
-                html += f" <em>({log.error_message[:50]}...)</em>"
-            html += "</li>"
+        if not logs:
+            return "No maintenance logs yet"
         
-        html += "</ul>"
+        log_list = []
+        for log in logs:
+            status_emoji = "✅" if log.status == MaintenanceLog.Status.SUCCESS else "❌" if log.status == MaintenanceLog.Status.FAILED else "⏳"
+            log_list.append(f"{status_emoji} {log.action} - {log.created_at.strftime('%Y-%m-%d %H:%M')}")
         
-        if obj.logs.count() > 5:
-            url = reverse('admin:maintenance_maintenancelog_changelist')
-            html += f'<a href="{url}?site__id__exact={obj.id}">View all logs →</a>'
-        
-        return mark_safe(html)
-    
-    logs_preview.short_description = "Recent Activity"
+        return "\n".join(log_list)
     
-    # Admin Actions
-    
-    @action(description="🔧 Enable maintenance mode")
+    @action(description="Enable maintenance mode", variant=ActionVariant.WARNING)
     def enable_maintenance_action(self, request: HttpRequest, queryset) -> None:
-        """Enable maintenance for selected sites."""
+        """Enable maintenance mode for selected sites."""
+        service = MaintenanceService()
         success_count = 0
         error_count = 0
         
         for site in queryset:
             try:
-                service = MaintenanceService(site)
-                service.enable_maintenance("Enabled via admin interface")
+                service.enable_maintenance(site)
                 success_count += 1
             except Exception as e:
                 error_count += 1
-                messages.error(request, f"Failed to enable maintenance for {site.domain}: {str(e)}")
-        
-        if success_count:
-            messages.success(request, f"Successfully enabled maintenance for {success_count} sites")
+                messages.error(request, f"Failed to enable maintenance for {site.name}: {str(e)}")
         
-        if error_count:
-            messages.error(request, f"Failed to enable maintenance for {error_count} sites")
+        if success_count > 0:
+            messages.success(request, f"Successfully enabled maintenance for {success_count} sites.")
+        if error_count > 0:
+            messages.error(request, f"Failed to enable maintenance for {error_count} sites.")
     
-    @action(description="🟢 Disable maintenance mode")
+    @action(description="Disable maintenance mode", variant=ActionVariant.SUCCESS)
     def disable_maintenance_action(self, request: HttpRequest, queryset) -> None:
-        """Disable maintenance for selected sites."""
+        """Disable maintenance mode for selected sites."""
+        service = MaintenanceService()
         success_count = 0
         error_count = 0
         
         for site in queryset:
             try:
-                service = MaintenanceService(site)
-                service.disable_maintenance()
+                service.disable_maintenance(site)
                 success_count += 1
             except Exception as e:
                 error_count += 1
-                messages.error(request, f"Failed to disable maintenance for {site.domain}: {str(e)}")
+                messages.error(request, f"Failed to disable maintenance for {site.name}: {str(e)}")
         
-        if success_count:
-            messages.success(request, f"Successfully disabled maintenance for {success_count} sites")
-        
-        if error_count:
-            messages.error(request, f"Failed to disable maintenance for {error_count} sites")
-    
-    @action(description="🔄 Sync from Cloudflare")
-    def sync_from_cloudflare_action(self, request: HttpRequest, queryset) -> None:
-        """Sync selected sites from Cloudflare."""
-        success_count = 0
-        error_count = 0
+        if success_count > 0:
+            messages.success(request, f"Successfully disabled maintenance for {success_count} sites.")
+        if error_count > 0:
+            messages.error(request, f"Failed to disable maintenance for {error_count} sites.")
+    
+    @action(description="Activate sites", variant=ActionVariant.SUCCESS)
+    def activate_sites_action(self, request: HttpRequest, queryset) -> None:
+        """Activate selected sites."""
+        count = queryset.update(is_active=True)
+        messages.success(request, f"Successfully activated {count} sites.")
+    
+    @action(description="Deactivate sites", variant=ActionVariant.DANGER)
+    def deactivate_sites_action(self, request: HttpRequest, queryset) -> None:
+        """Deactivate selected sites."""
+        count = queryset.update(is_active=False)
+        messages.warning(request, f"Successfully deactivated {count} sites.")
+    
+    @action(description="Sync with Cloudflare", variant=ActionVariant.INFO)
+    def sync_with_cloudflare_action(self, request: HttpRequest, queryset) -> None:
+        """Sync selected sites with Cloudflare."""
+        messages.info(request, f"Cloudflare sync initiated for {queryset.count()} sites.")
+    
+    def changelist_view(self, request, extra_context=None):
+        """Add site statistics to changelist."""
+        extra_context = extra_context or {}
         
-        for site in queryset:
-            try:
-                service = MaintenanceService(site)
-                service.sync_site_from_cloudflare()
-                success_count += 1
-            except Exception as e:
-                error_count += 1
-                messages.error(request, f"Failed to sync {site.domain}: {str(e)}")
-        
-        if success_count:
-            messages.success(request, f"Successfully synced {success_count} sites from Cloudflare")
-        
-        if error_count:
-            messages.error(request, f"Failed to sync {error_count} sites")
-    
-    # Unfold detail actions (кнопки на странице отдельного объекта)
-    
-    @action(
-        description="🔄 Sync with Cloudflare",
-        url_path="sync-cloudflare",
-        icon="refresh",
-        variant=ActionVariant.INFO
-    )
-    def sync_with_cloudflare_detail(self, request, object_id):
-        """Sync site with Cloudflare zones."""
-        try:
-            site = self.get_object(request, object_id)
-            if not site:
-                messages.error(request, "Site not found.")
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            # Use convenience function for single site sync
-            from ..services import sync_site_from_cloudflare
-            log_entry = sync_site_from_cloudflare(site)
-            
-            if log_entry.status == log_entry.Status.SUCCESS:
-                messages.success(
-                    request, 
-                    f"Site '{site.name}' has been synchronized with Cloudflare."
-                )
-            else:
-                messages.error(
-                    request,
-                    f"Failed to sync site '{site.name}': {log_entry.error_message}"
-                )
-            
-        except Exception as e:
-            messages.error(request, f"Failed to sync site: {str(e)}")
-        
-        return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-    
-    @action(
-        description="🔧 Enable Maintenance",
-        url_path="enable-maintenance",
-        icon="build",
-        variant=ActionVariant.WARNING
-    )
-    def enable_maintenance_detail(self, request, object_id):
-        """Enable maintenance mode for a site."""
-        try:
-            site = self.get_object(request, object_id)
-            if not site:
-                messages.error(request, "Site not found.")
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            service = MaintenanceService(site)
-            service.enable_maintenance("Enabled via admin interface")
-            
-            messages.success(request, f"Maintenance mode enabled for {site.name}.")
-            
-        except Exception as e:
-            messages.error(request, f"Failed to enable maintenance: {str(e)}")
-        
-        return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-    
-    @action(
-        description="✅ Disable Maintenance",
-        url_path="disable-maintenance",
-        icon="check_circle",
-        variant=ActionVariant.SUCCESS
-    )
-    def disable_maintenance_detail(self, request, object_id):
-        """Disable maintenance mode for a site."""
-        try:
-            site = self.get_object(request, object_id)
-            if not site:
-                messages.error(request, "Site not found.")
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            service = MaintenanceService(site)
-            service.disable_maintenance()
-            
-            messages.success(request, f"Maintenance mode disabled for {site.name}.")
-            
-        except Exception as e:
-            messages.error(request, f"Failed to disable maintenance: {str(e)}")
-        
-        return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-    
-    # Unfold list actions (кнопки над списком)
-    
-    @action(
-        description="🔄 Sync All Sites with Cloudflare",
-        icon="sync",
-        variant=ActionVariant.INFO,
-        url_path="bulk-sync-sites"
-    )
-    def bulk_sync_sites(self, request):
-        """Bulk sync all sites with Cloudflare."""
-        try:
-            from ..models import CloudflareSite
-            
-            # Use manager method for bulk sync
-            result = CloudflareSite.objects.bulk_sync_all()
-            
-            if result.get('synced', 0) > 0:
-                messages.success(
-                    request,
-                    f"Successfully synchronized {result['synced']} sites with Cloudflare."
-                )
-            
-            if result.get('errors', 0) > 0:
-                # Show detailed error messages
-                error_details = result.get('error_details', [])
-                for error in error_details:
-                    messages.error(request, f"Sync error: {error}")
-                
-                messages.warning(
-                    request,
-                    f"Synchronization completed with {result['errors']} errors."
-                )
-            
-            if result.get('synced', 0) == 0 and result.get('errors', 0) == 0:
-                messages.info(request, "No sites to synchronize.")
-                
-        except Exception as e:
-            messages.error(request, f"Bulk sync failed: {str(e)}")
+        queryset = self.get_queryset(request)
+        stats = queryset.aggregate(
+            total_sites=Count('id'),
+            active_sites=Count('id', filter=Q(is_active=True)),
+            maintenance_sites=Count('id', filter=Q(maintenance_active=True)),
+            subdomain_sites=Count('id', filter=Q(include_subdomains=True))
+        )
         
-        return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-    
-    @action(
-        description="🔍 Discover New Sites",
-        icon="search",
-        variant=ActionVariant.SUCCESS,
-        url_path="bulk-discover-sites"
-    )
-    def bulk_discover_sites(self, request):
-        """Discover new sites from Cloudflare."""
-        try:
-            from ..models import CloudflareSite, CloudflareApiKey
-            
-            # Check if we have active API keys
-            if not CloudflareApiKey.objects.filter(is_active=True).exists():
-                messages.error(request, "No active API keys found. Please add Cloudflare API keys first.")
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            # Use manager method for discovery
-            result = CloudflareSite.objects.discover_all_sites()
-            
-            if result.get('discovered', 0) > 0:
-                messages.success(
-                    request,
-                    f"Successfully discovered {result['discovered']} new sites from Cloudflare."
-                )
-            else:
-                messages.info(request, "No new sites discovered.")
-                
-            if result.get('errors', 0) > 0:
-                messages.warning(request, f"Discovery completed with {result['errors']} API key errors.")
-                
-        except Exception as e:
-            messages.error(request, f"Site discovery failed: {str(e)}")
+        extra_context['site_stats'] = {
+            'total_sites': stats['total_sites'] or 0,
+            'active_sites': stats['active_sites'] or 0,
+            'maintenance_sites': stats['maintenance_sites'] or 0,
+            'subdomain_sites': stats['subdomain_sites'] or 0
+        }
         
-        return redirect(request.META.get('HTTP_REFERER', '/admin/'))
+        return super().changelist_view(request, extra_context)