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

django_cfg/apps/knowbase/admin/archive_admin.py

@@ -1,11 +1,12 @@
 """
-Admin interface for archive models with Unfold optimization.
+Archive admin interfaces using Django Admin Utilities.
+
+Enhanced archive management with Material Icons and optimized queries.
 """
 
 import hashlib
 import logging
 from django.contrib import admin, messages
-from django.utils.html import format_html
 from django.urls import reverse
 from django.utils.safestring import mark_safe
 from django.db import models
@@ -14,12 +15,23 @@ from django.db.models.fields.json import JSONField
 from django.shortcuts import redirect
 from django_json_widget.widgets import JSONEditorWidget
 from unfold.admin import ModelAdmin, TabularInline
-from unfold.decorators import display, action
-from unfold.enums import ActionVariant
 from unfold.contrib.filters.admin import AutocompleteSelectFilter
 from unfold.contrib.forms.widgets import WysiwygWidget
 from django_cfg import ExportMixin
 
+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.archive import DocumentArchive, ArchiveItem, ArchiveItemChunk
 
 logger = logging.getLogger(__name__)
@@ -32,20 +44,17 @@ class ArchiveItemInline(TabularInline):
     verbose_name = "Archive Item"
     verbose_name_plural = "📁 Archive Items (Read-only)"
     extra = 0
-    max_num = 0  # No new items allowed
-    can_delete = False  # Prevent deletion through inline
-    show_change_link = True  # Allow viewing individual items
+    max_num = 0
+    can_delete = False
+    show_change_link = True
     
     def has_add_permission(self, request, obj=None):
-        """Disable adding new items through inline."""
         return False
     
     def has_change_permission(self, request, obj=None):
-        """Disable editing items through inline."""
         return False
     
     def has_delete_permission(self, request, obj=None):
