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

django_cfg/apps/maintenance/admin/api_key_admin.py

@@ -1,46 +1,54 @@
 """
-CloudflareApiKey admin with Unfold styling.
+CloudflareApiKey admin using Django Admin Utilities.
 
-Admin interface for managing Cloudflare API keys.
+Enhanced API key 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
+from django.db import models
+from django.db.models import Count
 from typing import Any
-
 from unfold.admin import ModelAdmin
-from unfold.decorators import display, action
+
+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 CloudflareApiKey
 
 
 @admin.register(CloudflareApiKey)
-class CloudflareApiKeyAdmin(ModelAdmin):
-    """Admin interface for CloudflareApiKey model."""
+class CloudflareApiKeyAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Admin interface for CloudflareApiKey model using Django Admin Utilities."""
     
     list_display = [
         'status_display',
-        'name',
+        'name_display',
         'description_preview',
-        'active_badge',
-        'default_badge',
+        'active_display',
+        'default_display',
         'sites_count',
-        'last_used_at',
-        'created_at'
+        'last_used_display',
+        'created_at_display'
     ]
-    
-    list_display_links = ['name']
-    
+    list_display_links = ['name_display']
+    ordering = ['-created_at']
     search_fields = ['name', 'description', 'account_id']
-    
     list_filter = [
         'is_active',
         'is_default',
         'created_at',
         'last_used_at'
     ]
