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

django_cfg/apps/knowbase/admin/document_admin.py

@@ -1,22 +1,34 @@
 """
-Document admin interfaces with Unfold optimization.
+Document admin interfaces using Django Admin Utilities.
+
+Enhanced document 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.db import models, IntegrityError
-from django.db.models import Count, Sum, Avg
+from django.db.models import Count, Sum, Avg, Q
 from django.db.models.fields.json import JSONField
-from django.contrib import messages
 from django_json_widget.widgets import JSONEditorWidget
 from unfold.admin import ModelAdmin, TabularInline
-from unfold.decorators import display
 from unfold.contrib.filters.admin import AutocompleteSelectFilter, AutocompleteSelectMultipleFilter
 from unfold.contrib.forms.widgets import WysiwygWidget
 from django_cfg import ImportExportModelAdmin, ExportMixin, ImportForm, ExportForm
 
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    MoneyDisplayConfig,
+    StatusBadgeConfig,
+    DateTimeDisplayConfig,
+    Icons,
+    ActionVariant,
+    display,
+    action
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+
 from ..models import Document, DocumentChunk, DocumentCategory
 
 
@@ -27,20 +39,17 @@ class DocumentChunkInline(TabularInline):
     verbose_name = "Document Chunk"
     verbose_name_plural = "📄 Document Chunks (Read-only)"
     extra = 0
-    max_num = 0  # No new chunks allowed
-    can_delete = False  # Prevent deletion through inline
-    show_change_link = True  # Allow viewing individual chunks
+    max_num = 0
+    can_delete = False
+    show_change_link = True
     
     def has_add_permission(self, request, obj=None):
-        """Disable adding new chunks through inline."""
         return False
     
     def has_change_permission(self, request, obj=None):
-        """Disable editing chunks through inline."""
         return False
     
     def has_delete_permission(self, request, obj=None):
-        """Disable deleting chunks through inline."""
         return False
     
     fields = [
@@ -52,20 +61,15 @@ class DocumentChunkInline(TabularInline):
         'has_embedding_inline', 'embedding_cost', 'created_at'
     ]
     
-    # Unfold specific options
-    hide_title = False  # Show titles for better UX
-    classes = ['collapse']  # Collapsed by default
+    hide_title = False
+    classes = ['collapse']
     
     @display(description="Content Preview")
     def content_preview_inline(self, obj):
         """Shortened content preview for inline display."""
         if not obj.content:
-            return "-"
-        preview = obj.content[:100] + "..." if len(obj.content) > 100 else obj.content
-        return format_html(
-            '<div style="max-width: 300px; font-size: 12px; color: #666;">{}</div>',
-            preview
-        )
+            return "—"
+        return obj.content[:100] + "..." if len(obj.content) > 100 else obj.content
     
     @display(description="Has Embedding", boolean=True)
     def has_embedding_inline(self, obj):
@@ -78,18 +82,23 @@ class DocumentChunkInline(TabularInline):
 
 
 @admin.register(Document)
-class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
-    """Admin interface for Document model with Unfold styling."""
+class DocumentAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ImportExportModelAdmin):
+    """Admin interface for Document model using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['user']
     
     # Import/Export configuration
     import_form_class = ImportForm
     export_form_class = ExportForm
     
     list_display = [
-        'title_display', 'categories_display', 'user', 
-        'visibility_badge', 'status_badge', 'chunks_count_display', 'vectorization_progress', 'tokens_display', 'cost_display', 'created_at'
+        'title_display', 'categories_display', 'user_display', 
+        'visibility_display', 'status_display', 'chunks_count_display', 
+        'vectorization_progress', 'tokens_display', 'cost_display', 'created_at_display'
     ]