-        """Disable deleting items through inline."""
         return False
     
     fields = [
@@ -57,9 +66,8 @@ class ArchiveItemInline(TabularInline):
         'is_processable', 'chunks_count', '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="File Size")
     def file_size_display_inline(self, obj):
@@ -77,15 +85,19 @@ class ArchiveItemInline(TabularInline):
 
 
 @admin.register(DocumentArchive)
-class DocumentArchiveAdmin(ExportMixin, ModelAdmin):
-    """Admin interface for DocumentArchive."""
+class DocumentArchiveAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
+    """Admin interface for DocumentArchive using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['user']
     
     list_display = [
-        'title_display', 'user', 'archive_type_badge', 'status_badge',
+        'title_display', 'user_display', 'archive_type_display', 'status_display',
         'items_count', 'chunks_count', 'vectorization_progress', 'file_size_display',
-        'progress_display', 'created_at'
+        'progress_display', 'created_at_display'
     ]
-    ordering = ['-created_at']  # Newest first
+    list_display_links = ['title_display']
+    ordering = ['-created_at']
     inlines = [ArchiveItemInline]
     list_filter = [
         'processing_status', 'archive_type', 'is_public',
@@ -98,40 +110,33 @@ class DocumentArchiveAdmin(ExportMixin, ModelAdmin):
         'id', 'user', 'content_hash', 'original_filename', 'file_size', 'archive_type',
         'processing_status', 'processed_at', 'processing_duration_ms', 
         'processing_error', 'total_items', 'processed_items', 'total_chunks', 
-        'vectorized_chunks', 'total_tokens', 'total_cost_usd', 'created_at', 
-        'updated_at', 'progress_display', 'vectorization_progress_display',
-        'items_link', 'chunks_link'
+        'vectorized_chunks', 'total_cost_usd', 'created_at', 'updated_at'
     ]
+    
     fieldsets = (
-        ('Basic Information', {
-            'fields': ('id', 'title', 'description', 'user', 'categories', 'is_public')
+        ('📁 Archive Info', {
+            'fields': ('id', 'title', 'description', 'user', 'categories', 'is_public'),
+            'classes': ('tab',)
         }),
-        ('Archive Details', {
-            'fields': (
-                'archive_file', 'original_filename', 'file_size', 'archive_type',
-                'content_hash'
-            )
+        ('📄 File Details', {
+            'fields': ('original_filename', 'file_size', 'archive_type', 'content_hash'),
+            'classes': ('tab',)
         }),
-        ('Processing Status', {
+        ('⚙️ Processing Status', {
             'fields': (
                 'processing_status', 'processed_at', 'processing_duration_ms',
-                'processing_error', 'progress_display',
-                'vectorization_progress_display'
-            )
+                'processing_error'
+            ),
+            'classes': ('tab',)
         }),
-        ('Statistics', {
-            'fields': (
-                'total_items', 'processed_items', 'total_chunks',
-                'vectorized_chunks', 'total_tokens', 'total_cost_usd'
-            )
-        }),
-        ('Related Data', {
-            'fields': ('items_link', 'chunks_link')
+        ('📊 Statistics', {
+            'fields': ('total_items', 'processed_items', 'total_chunks', 'vectorized_chunks', 'total_cost_usd'),
+            'classes': ('tab',)
         }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ('created_at', 'updated_at'),
-            'classes': ('collapse',)
-        }),
+            'classes': ('tab', 'collapse')
+        })
     )
     filter_horizontal = ['categories']
     
@@ -141,485 +146,259 @@ class DocumentArchiveAdmin(ExportMixin, ModelAdmin):
     
     # Form field overrides
     formfield_overrides = {
-        models.TextField: {
-            "widget": WysiwygWidget,
-        },
-        JSONField: {
-            "widget": JSONEditorWidget,
-        }
+        models.TextField: {"widget": WysiwygWidget},
+        JSONField: {"widget": JSONEditorWidget}
     }
     
+    actions = ['reprocess_archives', 'mark_as_public', 'mark_as_private']
+    
     @display(description="Archive Title", ordering="title")
     def title_display(self, obj):
-        """Display archive title with truncation."""
+        """Display archive title."""
         title = obj.title or "Untitled Archive"
         if len(title) > 50:
             title = title[:47] + "..."
-        return format_html(
-            '<div style="font-weight: 500;">{}</div>',
-            title
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.ARCHIVE)
+        return StatusBadge.create(
+            text=title,
+            variant="primary",
+            config=config
         )
     
-    @display(
-        description="Archive Type",
-        ordering="archive_type",
-        label={
-            'DOCUMENTS': 'info',     # blue for documents
-            'CODE': 'success',       # green for code
-            'MIXED': 'warning',      # orange for mixed
-            'OTHER': 'danger'        # red for other
-        }
-    )
-    def archive_type_badge(self, obj):
-        """Display archive type with color coding."""
-        return obj.archive_type, obj.get_archive_type_display()
-    
-    @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
+    @display(description="User")
+    def user_display(self, obj):
+        """User display."""
+        if not obj.user:
+            return "—"
+        return self.display_user_simple(obj.user)
+    
+    @display(description="Archive Type")
+    def archive_type_display(self, obj):
+        """Display archive type with badge."""
+        if not obj.archive_type:
+            return "—"
+        
+        type_variants = {
+            'zip': 'info',
+            'tar': 'warning',
+            'rar': 'secondary',
+            '7z': 'primary'
         }
-    )
-    def status_badge(self, obj):
-        """Display processing status with color coding."""
-        return obj.processing_status, obj.get_processing_status_display()
+        variant = type_variants.get(obj.archive_type.lower(), 'secondary')
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.FOLDER_ZIP)
+        return StatusBadge.create(
+            text=obj.archive_type.upper(),
+            variant=variant,
+            config=config
+        )
     
-    @display(description="File Size", ordering="file_size")
-    def file_size_display(self, obj):
-        """Display file size in human readable format."""
-        size = obj.file_size
-        for unit in ['B', 'KB', 'MB', 'GB']:
-            if size < 1024.0:
-                return f"{size:.1f} {unit}"
-            size /= 1024.0
-        return f"{size:.1f} TB"
+    @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="Items", ordering="total_items")
     def items_count(self, obj):
-        """Display items count with link."""
-        count = obj.total_items
-        if count > 0:
-            url = f"/admin/knowbase/archiveitem/?archive__id__exact={obj.id}"
-            return format_html(
-                '<a href="{}" style="text-decoration: none;">{} items</a>',
-                url, count
-            )
-        return "0 items"
+        """Display items count."""
+        total = obj.total_items or 0
+        processed = obj.processed_items or 0
+        return f"{processed}/{total} items"
     
     @display(description="Chunks", ordering="total_chunks")
     def chunks_count(self, obj):
-        """Display chunks count with link."""
-        count = obj.total_chunks
-        if count > 0:
-            url = f"/admin/knowbase/archiveitemchunk/?archive__id__exact={obj.id}"
-            return format_html(
-                '<a href="{}" style="text-decoration: none;">{} chunks</a>',
-                url, count
-            )
-        return "0 chunks"
-    
-    @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
-        }
-    )
+        """Display chunks count."""
+        total = obj.total_chunks or 0
+        vectorized = obj.vectorized_chunks or 0
+        return f"{vectorized}/{total} chunks"
+    
+    @display(description="Vectorization")
     def vectorization_progress(self, obj):
-        """Display vectorization progress with color coding."""
-        try:
-            # Check processing status first
-            if obj.processing_status == 'pending':
-                return 'no_chunks', 'Pending'
-            elif obj.processing_status == 'processing':
-                return 'partial', 'Processing...'
-            elif obj.processing_status == 'failed':
-                return 'none', 'Failed'
-            
-            progress = DocumentArchive.objects.get_vectorization_progress(obj.id)
-            total = progress['total']
-            vectorized = progress['vectorized']
-            percentage = progress['percentage']
-            
-            if total == 0:
-                return 'no_chunks', 'No chunks'
-            elif percentage == 100:
-                return 'completed', f'{vectorized}/{total} (100%)'
-            elif percentage > 0:
-                return 'partial', f'{vectorized}/{total} ({percentage}%)'
-            else:
-                return 'none', f'{vectorized}/{total} (0%)'
-        except Exception as e:
-            # Log the error for debugging
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error getting vectorization progress for archive {obj.id}: {e}")
-            return 'no_chunks', 'Not ready'
-    
-    @display(description="Overall Progress")
-    def progress_display(self, obj):
-        """Display overall progress including processing and vectorization."""
-        from ..models.base import ProcessingStatus
+        """Display vectorization progress."""
+        total = obj.total_chunks or 0
+        vectorized = obj.vectorized_chunks or 0
         
-        # Calculate overall progress: 50% for processing, 50% for vectorization
-        processing_progress = obj.processing_progress
+        if total == 0:
+            return "No chunks"
         
-        # Get vectorization progress
-        try:
-            vectorization_stats = DocumentArchive.objects.get_vectorization_progress(obj.id)
-            vectorization_progress = vectorization_stats.get('percentage', 0)
-        except Exception:
-            vectorization_progress = 0
+        percentage = (vectorized / total) * 100
         
-        # Overall progress: processing (50%) + vectorization (50%)
-        overall_progress = (processing_progress * 0.5) + (vectorization_progress * 0.5)
-        
-        # Determine color based on status and progress
-        if obj.processing_status == ProcessingStatus.COMPLETED and vectorization_progress == 100:
-            color_class = "bg-green-500"  # Fully complete
-        elif obj.processing_status == ProcessingStatus.FAILED:
-            color_class = "bg-red-500"    # Failed
-        elif overall_progress > 0:
-            color_class = "bg-blue-500"   # In progress
+        if percentage == 100:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+            return StatusBadge.create(text="100%", variant="success", config=config)
+        elif percentage > 0:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.SCHEDULE)
+            return StatusBadge.create(text=f"{percentage:.1f}%", variant="warning", config=config)
         else:
-            color_class = "bg-gray-300"   # Not started
-        
-        return format_html(
-            '<div class="w-24 bg-gray-200 rounded-full h-2 dark:bg-gray-700">'
-            '<div class="{} h-2 rounded-full transition-all duration-300" style="width: {}%"></div>'
-            '</div>'
-            '<span class="text-xs text-gray-600 dark:text-gray-400 ml-2">{}%</span>',
-            color_class, overall_progress, int(overall_progress)
-        )
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.ERROR)
+            return StatusBadge.create(text="0%", variant="danger", config=config)
     
-    def vectorization_progress_display(self, obj: DocumentArchive) -> str:
-        """Display vectorization progress with progress bar."""
-        progress = obj.vectorization_progress
-        color = 'green' if progress == 100 else 'blue' if progress > 0 else 'gray'
-        
-        return format_html(
-            '<div style="width: 100px; background-color: #f0f0f0; border-radius: 3px;">'
-            '<div style="width: {}%; height: 20px; background-color: {}; border-radius: 3px; '
-            'text-align: center; line-height: 20px; color: white; font-size: 12px;">'
-            '{}%</div></div>',
-            progress, color, round(progress, 1)
-        )
-    vectorization_progress_display.short_description = "Vectorization Progress"
-    
-    def items_link(self, obj: DocumentArchive) -> str:
-        """Link to archive items."""
-        if obj.pk:
-            url = reverse('admin:django_cfg_knowbase_archiveitem_changelist')
-            return format_html(
-                '<a href="{}?archive__id__exact={}">View {} Items</a>',
-                url, obj.pk, obj.total_items
-            )
-        return "No items yet"
-    items_link.short_description = "Items"
-    
-    def chunks_link(self, obj: DocumentArchive) -> str:
-        """Link to archive chunks."""
-        if obj.pk:
-            url = reverse('admin:django_cfg_knowbase_archiveitemchunk_changelist')
-            return format_html(
-                '<a href="{}?archive__id__exact={}">View {} Chunks</a>',
-                url, obj.pk, obj.total_chunks
-            )
-        return "No chunks yet"
-    chunks_link.short_description = "Chunks"
+    @display(description="File Size", ordering="file_size")
+    def file_size_display(self, obj):
+        """Display file size in human readable format."""
+        size = obj.file_size
+        for unit in ['B', 'KB', 'MB']:
+            if size < 1024.0:
+                return f"{size:.1f} {unit}"
+            size /= 1024.0
+        return f"{size:.1f} GB"
     
-    def get_queryset(self, request):
-        """Optimize queryset with select_related."""
-        # Use all_users() to show all archives in admin, then filter by user if needed
-        queryset = DocumentArchive.objects.all_users().select_related('user').prefetch_related('categories')
-        
-        # For non-superusers, filter by their own archives
-        if not request.user.is_superuser:
-            queryset = queryset.filter(user=request.user)
+    @display(description="Progress")
+    def progress_display(self, obj):
+        """Display overall progress."""
+        total_items = obj.total_items or 0
+        processed_items = obj.processed_items or 0
         
-        return queryset
-    
-    def save_model(self, request, obj, form, change):
-        """Automatically set user and file metadata when creating new archives."""
-        if not change:  # Only for new archives
-            obj.user = request.user
-            
-            # Auto-populate metadata from uploaded file
-            if obj.archive_file:
-                import hashlib
-                import os
-                
-                # Set original filename
-                if not obj.original_filename:
-                    obj.original_filename = obj.archive_file.name
-                
-                # Set file size
-                if not obj.file_size and hasattr(obj.archive_file, 'size'):
-                    obj.file_size = obj.archive_file.size
-                
-                # Check for duplicates using manager method
-                is_duplicate, existing_archive = DocumentArchive.objects.check_duplicate_before_save(
-                    user=obj.user,
-                    title=obj.title,
-                    file_size=obj.file_size
-                )
-                
-                if is_duplicate and existing_archive:
-                    messages.error(
-                        request,
-                        f'❌ An archive with the same title and file size already exists: "{existing_archive.title}" '
-                        f'(created {existing_archive.created_at.strftime("%Y-%m-%d %H:%M")}). '
-                        f'Please use a different title or check if this is a duplicate upload.'
-                    )
-                    # Don't save, just return - this will keep the form open with the error
-                    return
-                
-                # Set archive type based on file extension
-                if not obj.archive_type:
-                    filename = obj.archive_file.name.lower()
-                    
-                    # ZIP formats
-                    if filename.endswith(('.zip', '.jar', '.war', '.ear')):
-                        obj.archive_type = 'zip'
-                    # TAR.GZ formats
-                    elif filename.endswith(('.tar.gz', '.tgz')):
-                        obj.archive_type = 'tar.gz'
-                    # TAR.BZ2 formats  
-                    elif filename.endswith(('.tar.bz2', '.tbz2', '.tar.bzip2')):
-                        obj.archive_type = 'tar.bz2'
-                    # TAR formats
-                    elif filename.endswith('.tar'):
-                        obj.archive_type = 'tar'
-                    else:
-                        # Default to zip for unknown formats
-                        obj.archive_type = 'zip'
-                
-                # Generate content hash
-                if not obj.content_hash and hasattr(obj.archive_file, 'read'):
-                    obj.archive_file.seek(0)
-                    content = obj.archive_file.read()
-                    obj.content_hash = hashlib.sha256(content).hexdigest()
-                    obj.archive_file.seek(0)
+        if total_items == 0:
+            return "No items"
         
-        super().save_model(request, obj, form, change)
+        percentage = (processed_items / total_items) * 100
+        return f"{percentage:.1f}%"
+    
+    @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="Reprocess archives", variant=ActionVariant.INFO)
+    def reprocess_archives(self, request, queryset):
+        """Reprocess selected archives."""
+        count = queryset.count()
+        messages.info(request, f"Reprocess functionality not implemented yet. {count} archives selected.")
+    
+    @action(description="Mark as public", variant=ActionVariant.SUCCESS)
+    def mark_as_public(self, request, queryset):
+        """Mark selected archives as public."""
+        updated = queryset.update(is_public=True)
+        messages.success(request, f"Marked {updated} archives as public.")
+    
+    @action(description="Mark as private", variant=ActionVariant.WARNING)
+    def mark_as_private(self, request, queryset):
+        """Mark selected archives as private."""
+        updated = queryset.update(is_public=False)
+        messages.warning(request, f"Marked {updated} archives as private.")
     
     def changelist_view(self, request, extra_context=None):
-        """Add summary statistics to changelist."""
+        """Add archive statistics to changelist."""
         extra_context = extra_context or {}
         
-        # Get summary statistics
         queryset = self.get_queryset(request)
         stats = queryset.aggregate(
             total_archives=Count('id'),
+            completed_archives=Count('id', filter=Q(processing_status='completed')),
             total_items=Sum('total_items'),
             total_chunks=Sum('total_chunks'),
             total_cost=Sum('total_cost_usd')
         )
         
-        # Status breakdown
-        status_counts = dict(
-            queryset.values_list('processing_status').annotate(
-                count=Count('id')
-            )
-        )
-        
         extra_context['archive_stats'] = {
             'total_archives': stats['total_archives'] or 0,
+            'completed_archives': stats['completed_archives'] or 0,
             'total_items': stats['total_items'] or 0,
             'total_chunks': stats['total_chunks'] or 0,
-            'total_cost': f"${(stats['total_cost'] or 0):.6f}",
-            'status_counts': status_counts
+            'total_cost': f"${(stats['total_cost'] or 0):.6f}"
         }
         
         return super().changelist_view(request, extra_context)
-    
-    # Actions for detail view
-    actions_detail = ["reprocess_archive"]
-    
-    @action(
-        description="🔄 Reprocess Archive",
-        icon="refresh",
-        variant=ActionVariant.WARNING
-    )
-    def reprocess_archive(self, request, object_id):
-        """Force reprocessing of the archive."""
-        try:
-            # Get the archive object to get its title for the message
-            archive = self.get_object(request, object_id)
-            if not archive:
-                self.message_user(request, "Archive not found.", level='error')
-                return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-            
-            # Use custom manager method to reprocess
-            DocumentArchive.objects.reprocess(object_id)
-            
-            self.message_user(
-                request, 
-                f"Archive '{archive.title}' has been reset and queued for reprocessing.", 
-                level='success'
-            )
-            
-        except ValueError as e:
-            self.message_user(
-                request, 
-                f"Error reprocessing archive: {e}", 
-                level='error'
-            )
-        except Exception as e:
-            logger.exception(f"Unexpected error reprocessing archive {object_id}")
-            self.message_user(
-                request, 
-                f"Unexpected error reprocessing archive: {e}", 
-                level='error'
-            )
-        
-        return redirect(request.META.get('HTTP_REFERER', '/admin/'))
 
 
 @admin.register(ArchiveItem)
-class ArchiveItemAdmin(ExportMixin, ModelAdmin):
-    """Admin interface for ArchiveItem."""
+class ArchiveItemAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
+    """Admin interface for ArchiveItem using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['archive', 'user']
     
     list_display = [
-        'item_name_display', 'archive_link', 'content_type_badge', 'language_badge',
-        'processable_badge', 'chunks_count_display', 'file_size_display', 'created_at'
+        'item_name_display', 'archive_display', 'user_display', 'content_type_display',
+        'file_size_display', 'processable_display', 'chunks_count_display', 'created_at_display'
     ]
-    ordering = ['-created_at']  # Newest first
+    list_display_links = ['item_name_display']
+    ordering = ['-created_at']
     list_filter = [
-        'content_type', 'is_processable', 'language', 'created_at',
-        'archive__processing_status',
-        ('archive', AutocompleteSelectFilter)
-    ]
-    search_fields = [
-        'item_name', 'relative_path', 'archive__title',
-        'language', 'archive__user__username'
+        'content_type', 'is_processable', 'created_at',
+        ('archive', AutocompleteSelectFilter),
+        ('user', AutocompleteSelectFilter)
     ]
-    autocomplete_fields = ['archive']
+    search_fields = ['item_name', 'content_type', 'archive__title', 'user__username']
+    autocomplete_fields = ['archive', 'user']
     readonly_fields = [
-        'id', 'user', 'content_hash', 'chunks_count', 'total_tokens',
-        'processing_cost', 'created_at', 'updated_at',
-        'archive_link', 'chunks_link', 'content_preview'
+        'id', 'user', 'file_size', 'content_type', 'is_processable',
+        'chunks_count', 'created_at', 'updated_at'
     ]
+    
     fieldsets = (
-        ('Basic Information', {
-            'fields': ('id', 'archive_link', 'user', 'relative_path', 'item_name')
-        }),
-        ('File Details', {
-            'fields': (
-                'item_type', 'content_type', 'file_size',
-                'content_hash', 'language', 'encoding'
-            )
+        ('📄 Item Info', {
+            'fields': ('id', 'item_name', 'archive', 'user'),
+            'classes': ('tab',)
         }),
-        ('Processing', {
-            'fields': (
-                'is_processable', 'chunks_count', 'total_tokens',
-                'processing_cost'
-            )
-        }),
-        ('Content', {
-            'fields': ('content_preview',),
-            'classes': ('collapse',)
+        ('📁 File Details', {
+            'fields': ('content_type', 'file_size', 'is_processable'),
+            'classes': ('tab',)
         }),
-        ('Metadata', {
-            'fields': ('metadata',),
-            'classes': ('collapse',)
+        ('📊 Processing', {
+            'fields': ('chunks_count',),
+            'classes': ('tab',)
         }),
-        ('Related Data', {
-            'fields': ('chunks_link',)
-        }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ('created_at', 'updated_at'),
-            'classes': ('collapse',)
-        }),
+            'classes': ('tab', 'collapse')
+        })
     )
     
-    # Unfold configuration
-    compressed_fields = True
-    warn_unsaved_form = True
-    
-    # Form field overrides
-    formfield_overrides = {
-        models.TextField: {
-            "widget": WysiwygWidget,
-        },
-        JSONField: {
-            "widget": JSONEditorWidget,
-        }
-    }
+    actions = ['mark_as_processable', 'mark_as_not_processable']
     
     @display(description="Item Name", ordering="item_name")
     def item_name_display(self, obj):
-        """Display item name with truncation."""
-        name = obj.item_name or "Unnamed Item"
-        if len(name) > 40:
-            name = name[:37] + "..."
-        return format_html(
-            '<div style="font-weight: 500;">{}</div>',
-            name
+        """Display item name."""
+        name = obj.item_name
+        if len(name) > 50:
+            name = name[:47] + "..."
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.INSERT_DRIVE_FILE)
+        return StatusBadge.create(
+            text=name,
+            variant="primary",
+            config=config
         )
     
     @display(description="Archive", ordering="archive__title")
-    def archive_link(self, obj):
-        """Link to parent archive."""
-        if obj.archive:
-            url = reverse('admin:django_cfg_knowbase_documentarchive_change', args=[obj.archive.pk])
-            title = obj.archive.title[:30] + "..." if len(obj.archive.title) > 30 else obj.archive.title
-            return format_html('<a href="{}" style="text-decoration: none;">{}</a>', url, title)
-        return "No archive"
-    
-    @display(
-        description="Content Type",
-        ordering="content_type",
-        label={
-            'TEXT': 'info',      # blue for text
-            'CODE': 'success',   # green for code
-            'BINARY': 'warning', # orange for binary
-            'OTHER': 'secondary' # gray for other
-        }
-    )
-    def content_type_badge(self, obj):
-        """Display content type with color coding."""
-        return obj.content_type, obj.get_content_type_display()
-    
-    @display(
-        description="Language",
-        ordering="language",
-        label=True
-    )
-    def language_badge(self, obj):
-        """Display language with badge."""
-        return obj.language or "Unknown"
-    
-    @display(
-        description="Processable",
-        ordering="is_processable",
-        label={
-            True: 'success',   # green for processable
-            False: 'danger'    # red for not processable
-        }
-    )
-    def processable_badge(self, obj):
-        """Display processable status."""
-        return obj.is_processable, "Yes" if obj.is_processable else "No"
-    
-    @display(description="Chunks", ordering="chunks_count")
-    def chunks_count_display(self, obj):
-        """Display chunks count with link."""
-        count = obj.chunks_count
-        if count > 0:
-            url = f"/admin/knowbase/archiveitemchunk/?item__id__exact={obj.id}"
-            return format_html(
-                '<a href="{}" style="text-decoration: none;">{} chunks</a>',
-                url, count
-            )
-        return "0 chunks"
+    def archive_display(self, obj):
+        """Display archive title."""
+        return obj.archive.title or "Untitled Archive"
+    
+    @display(description="User")
+    def user_display(self, obj):
+        """User display."""
+        if not obj.user:
+            return "—"
+        return self.display_user_simple(obj.user)
+    
+    @display(description="Content Type")
+    def content_type_display(self, obj):
+        """Display content type with badge."""
+        if not obj.content_type:
+            return "—"
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.DESCRIPTION)
+        return StatusBadge.create(
+            text=obj.content_type,
+            variant="info",
+            config=config
+        )
     
     @display(description="File Size", ordering="file_size")
     def file_size_display(self, obj):
@@ -631,123 +410,112 @@ class ArchiveItemAdmin(ExportMixin, ModelAdmin):
             size /= 1024.0
         return f"{size:.1f} GB"
     
-    def chunks_link(self, obj: ArchiveItem) -> str:
-        """Link to item chunks."""
-        if obj.pk:
-            url = reverse('admin:django_cfg_knowbase_archiveitemchunk_changelist')
-            return format_html(
-                '<a href="{}?item__id__exact={}">View {} Chunks</a>',
-                url, obj.pk, obj.chunks_count
-            )
-        return "No chunks yet"
-    chunks_link.short_description = "Chunks"
-    
-    def content_preview(self, obj: ArchiveItem) -> str:
-        """Show content preview."""
-        if obj.raw_content:
-            preview = obj.raw_content[:500]
-            if len(obj.raw_content) > 500:
-                preview += "..."
-            return format_html('<pre style="white-space: pre-wrap;">{}</pre>', preview)
-        return "No content"
-    content_preview.short_description = "Content Preview"
-    
-    def get_queryset(self, request):
-        """Optimize queryset with select_related."""
-        # Use all_users() to show all archive items in admin, then filter by user if needed
-        queryset = ArchiveItem.objects.all_users().select_related('archive', 'user')
-        
-        # For non-superusers, filter by their own items
-        if not request.user.is_superuser:
-            queryset = queryset.filter(user=request.user)
-        
-        return queryset
+    @display(description="Processable")
+    def processable_display(self, obj):
+        """Display processable status."""
+        if obj.is_processable:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+            return StatusBadge.create(text="Yes", variant="success", config=config)
+        else:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.CANCEL)
+            return StatusBadge.create(text="No", variant="danger", config=config)
     
-    def save_model(self, request, obj, form, change):
-        """Automatically set user to current user when creating new archive items."""
-        if not change:  # Only for new items
-            obj.user = request.user
-        super().save_model(request, obj, form, change)
+    @display(description="Chunks", ordering="chunks_count")
+    def chunks_count_display(self, obj):
+        """Display chunks count."""
+        count = obj.chunks_count or 0
+        return f"{count} chunks"
+    
+    @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="Mark as processable", variant=ActionVariant.SUCCESS)
+    def mark_as_processable(self, request, queryset):
+        """Mark selected items as processable."""
+        updated = queryset.update(is_processable=True)
+        messages.success(request, f"Marked {updated} items as processable.")
+    
+    @action(description="Mark as not processable", variant=ActionVariant.WARNING)
+    def mark_as_not_processable(self, request, queryset):
+        """Mark selected items as not processable."""
+        updated = queryset.update(is_processable=False)
+        messages.warning(request, f"Marked {updated} items as not processable.")
 
 
 @admin.register(ArchiveItemChunk)
-class ArchiveItemChunkAdmin(ModelAdmin):
-    """Admin interface for ArchiveItemChunk."""
+class ArchiveItemChunkAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
+    """Admin interface for ArchiveItemChunk using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['archive_item', 'user']
     
     list_display = [
-        'chunk_display', 'archive_link', 'item_link', 'chunk_type_badge',
-        'token_count_display', 'embedding_status', 'cost_display', 'created_at'
+        'chunk_display', 'archive_item_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 = [
-        'chunk_type', 'created_at', 'embedding_model',
-        'item__content_type', 'item__language',
-        ('item', AutocompleteSelectFilter),
-        ('archive', AutocompleteSelectFilter)
+        'embedding_model', 'created_at',
+        ('user', AutocompleteSelectFilter),
+        ('archive_item', AutocompleteSelectFilter)
     ]
-    search_fields = [
-        'content', 'item__item_name', 'item__relative_path',
-        'archive__title', 'item__archive__user__username'
-    ]
-    autocomplete_fields = ['item', 'archive']
+    search_fields = ['archive_item__item_name', 'user__username', 'content']
+    autocomplete_fields = ['item', 'user']
     readonly_fields = [
-        'id', 'user', 'token_count', 'character_count', 'embedding_model',
-        'embedding_cost', 'created_at', 'updated_at',
-        'archive_link', 'item_link', 'content_preview',
-        'context_summary', 'embedding_status'
+        'id', 'token_count', 'character_count', 'embedding_cost',
+        'created_at', 'updated_at', 'content_preview'
     ]
+    
     fieldsets = (
-        ('Basic Information', {
-            'fields': ('id', 'archive_link', 'item_link', 'user', 'chunk_index', 'chunk_type')
+        ('📄 Chunk Info', {
+            'fields': ('id', 'archive_item', 'user', 'chunk_index'),
+            'classes': ('tab',)
         }),
-        ('Content', {
-            'fields': ('content_preview',)
+        ('📝 Content', {
+            'fields': ('content_preview', 'content'),
+            'classes': ('tab',)
         }),
-        ('Context', {
-            'fields': ('context_summary',),
-            'classes': ('collapse',)
+        ('🔗 Embedding', {
+            'fields': ('embedding_model', 'token_count', 'character_count', 'embedding_cost'),
+            'classes': ('tab',)
         }),
-        ('Vectorization', {
-            'fields': (
-                'embedding_status', 'token_count', 'character_count',
-                'embedding_model', 'embedding_cost'
-            )
+        ('🧠 Vector', {
+            'fields': ('embedding',),
+            'classes': ('tab', 'collapse')
         }),
-        ('Timestamps', {
+        ('⏰ Timestamps', {
             'fields': ('created_at', 'updated_at'),
-            'classes': ('collapse',)
-        }),
+            'classes': ('tab', 'collapse')
+        })
     )
     
-    # Unfold configuration
-    compressed_fields = True
-    warn_unsaved_form = True
-    
-    # Form field overrides
-    formfield_overrides = {
-        JSONField: {
-            "widget": JSONEditorWidget,
-        }
-    }
+    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}"
-    
-    @display(
-        description="Chunk Type",
-        ordering="chunk_type",
-        label={
-            'CONTENT': 'info',     # blue for content
-            'HEADER': 'success',   # green for header
-            'FOOTER': 'warning',   # orange for footer
-            'METADATA': 'secondary' # gray for metadata
-        }
-    )
-    def chunk_type_badge(self, obj):
-        """Display chunk type with color coding."""
-        return obj.chunk_type, obj.get_chunk_type_display()
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.ARTICLE)
+        return StatusBadge.create(
+            text=f"Chunk {obj.chunk_index + 1}",
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Archive Item", ordering="archive_item__item_name")
+    def archive_item_display(self, obj):
+        """Display archive item name."""
+        return obj.archive_item.item_name
+    
+    @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):
@@ -757,102 +525,46 @@ class ArchiveItemChunkAdmin(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"
+        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 cost_display(self, obj):
+    def embedding_cost_display(self, obj):
         """Display embedding cost with currency formatting."""
-        return f"${obj.embedding_cost:.6f}"
-    
-    def archive_link(self, obj: ArchiveItemChunk) -> str:
-        """Link to parent archive."""
-        if obj.archive:
-            url = reverse('admin:django_cfg_knowbase_documentarchive_change', args=[obj.archive.pk])
-            return format_html('<a href="{}">{}</a>', url, obj.archive.title)
-        return "No archive"
-    archive_link.short_description = "Archive"
-    
-    def item_link(self, obj: ArchiveItemChunk) -> str:
-        """Link to parent item."""
-        if obj.item:
-            url = reverse('admin:django_cfg_knowbase_archiveitem_change', args=[obj.item.pk])
-            return format_html('<a href="{}">{}</a>', url, obj.item.item_name)
-        return "No item"
-    item_link.short_description = "Item"
-    
-    def changelist_view(self, request, extra_context=None):
-        """Add chunk statistics to changelist."""
-        extra_context = extra_context or {}
-        
-        queryset = self.get_queryset(request)
-        stats = queryset.aggregate(
-            total_chunks=Count('id'),
-            vectorized_chunks=Count('id', filter=Q(embedding__isnull=False)),
-            total_tokens=Sum('token_count'),
-            total_characters=Sum('character_count'),
-            total_embedding_cost=Sum('embedding_cost'),
-            avg_tokens_per_chunk=Avg('token_count')
-        )
-        
-        # Type breakdown
-        type_counts = dict(
-            queryset.values_list('chunk_type').annotate(
-                count=Count('id')
-            )
-        )
-        
-        extra_context['chunk_stats'] = {
-            'total_chunks': stats['total_chunks'] or 0,
-            'vectorized_chunks': stats['vectorized_chunks'] or 0,
-            'total_tokens': stats['total_tokens'] or 0,
-            'total_characters': stats['total_characters'] or 0,
-            'total_embedding_cost': f"${(stats['total_embedding_cost'] or 0):.6f}",
-            'avg_tokens_per_chunk': f"{(stats['avg_tokens_per_chunk'] or 0):.0f}",
-            'type_counts': type_counts
-        }
-        
-        return super().changelist_view(request, extra_context)
-    
-    def content_preview(self, obj: ArchiveItemChunk) -> str:
-        """Show content preview."""
-        preview = obj.content[:300]
-        if len(obj.content) > 300:
-            preview += "..."
-        return format_html('<pre style="white-space: pre-wrap;">{}</pre>', preview)
-    content_preview.short_description = "Content Preview"
-    
-    def context_summary(self, obj: ArchiveItemChunk) -> str:
-        """Show context summary."""
-        context = obj.get_context_summary()
-        return format_html('<pre>{}</pre>', 
-                          '\n'.join(f"{k}: {v}" for k, v in context.items()))
-    context_summary.short_description = "Context Summary"
-    
-    def get_queryset(self, request):
-        """Optimize queryset with select_related."""
-        # Use all_users() to show all archive item chunks in admin, then filter by user if needed
-        queryset = ArchiveItemChunk.objects.all_users().select_related(
-            'archive', 'item', 'user'
+        config = MoneyDisplayConfig(
+            currency="USD",
+            decimal_places=6,
+            show_sign=False
         )
-        
-        # For non-superusers, filter by their own chunks
-        if not request.user.is_superuser:
-            queryset = queryset.filter(user=request.user)
-        
-        return queryset
-    
-    def save_model(self, request, obj, form, change):
-        """Automatically set user to current user when creating new archive item chunks."""
-        if not change:  # Only for new chunks
-            obj.user = request.user
-        super().save_model(request, obj, form, change)
+        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."""
+        return obj.content[:200] + "..." if len(obj.content) > 200 else obj.content
+    
+    @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.")