-    
     readonly_fields = [
         'created_at',
         'updated_at',
@@ -49,23 +57,25 @@ class CloudflareApiKeyAdmin(ModelAdmin):
     ]
     
     fieldsets = [
-        ('Basic Information', {
-            'fields': ['name', 'description']
+        ('🔑 Basic Information', {
+            'fields': ['name', 'description'],
+            'classes': ('tab',)
         }),
-        ('Cloudflare Configuration', {
+        ('☁️ Cloudflare Configuration', {
             'fields': ['api_token', 'account_id'],
-            'classes': ['collapse']
+            'classes': ('tab', 'collapse')
         }),
-        ('Settings', {
-            'fields': ['is_active', 'is_default']
+        ('⚙️ Settings', {
+            'fields': ['is_active', 'is_default'],
+            'classes': ('tab',)
         }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ['created_at', 'updated_at', 'last_used_at'],
-            'classes': ['collapse']
+            'classes': ('tab', 'collapse')
         }),
-        ('Usage', {
+        ('📊 Usage', {
             'fields': ['sites_using_key'],
-            'classes': ['collapse']
+            'classes': ('tab', 'collapse')
         })
     ]
     
@@ -75,24 +85,47 @@ class CloudflareApiKeyAdmin(ModelAdmin):
         'deactivate_keys_action'
     ]
     
-    # Display methods
-    
     @display(description="Status")
     def status_display(self, obj: CloudflareApiKey) -> str:
-        """Display status with emoji."""
+        """Display status with badge."""
         if obj.is_active:
             if obj.is_default:
-                return format_html('<span style="color: green;">🔑 {} (Default)</span>', obj.name)
+                config = StatusBadgeConfig(show_icons=True, icon=Icons.STAR)
+                return StatusBadge.create(
+                    text=f"{obj.name} (Default)",
+                    variant="success",
+                    config=config
+                )
             else:
-                return format_html('<span style="color: green;">🔑 {}</span>', obj.name)
+                config = StatusBadgeConfig(show_icons=True, icon=Icons.KEY)
+                return StatusBadge.create(
+                    text=obj.name,
+                    variant="success",
+                    config=config
+                )
         else:
-            return format_html('<span style="color: red;">🔒 {}</span>', obj.name)
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.LOCK)
+            return StatusBadge.create(
+                text=obj.name,
+                variant="danger",
+                config=config
+            )
+    
+    @display(description="Name", ordering="name")
+    def name_display(self, obj: CloudflareApiKey) -> str:
+        """Display API key name."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.KEY)
+        return StatusBadge.create(
+            text=obj.name,
+            variant="primary",
+            config=config
+        )
     
     @display(description="Description")
     def description_preview(self, obj: CloudflareApiKey) -> str:
         """Show description preview."""
         if not obj.description:
-            return "-"
+            return "—"
         
         preview = obj.description[:50]
         if len(obj.description) > 50:
@@ -101,20 +134,23 @@ class CloudflareApiKeyAdmin(ModelAdmin):
         return preview
     
     @display(description="Active")
-    def active_badge(self, obj: CloudflareApiKey) -> str:
+    def active_display(self, obj: CloudflareApiKey) -> str:
         """Display active status badge."""
         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="Default")
-    def default_badge(self, obj: CloudflareApiKey) -> str:
+    def default_display(self, obj: CloudflareApiKey) -> str:
         """Display default status badge."""
         if obj.is_default:
-            return format_html('<span class="badge badge-primary">Default</span>')
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.STAR)
+            return StatusBadge.create(text="Default", variant="primary", config=config)
         else:
-            return "-"
+            return "—"
     
     @display(description="Sites")
     def sites_count(self, obj: CloudflareApiKey) -> str:
@@ -124,62 +160,88 @@ class CloudflareApiKeyAdmin(ModelAdmin):
             return f"{count} sites"
         return "No sites"
     
+    @display(description="Last Used")
+    def last_used_display(self, obj: CloudflareApiKey) -> str:
+        """Display last used time."""
+        if not obj.last_used_at:
+            return "Never"
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'last_used_at', config)
+    
+    @display(description="Created")
+    def created_at_display(self, obj: CloudflareApiKey) -> str:
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
+    
     def sites_using_key(self, obj: CloudflareApiKey) -> str:
         """Show sites using this API key."""
-        sites = obj.cloudflaresite_set.all()[:10]  # Limit to 10 for display
+        sites = obj.cloudflaresite_set.all()[:10]
         
         if not sites:
             return "No sites using this key"
         
-        html = "<ul>"
+        site_list = []
         for site in sites:
             status_emoji = "🔧" if site.maintenance_active else "🟢"
-            html += f"<li>{status_emoji} {site.name} ({site.domain})</li>"
+            site_list.append(f"{status_emoji} {site.name} ({site.domain})")
         
-        html += "</ul>"
+        result = "\n".join(site_list)
         
         total_count = obj.cloudflaresite_set.count()
         if total_count > 10:
-            html += f"<p><em>... and {total_count - 10} more sites</em></p>"
+            result += f"\n... and {total_count - 10} more sites"
         
-        return format_html(html)
-    
-    sites_using_key.short_description = "Sites Using This Key"
-    
-    # Admin Actions
+        return result
     
-    @action(description="🔑 Make default API key")
+    @action(description="Make default API key", variant=ActionVariant.PRIMARY)
     def make_default_action(self, request: HttpRequest, queryset) -> None:
         """Make selected key the default."""
         if queryset.count() > 1:
-            self.message_user(request, "Please select only one API key to make default.", level='error')
+            messages.error(request, "Please select only one API key to make default.")
             return
         
         key = queryset.first()
         if key:
-            # This will automatically set others to non-default via the model's save method
             key.is_default = True
             key.save()
-            self.message_user(request, f"'{key.name}' is now the default API key.")
+            messages.success(request, f"'{key.name}' is now the default API key.")
     
-    @action(description="✅ Activate API keys")
+    @action(description="Activate API keys", variant=ActionVariant.SUCCESS)
     def activate_keys_action(self, request: HttpRequest, queryset) -> None:
         """Activate selected API keys."""
         count = queryset.update(is_active=True)
-        self.message_user(request, f"Successfully activated {count} API keys.")
+        messages.success(request, f"Successfully activated {count} API keys.")
     
-    @action(description="❌ Deactivate API keys")
+    @action(description="Deactivate API keys", variant=ActionVariant.DANGER)
     def deactivate_keys_action(self, request: HttpRequest, queryset) -> None:
         """Deactivate selected API keys."""
-        # Don't allow deactivating the default key
         default_keys = queryset.filter(is_default=True)
         if default_keys.exists():
-            self.message_user(
+            messages.error(
                 request, 
-                "Cannot deactivate default API key. Please set another key as default first.", 
-                level='error'
+                "Cannot deactivate default API key. Please set another key as default first."
             )
             return
         
         count = queryset.update(is_active=False)
-        self.message_user(request, f"Successfully deactivated {count} API keys.")
+        messages.warning(request, f"Successfully deactivated {count} API keys.")
+    
+    def changelist_view(self, request, extra_context=None):
+        """Add API key statistics to changelist."""
+        extra_context = extra_context or {}
+        
+        queryset = self.get_queryset(request)
+        stats = queryset.aggregate(
+            total_keys=Count('id'),
+            active_keys=Count('id', filter=models.Q(is_active=True)),
+            default_keys=Count('id', filter=models.Q(is_default=True))
+        )
+        
+        extra_context['api_key_stats'] = {
+            'total_keys': stats['total_keys'] or 0,
+            'active_keys': stats['active_keys'] or 0,
+            'default_keys': stats['default_keys'] or 0
+        }
+        
+        return super().changelist_view(request, extra_context)

django_cfg/apps/maintenance/admin/log_admin.py

@@ -1,48 +1,59 @@
 """
-MaintenanceLog admin with Unfold styling.
+MaintenanceLog admin using Django Admin Utilities.
 
 Read-only admin interface for viewing maintenance operation logs.
 """
 
 from django.contrib import admin
-from django.utils.html import format_html
 from django.http import HttpRequest
+from django.db import models
+from django.db.models import Count, Q
 from typing import Any
 import json
-
 from unfold.admin import ModelAdmin
-from unfold.decorators import display
+
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    StatusBadgeConfig,
+    DateTimeDisplayConfig,
+    Icons,
+    display
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
 
 from ..models import MaintenanceLog
 
 
 @admin.register(MaintenanceLog)
-class MaintenanceLogAdmin(ModelAdmin):
-    """Admin interface for MaintenanceLog model."""
+class MaintenanceLogAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Admin interface for MaintenanceLog model using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['site']
     
     list_display = [
         'status_display',
-        'site',
+        'site_display',
         'action_display',
-        'created_at',
+        'created_at_display',
         'duration_display',
         'error_preview'
     ]
-    
+    list_display_links = ['site_display']
+    ordering = ['-created_at']
     list_filter = [
         'action',
         'status',
         'created_at',
         'site'
     ]
-    
     search_fields = [
         'site__name',
         'site__domain',
         'reason',
         'error_message'
     ]
-    
     readonly_fields = [
         'site',
         'action',
@@ -56,101 +67,172 @@ class MaintenanceLogAdmin(ModelAdmin):
     ]
     
     fieldsets = [
-        ('Operation Details', {
-            'fields': ['site', 'action', 'status', 'created_at', 'duration_seconds']
+        ('📋 Log Information', {
+            'fields': ['site', 'action', 'status', 'reason'],
+            'classes': ('tab',)
+        }),
+        ('⏱️ Timing', {
+            'fields': ['created_at', 'duration_seconds'],
+            'classes': ('tab',)
         }),
-        ('Additional Information', {
-            'fields': ['reason', 'error_message']
+        ('❌ Error Details', {
+            'fields': ['error_message'],
+            'classes': ('tab', 'collapse')
         }),
-        ('Cloudflare Response', {
+        ('📊 Cloudflare Response', {
             'fields': ['cloudflare_response_formatted'],
-            'classes': ['collapse']
+            'classes': ('tab', 'collapse')
         })
     ]
     
-    ordering = ['-created_at']
-    
-    def has_add_permission(self, request: HttpRequest) -> bool:
-        """Logs are created automatically, no manual adding."""
+    def has_add_permission(self, request):
+        """Disable adding new logs through admin."""
         return False
     
-    def has_change_permission(self, request: HttpRequest, obj: Any = None) -> bool:
-        """Logs are read-only."""
+    def has_change_permission(self, request, obj=None):
+        """Disable editing logs through admin."""
         return False
     
-    def has_delete_permission(self, request: HttpRequest, obj: Any = None) -> bool:
-        """Allow deletion of old logs."""
+    def has_delete_permission(self, request, obj=None):
+        """Allow deleting old logs."""
         return True
     
-    # Display methods
-    
-    @display(description="Status", ordering="status")
+    @display(description="Status")
     def status_display(self, obj: MaintenanceLog) -> str:
-        """Display status with emoji and badge."""
-        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)
         
-        color_class = {
-            MaintenanceLog.Status.SUCCESS: "badge-success",
-            MaintenanceLog.Status.FAILED: "badge-danger",
-            MaintenanceLog.Status.PENDING: "badge-warning"
-        }.get(obj.status, "badge-secondary")
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=obj.get_status_display(),
+            variant=variant,
+            config=config
+        )
+    
+    @display(description="Site", ordering="site__name")
+    def site_display(self, obj: MaintenanceLog) -> str:
+        """Display site name."""
+        if not obj.site:
+            return "—"
         
-        return format_html(
-            '<span class="badge {}">{} {}</span>',
-            color_class, status_emoji, obj.get_status_display()
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.LANGUAGE)
+        return StatusBadge.create(
+            text=f"{obj.site.name} ({obj.site.domain})",
+            variant="info",
+            config=config
         )
     
-    @display(description="Action", ordering="action")
+    @display(description="Action")
     def action_display(self, obj: MaintenanceLog) -> str:
-        """Display action with icon."""
+        """Display action with badge."""
+        action_variants = {
+            MaintenanceLog.Action.ENABLE: 'warning',
+            MaintenanceLog.Action.DISABLE: 'success',
+            MaintenanceLog.Action.CHECK_STATUS: 'info'
+        }
+        variant = action_variants.get(obj.action, 'secondary')
+        
         action_icons = {
-            MaintenanceLog.Action.ENABLE: "🔧",
-            MaintenanceLog.Action.DISABLE: "🟢", 
-            MaintenanceLog.Action.SYNC: "🔄",
-            MaintenanceLog.Action.ERROR: "❌"
+            MaintenanceLog.Action.ENABLE: Icons.BUILD,
+            MaintenanceLog.Action.DISABLE: Icons.CHECK_CIRCLE,
+            MaintenanceLog.Action.CHECK_STATUS: Icons.VISIBILITY
         }
+        icon = action_icons.get(obj.action, Icons.SETTINGS)
         
-        icon = action_icons.get(obj.action, "❓")
-        return f"{icon} {obj.get_action_display()}"
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=obj.get_action_display(),
+            variant=variant,
+            config=config
+        )
+    
+    @display(description="Created")
+    def created_at_display(self, obj: MaintenanceLog) -> str:
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
     
     @display(description="Duration")
     def duration_display(self, obj: MaintenanceLog) -> str:
         """Display operation duration."""
-        if not obj.duration_seconds:
-            return "-"
+        if obj.duration_seconds is None:
+            return "—"
         
-        if obj.duration_seconds < 60:
-            return f"{obj.duration_seconds}s"
+        if obj.duration_seconds < 1:
+            return f"{obj.duration_seconds * 1000:.0f}ms"
+        elif obj.duration_seconds < 60:
+            return f"{obj.duration_seconds:.1f}s"
         else:
             minutes = obj.duration_seconds // 60
             seconds = obj.duration_seconds % 60
-            return f"{minutes}m {seconds}s"
+            return f"{minutes:.0f}m {seconds:.0f}s"
     
     @display(description="Error")
     def error_preview(self, obj: MaintenanceLog) -> str:
         """Show error message preview."""
         if not obj.error_message:
-            return "-"
+            return "—"
         
         preview = obj.error_message[:100]
         if len(obj.error_message) > 100:
             preview += "..."
         
-        return format_html('<span style="color: red; font-family: monospace;">{}</span>', preview)
+        return preview
     
     def cloudflare_response_formatted(self, obj: MaintenanceLog) -> str:
-        """Format Cloudflare response for display."""
+        """Format cloudflare response for display."""
         if not obj.cloudflare_response:
             return "No response data"
         
         try:
-            formatted = json.dumps(obj.cloudflare_response, indent=2)
-            return format_html('<pre style="background: #f8f8f8; padding: 10px; overflow: auto;">{}</pre>', formatted)
-        except Exception:
+            if isinstance(obj.cloudflare_response, str):
+                data = json.loads(obj.cloudflare_response)
+            else:
+                data = obj.cloudflare_response
+            
+            return json.dumps(data, indent=2, ensure_ascii=False)
+        except (json.JSONDecodeError, TypeError):
             return str(obj.cloudflare_response)
     
     cloudflare_response_formatted.short_description = "Cloudflare Response (Formatted)"
+    
+    def changelist_view(self, request, extra_context=None):
+        """Add log statistics to changelist."""
+        extra_context = extra_context or {}
+        
+        queryset = self.get_queryset(request)
+        stats = queryset.aggregate(
+            total_logs=Count('id'),
+            success_logs=Count('id', filter=Q(status=MaintenanceLog.Status.SUCCESS)),
+            failed_logs=Count('id', filter=Q(status=MaintenanceLog.Status.FAILED)),
+            pending_logs=Count('id', filter=Q(status=MaintenanceLog.Status.PENDING))
+        )
+        
+        # Action breakdown
+        action_counts = dict(
+            queryset.values_list('action').annotate(
+                count=Count('id')
+            )
+        )
+        
+        extra_context['log_stats'] = {
+            'total_logs': stats['total_logs'] or 0,
+            'success_logs': stats['success_logs'] or 0,
+            'failed_logs': stats['failed_logs'] or 0,
+            'pending_logs': stats['pending_logs'] or 0,
+            'action_counts': action_counts
+        }
+        
+        return super().changelist_view(request, extra_context)