-    ordering = ['-created_at']  # Newest first
+    list_display_links = ['title_display']
+    ordering = ['-created_at']
     inlines = [DocumentChunkInline]
     list_filter = [
         'processing_status', 'is_public', 'file_type', 'created_at',
@@ -106,29 +115,33 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
     ]
     
     fieldsets = (
-        ('Basic Information', {
-            'fields': ('id', 'title', 'user', 'categories', 'is_public', 'file_type', 'file_size')
+        ('📄 Basic Information', {
+            'fields': ('id', 'title', 'user', 'categories', 'is_public', 'file_type', 'file_size'),
+            'classes': ('tab',)
         }),
-        ('Content', {
+        ('📝 Content', {
             'fields': ('content', 'content_hash', 'duplicate_check'),
+            'classes': ('tab',)
         }),
-        ('Processing Status', {
+        ('⚙️ Processing Status', {
             'fields': (
                 'processing_status', 'processing_started_at', 
                 'processing_completed_at', 'processing_error'
-            )
+            ),
+            'classes': ('tab',)
         }),
-        ('Statistics', {
-            'fields': ('chunks_count', 'total_tokens', 'total_cost_usd')
+        ('📊 Statistics', {
+            'fields': ('chunks_count', 'total_tokens', 'total_cost_usd'),
+            'classes': ('tab',)
         }),
-        ('Metadata', {
+        ('🔧 Metadata', {
             'fields': ('metadata',),
-            'classes': ('collapse',),
+            'classes': ('tab', 'collapse'),
             'description': 'Auto-generated metadata (read-only)'
         }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ('created_at', 'updated_at'),
-            'classes': ('collapse',)
+            'classes': ('tab', 'collapse')
         })
     )
     filter_horizontal = ['categories']
@@ -139,20 +152,16 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
     
     # Form field overrides
     formfield_overrides = {
-        models.TextField: {
-            "widget": WysiwygWidget,
-        },
-        JSONField: {
-            "widget": JSONEditorWidget,
-        }
+        models.TextField: {"widget": WysiwygWidget},
+        JSONField: {"widget": JSONEditorWidget}
     }
     
+    actions = ['reprocess_documents', 'mark_as_public', 'mark_as_private']
+    
     def get_queryset(self, request):
         """Optimize queryset with select_related and prefetch_related."""
-        # Use all_users() to show all documents in admin, then filter by user if needed
         queryset = Document.objects.all_users().select_related('user').prefetch_related('categories')
         
-        # For non-superusers, filter by their own documents
         if not request.user.is_superuser:
             queryset = queryset.filter(user=request.user)
         
@@ -160,10 +169,9 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
     
     def save_model(self, request, obj, form, change):
         """Automatically set user to current user when creating new documents."""
-        if not change:  # Only for new documents
+        if not change:
             obj.user = request.user
             
-            # Check for duplicates using manager method
             is_duplicate, existing_doc = Document.objects.check_duplicate_before_save(
                 user=obj.user, 
                 content=obj.content
@@ -176,7 +184,6 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
                     f'(created {existing_doc.created_at.strftime("%Y-%m-%d %H:%M")}). '
                     f'Please modify the content or update the existing document.'
                 )
-                # Don't save, just return - this will keep the form open with the error
                 return
         
         try:
@@ -190,8 +197,6 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
                 )
             else:
                 messages.error(request, f'Database error: {str(e)}')
-            
-            # Re-raise the exception to prevent saving
             raise
     
     @display(description="Document Title", ordering="title")
@@ -200,112 +205,71 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
         title = obj.title or "Untitled Document"
         if len(title) > 50:
             title = title[:47] + "..."
-        return format_html(
-            '<div style="font-weight: 500;">{}</div>',
-            title
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.DESCRIPTION)
+        return StatusBadge.create(
+            text=title,
+            variant="primary",
+            config=config
         )
     
-    @display(
-        description="Visibility",
-        ordering="is_public",
-        label={
-            True: 'success',   # green for public
-            False: 'danger'    # red for private
-        }
-    )
-    def visibility_badge(self, obj):
-        """Display visibility status with color coding."""
-        return obj.is_public, "Public" if obj.is_public else "Private"
-    
-    @display(
-        description="Status",
-        ordering="processing_status",
-        label={
-            'pending': 'warning',     # orange for pending
-            'processing': 'info',     # blue for processing
-            'completed': 'success',   # green for completed
-            'failed': 'danger',       # red for failed
-            'cancelled': 'secondary'  # gray for cancelled
-        }
-    )
-    def status_badge(self, obj):
-        """Display processing status with color coding."""
-        return obj.processing_status, obj.get_processing_status_display()
-    
-    @display(
-        description="Categories",
-        ordering="categories__name",
-        label={
-            'public': 'success',    # green for public categories
-            'private': 'danger',    # red for private categories
-            'mixed': 'warning',     # orange for mixed visibility
-            'none': 'info'          # blue for no categories
-        }
-    )
+    @display(description="User")
+    def user_display(self, obj):
+        """User display."""
+        if not obj.user:
+            return "—"
+        return self.display_user_simple(obj.user)
+    
+    @display(description="Visibility")
+    def visibility_display(self, obj):
+        """Display visibility status."""
+        if obj.is_public:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.PUBLIC)
+            return StatusBadge.create(text="Public", variant="success", config=config)
+        else:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.LOCK)
+            return StatusBadge.create(text="Private", variant="danger", config=config)
+    
+    @display(description="Status")
+    def status_display(self, obj):
+        """Display processing status."""
+        status_config = StatusBadgeConfig(
+            custom_mappings={
+                'pending': 'warning',
+                'processing': 'info',
+                'completed': 'success',
+                'failed': 'danger',
+                'cancelled': 'secondary'
+            },
+            show_icons=True,
+            icon=Icons.CHECK_CIRCLE if obj.processing_status == 'completed' else Icons.ERROR if obj.processing_status == 'failed' else Icons.SCHEDULE
+        )
+        return self.display_status_auto(obj, 'processing_status', status_config)
+    
+    @display(description="Categories")
     def categories_display(self, obj):
-        """Display multiple categories with Unfold label styling."""
+        """Display categories count."""
         categories = obj.categories.all()
         
         if not categories:
-            return 'none', 'No categories'
+            return "No categories"
         
-        # Determine overall visibility status
         public_count = sum(1 for cat in categories if cat.is_public)
         private_count = len(categories) - public_count
         
         if private_count == 0:
-            status = 'public'
-            description = f"{len(categories)} public"
+            return f"{len(categories)} public"
         elif public_count == 0:
-            status = 'private'  
-            description = f"{len(categories)} private"
+            return f"{len(categories)} private"
         else:
-            status = 'mixed'
-            description = f"{public_count} public, {private_count} private"
-        
-        # Return tuple for label display: (status_key, display_text)
-        return status, f"{', '.join(cat.name for cat in categories)} ({description})"
+            return f"{public_count} public, {private_count} private"
     
-    @display(description="Category Details", dropdown=True)
-    def category_dropdown(self, obj):
-        """Display category details in dropdown."""
-        categories = obj.categories.all()
-        
-        if not categories:
-            return {
-                "title": "No Categories",
-                "content": "<p class='text-gray-500 p-4'>This document has no categories assigned.</p>"
-            }
-        
-        # Build dropdown items for each category
-        items = []
-        for category in categories:
-            status_icon = "🟢" if category.is_public else "🔴"
-            visibility = "Public" if category.is_public else "Private"
-            
-            items.append({
-                "title": f"{status_icon} {category.name}",
-                "link": f"/admin/knowbase/documentcategory/{category.id}/change/"
-            })
-        
-        return {
-            "title": f"Categories ({len(categories)})",
-            "striped": True,
-            "height": 200,
-            "width": 300,
-            "items": items
-        }
-
     @display(description="Chunks", ordering="chunks_count")
     def chunks_count_display(self, obj):
-        """Display chunks count with link."""
+        """Display chunks count."""
         count = obj.chunks_count
         if count > 0:
-            url = f"/admin/knowbase/documentchunk/?document__id__exact={obj.id}"
-            return format_html(
-                '<a href="{}" style="text-decoration: none;">{} chunks</a>',
-                url, count
-            )
+            return f"{count} chunks"
         return "0 chunks"
     
     @display(description="Tokens", ordering="total_tokens")
@@ -319,21 +283,24 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
     @display(description="Cost (USD)", ordering="total_cost_usd")
     def cost_display(self, obj):
         """Display cost with currency formatting."""
-        return f"${obj.total_cost_usd:.6f}"
-    
-    @display(
-        description="Vectorization",
-        label={
-            'completed': 'success',    # green for 100%
-            'partial': 'warning',      # orange for partial
-            'none': 'danger',          # red for 0%
-            'no_chunks': 'info'        # blue for no chunks
-        }
-    )
+        config = MoneyDisplayConfig(
+            currency="USD",
+            decimal_places=6,
+            show_sign=False
+        )
+        return self.display_money_amount(obj, 'total_cost_usd', config)
+    
+    @display(description="Vectorization")
     def vectorization_progress(self, obj):
-        """Display vectorization progress with color coding."""
+        """Display vectorization progress."""
         return Document.objects.get_vectorization_status_display(obj)
     
+    @display(description="Created")
+    def created_at_display(self, obj):
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
+    
     @display(description="Processing Duration")
     def processing_duration_display(self, obj):
         """Display processing duration in readable format."""
@@ -357,37 +324,41 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
         
         if isinstance(duplicate_info, str):
             if "No duplicates found" in duplicate_info:
-                return format_html(
-                    '<span style="color: #059669;">✓ No duplicates found</span>'
-                )
-            return duplicate_info  # "No content hash"
+                return "✓ No duplicates found"
+            return duplicate_info
         
-        # Format the duplicate information for display
         duplicates_data = duplicate_info['duplicates']
         count = duplicate_info['count']
         
-        duplicate_list = []
-        for dup in duplicates_data:
-            url = reverse('admin:django_cfg_knowbase_document_change', args=[dup.pk])
-            duplicate_list.append(
-                f'<a href="{url}" target="_blank">{dup.title}</a> '
-                f'({dup.created_at.strftime("%Y-%m-%d")})'
-            )
-        
-        warning_text = f"⚠️ Found {count} duplicate(s):<br>" + "<br>".join(duplicate_list)
+        duplicate_names = [dup.title for dup in duplicates_data[:3]]
+        result = f"⚠️ Found {count} duplicate(s): " + ", ".join(duplicate_names)
         if count > 3:
-            warning_text += f"<br>... and {count - 3} more"
+            result += f" and {count - 3} more"
         
-        return format_html(
-            '<div style="color: #d97706; font-weight: 500;">{}</div>',
-            warning_text
-        )
+        return result
+    
+    @action(description="Reprocess documents", variant=ActionVariant.INFO)
+    def reprocess_documents(self, request, queryset):
+        """Reprocess selected documents."""
+        count = queryset.count()
+        messages.info(request, f"Reprocessing functionality not implemented yet. {count} documents selected.")
+    
+    @action(description="Mark as public", variant=ActionVariant.SUCCESS)
+    def mark_as_public(self, request, queryset):
+        """Mark selected documents as public."""
+        updated = queryset.update(is_public=True)
+        messages.success(request, f"Marked {updated} documents as public.")
+    
+    @action(description="Mark as private", variant=ActionVariant.WARNING)
+    def mark_as_private(self, request, queryset):
+        """Mark selected documents as private."""
+        updated = queryset.update(is_public=False)
+        messages.warning(request, f"Marked {updated} documents as private.")
     
     def changelist_view(self, request, extra_context=None):
         """Add summary statistics to changelist."""
         extra_context = extra_context or {}
         
-        # Get summary statistics
         queryset = self.get_queryset(request)
         stats = queryset.aggregate(
             total_documents=Count('id'),
@@ -396,7 +367,6 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
             total_cost=Sum('total_cost_usd')
         )
         
-        # Status breakdown
         status_counts = dict(
             queryset.values_list('processing_status').annotate(
                 count=Count('id')
@@ -415,14 +385,18 @@ class DocumentAdmin(ModelAdmin, ImportExportModelAdmin):
 
 
 @admin.register(DocumentChunk)
-class DocumentChunkAdmin(ModelAdmin):
-    """Admin interface for DocumentChunk model with Unfold styling."""
+class DocumentChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Admin interface for DocumentChunk model using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['document', 'user']
     
     list_display = [
-        'chunk_display', 'document_link', 'user', 'token_count_display', 
-        'embedding_status', 'embedding_cost_display', 'created_at'
+        'chunk_display', 'document_display', 'user_display', 'token_count_display', 
+        'embedding_status', 'embedding_cost_display', 'created_at_display'
     ]
-    ordering = ['-created_at']  # Newest first
+    list_display_links = ['chunk_display']
+    ordering = ['-created_at']
     list_filter = [
         'embedding_model', 'created_at',
         ('user', AutocompleteSelectFilter),
@@ -435,27 +409,30 @@ class DocumentChunkAdmin(ModelAdmin):
     ]
     
     fieldsets = (
-        ('Basic Information', {
-            'fields': ('id', 'document', 'user', 'chunk_index')
+        ('📄 Basic Information', {
+            'fields': ('id', 'document', 'user', 'chunk_index'),
+            'classes': ('tab',)
         }),
-        ('Content', {
-            'fields': ('content_preview', 'content')
+        ('📝 Content', {
+            'fields': ('content_preview', 'content'),
+            'classes': ('tab',)
         }),
-        ('Embedding Information', {
+        ('🔗 Embedding Information', {
             'fields': ('embedding_model', 'token_count', 'character_count', 'embedding_cost'),
+            'classes': ('tab',)
         }),
-        ('Vector Embedding', {
+        ('🧠 Vector Embedding', {
             'fields': ('embedding',),
-            'classes': ('collapse',)
+            'classes': ('tab', 'collapse')
         }),
-        ('Metadata', {
+        ('🔧 Metadata', {
             'fields': ('metadata',),
-            'classes': ('collapse',),
+            'classes': ('tab', 'collapse'),
             'description': 'Auto-generated chunk metadata (read-only)'
         }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ('created_at', 'updated_at'),
-            'classes': ('collapse',)
+            'classes': ('tab', 'collapse')
         })
     )
     
@@ -465,19 +442,32 @@ class DocumentChunkAdmin(ModelAdmin):
     
     # Form field overrides
     formfield_overrides = {
-        JSONField: {
-            "widget": JSONEditorWidget,
-        }
+        JSONField: {"widget": JSONEditorWidget}
     }
     
-    def get_queryset(self, request):
-        """Optimize queryset with select_related."""
-        return super().get_queryset(request).select_related('document', 'user')
+    actions = ['regenerate_embeddings', 'clear_embeddings']
     
     @display(description="Chunk", ordering="chunk_index")
     def chunk_display(self, obj):
         """Display chunk identifier."""
-        return f"Chunk {obj.chunk_index + 1}"
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.ARTICLE)
+        return StatusBadge.create(
+            text=f"Chunk {obj.chunk_index + 1}",
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Document", ordering="document__title")
+    def document_display(self, obj):
+        """Display document title."""
+        return obj.document.title
+    
+    @display(description="User")
+    def user_display(self, obj):
+        """User display."""
+        if not obj.user:
+            return "—"
+        return self.display_user_simple(obj.user)
     
     @display(description="Tokens", ordering="token_count")
     def token_count_display(self, obj):
@@ -487,58 +477,56 @@ class DocumentChunkAdmin(ModelAdmin):
             return f"{tokens/1000:.1f}K"
         return str(tokens)
     
-    @display(
-        description="Embedding",
-        label={
-            True: 'success',   # green for has embedding
-            False: 'danger'    # red for no embedding
-        }
-    )
+    @display(description="Embedding")
     def embedding_status(self, obj):
         """Display embedding status."""
         has_embedding = obj.embedding is not None and len(obj.embedding) > 0
-        return has_embedding, "✓ Vectorized" if has_embedding else "✗ Not vectorized"
-    
-    @display(description="Document", ordering="document__title")
-    def document_link(self, obj):
-        """Display document title with admin link."""
-        url = reverse('admin:django_cfg_knowbase_document_change', args=[obj.document.id])
-        return format_html(
-            '<a href="{}" style="text-decoration: none;">{}</a>',
-            url,
-            obj.document.title
-        )
+        if has_embedding:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+            return StatusBadge.create(text="✓ Vectorized", variant="success", config=config)
+        else:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.ERROR)
+            return StatusBadge.create(text="✗ Not vectorized", variant="danger", config=config)
     
     @display(description="Cost (USD)", ordering="embedding_cost")
     def embedding_cost_display(self, obj):
         """Display embedding cost with currency formatting."""
-        return f"${obj.embedding_cost:.6f}"
+        config = MoneyDisplayConfig(
+            currency="USD",
+            decimal_places=6,
+            show_sign=False
+        )
+        return self.display_money_amount(obj, 'embedding_cost', config)
+    
+    @display(description="Created")
+    def created_at_display(self, obj):
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
     
     @display(description="Content Preview")
     def content_preview(self, obj):
         """Display content preview with truncation."""
-        preview = obj.content[:200] + "..." if len(obj.content) > 200 else obj.content
-        return format_html(
-            '<div style="max-width: 400px; word-wrap: break-word;">{}</div>',
-            preview
-        )
-    
-    @display(description="Has Embedding", boolean=True)
-    def has_embedding(self, obj):
-        """Check if chunk has embedding vector."""
-        return obj.embedding is not None and len(obj.embedding) > 0
+        return obj.content[:200] + "..." if len(obj.content) > 200 else obj.content
     
     @display(description="Embedding Info")
     def embedding_info(self, obj):
         """Display embedding information safely."""
         if obj.embedding is not None and len(obj.embedding) > 0:
-            return format_html(
-                '<span style="color: green;">✓ Vector ({} dimensions)</span>',
-                len(obj.embedding)
-            )
-        return format_html(
-            '<span style="color: red;">✗ No embedding</span>'
-        )
+            return f"✓ Vector ({len(obj.embedding)} dimensions)"
+        return "✗ No embedding"
+    
+    @action(description="Regenerate embeddings", variant=ActionVariant.INFO)
+    def regenerate_embeddings(self, request, queryset):
+        """Regenerate embeddings for selected chunks."""
+        count = queryset.count()
+        messages.info(request, f"Regenerate embeddings functionality not implemented yet. {count} chunks selected.")
+    
+    @action(description="Clear embeddings", variant=ActionVariant.WARNING)
+    def clear_embeddings(self, request, queryset):
+        """Clear embeddings for selected chunks."""
+        updated = queryset.update(embedding=None)
+        messages.warning(request, f"Cleared embeddings for {updated} chunks.")
     
     def changelist_view(self, request, extra_context=None):
         """Add chunk statistics to changelist."""
@@ -553,7 +541,6 @@ class DocumentChunkAdmin(ModelAdmin):
             avg_tokens_per_chunk=Avg('token_count')
         )
         
-        # Model breakdown
         model_counts = dict(
             queryset.values_list('embedding_model').annotate(
                 count=Count('id')
@@ -573,28 +560,30 @@ class DocumentChunkAdmin(ModelAdmin):
 
 
 @admin.register(DocumentCategory)
-class DocumentCategoryAdmin(ModelAdmin, ImportExportModelAdmin):
-    """Admin interface for DocumentCategory model with Unfold styling."""
+class DocumentCategoryAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ImportExportModelAdmin):
+    """Admin interface for DocumentCategory model using Django Admin Utilities."""
     
     # Import/Export configuration
     import_form_class = ImportForm
     export_form_class = ExportForm
     
     list_display = [
-        'short_uuid', 'name', 'visibility_badge', 'document_count', 'created_at'
+        'short_uuid', 'name_display', 'visibility_display', 'document_count', 'created_at_display'
     ]
-    ordering = ['-created_at']  # Newest first
+    list_display_links = ['name_display']
+    ordering = ['-created_at']
     list_filter = ['is_public', 'created_at']
     search_fields = ['name', 'description']
     readonly_fields = ['id', 'created_at', 'updated_at']
     
     fieldsets = (
-        ('Basic Information', {
-            'fields': ('id', 'name', 'description', 'is_public')
+        ('📁 Basic Information', {
+            'fields': ('id', 'name', 'description', 'is_public'),
+            'classes': ('tab',)
         }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ('created_at', 'updated_at'),
-            'classes': ('collapse',)
+            'classes': ('tab', 'collapse')
         })
     )
     
@@ -604,36 +593,54 @@ class DocumentCategoryAdmin(ModelAdmin, ImportExportModelAdmin):
     
     # Form field overrides
     formfield_overrides = {
-        models.TextField: {
-            "widget": WysiwygWidget,
-        }
+        models.TextField: {"widget": WysiwygWidget}
     }
     
-    @display(
-        description="Visibility",
-        ordering="is_public",
-        label={
-            'public': 'success',
-            'private': 'danger'
-        }
-    )
-    def visibility_badge(self, obj):
-        """Display visibility status with color coding."""
-        status = 'public' if obj.is_public else 'private'
-        label = 'Public' if obj.is_public else 'Private'
-        return status, label
+    actions = ['make_public', 'make_private']
+    
+    @display(description="Category Name")
+    def name_display(self, obj):
+        """Display category name."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.FOLDER)
+        return StatusBadge.create(
+            text=obj.name,
+            variant="primary",
+            config=config
+        )
+    
+    @display(description="Visibility")
+    def visibility_display(self, obj):
+        """Display visibility status."""
+        if obj.is_public:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.PUBLIC)
+            return StatusBadge.create(text="Public", variant="success", config=config)
+        else:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.LOCK)
+            return StatusBadge.create(text="Private", variant="danger", config=config)
     
     @display(description="Documents", ordering="document_count")
     def document_count(self, obj):
         """Display count of documents in this category."""
         count = obj.documents.count()
-        if count > 0:
-            url = f"/admin/knowbase/document/?categories__id__exact={obj.id}"
-            return format_html(
-                '<a href="{}" style="text-decoration: none;">{} documents</a>',
-                url, count
-            )
-        return "0 documents"
+        return f"{count} documents"
+    
+    @display(description="Created")
+    def created_at_display(self, obj):
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
+    
+    @action(description="Make public", variant=ActionVariant.SUCCESS)
+    def make_public(self, request, queryset):
+        """Make selected categories public."""
+        updated = queryset.update(is_public=True)
+        messages.success(request, f"Made {updated} categories public.")
+    
+    @action(description="Make private", variant=ActionVariant.WARNING)
+    def make_private(self, request, queryset):
+        """Make selected categories private."""
+        updated = queryset.update(is_public=False)
+        messages.warning(request, f"Made {updated} categories private.")
     
     def get_queryset(self, request):
         """Optimize queryset with prefetch_related."""