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

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.3.7"
+__version__ = "1.3.9"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/accounts/admin/__init__.py

@@ -1,18 +1,34 @@
 """
-Admin configuration for Accounts app.
+Accounts admin interfaces using Django Admin Utilities.
+
+Modern, clean admin interfaces with Material Icons and consistent styling.
 """
 
-from .user import CustomUserAdmin
-from .otp import OTPSecretAdmin
-from .registration_source import RegistrationSourceAdmin, UserRegistrationSourceAdmin
-from .activity import UserActivityAdmin
-from .group import GroupAdmin
+from django.contrib import admin
+
+# Import all admin classes
+from .user_admin import CustomUserAdmin
+from .activity_admin import UserActivityAdmin
+from .otp_admin import OTPSecretAdmin
+from .registration_admin import RegistrationSourceAdmin, UserRegistrationSourceAdmin
+from .group_admin import GroupAdmin
+from .twilio_admin import TwilioResponseAdmin, TwilioResponseInline
+
+# All models are registered in their respective admin files using @admin.register
+# This provides:
+# - Clean separation of concerns
+# - Material Icons integration
+# - Type-safe configurations
+# - Performance optimizations
+# - Consistent styling with django_admin module
 
 __all__ = [
     'CustomUserAdmin',
-    'OTPSecretAdmin', 
+    'UserActivityAdmin',
+    'OTPSecretAdmin',
     'RegistrationSourceAdmin',
     'UserRegistrationSourceAdmin',
-    'UserActivityAdmin',
     'GroupAdmin',
+    'TwilioResponseAdmin',
+    'TwilioResponseInline',
 ]

django_cfg/apps/accounts/admin/activity_admin.py

@@ -0,0 +1,146 @@
+"""
+User Activity admin interface using Django Admin Utilities.
+
+Enhanced activity tracking with Material Icons and optimized queries.
+"""
+
+from django.contrib import admin
+from unfold.admin import ModelAdmin
+
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    UserDisplayConfig,
+    DateTimeDisplayConfig,
+    StatusBadgeConfig,
+    Icons,
+    display
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+
+from ..models import UserActivity
+from .filters import ActivityTypeFilter
+
+
+@admin.register(UserActivity)
+class UserActivityAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Enhanced admin for UserActivity model using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['user']
+    
+    list_display = [
+        'user_display',
+        'activity_type_display',
+        'description_display',
+        'ip_address_display',
+        'created_at_display'
+    ]
+    list_display_links = ['user_display', 'activity_type_display']
+    list_filter = [ActivityTypeFilter, 'activity_type', 'created_at']
+    search_fields = ['user__username', 'user__email', 'description', 'ip_address']
+    readonly_fields = ['created_at']
+    date_hierarchy = 'created_at'
+    ordering = ['-created_at']
+    
+    fieldsets = (
+        ('Activity', {
+            'fields': ('user', 'activity_type', 'description')
+        }),
+        ('Related Object', {
+            'fields': ('object_id', 'object_type'),
+            'classes': ('collapse',),
+            'description': 'Optional reference to related model instance'
+        }),
+        ('Request Info', {
+            'fields': ('ip_address', 'user_agent'),
+            'classes': ('collapse',)
+        }),
+        ('Timestamp', {
+            'fields': ('created_at',)
+        }),
+    )
+    
+    @display(description="User")
+    def user_display(self, obj):
+        """Enhanced user display with avatar."""
+        config = UserDisplayConfig(
+            show_avatar=True,
+            avatar_size=20,
+            show_email=False
+        )
+        return self.display_user_simple(obj.user, config)
+    
+    @display(description="Activity")
+    def activity_type_display(self, obj):
+        """Activity type with appropriate icons."""
+        activity_icons = {
+            'login': Icons.LOGIN,
+            'logout': Icons.LOGOUT,
+            'otp_requested': Icons.EMAIL,
+            'otp_verified': Icons.VERIFIED,
+            'profile_updated': Icons.EDIT,
+            'registration': Icons.PERSON_ADD,
+        }
+        
+        activity_variants = {
+            'login': 'success',
+            'logout': 'info',
+            'otp_requested': 'warning',
+            'otp_verified': 'success',
+            'profile_updated': 'info',
+            'registration': 'primary',
+        }
+        
+        icon = activity_icons.get(obj.activity_type, Icons.DESCRIPTION)
+        variant = activity_variants.get(obj.activity_type, 'info')
+        
+        config = StatusBadgeConfig(
+            show_icons=True,
+            icon=icon,
+            custom_mappings={obj.get_activity_type_display(): variant}
+        )
+        
+        return StatusBadge.create(
+            text=obj.get_activity_type_display(),
+            variant=variant,
+            config=config
+        )
+    
+    @display(description="Description")
+    def description_display(self, obj):
+        """Truncated description with full text in tooltip."""
+        if len(obj.description) > 50:
+            truncated = f"{obj.description[:47]}..."
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.DESCRIPTION)
+            return StatusBadge.create(
+                text=truncated,
+                variant="secondary",
+                config=config
+            )
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.DESCRIPTION)
+        return StatusBadge.create(
+            text=obj.description,
+            variant="info",
+            config=config
+        )
+    
+    @display(description="IP Address")
+    def ip_address_display(self, obj):
+        """IP address with network icon."""
+        if not obj.ip_address:
+            return "—"
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.PUBLIC)
+        return StatusBadge.create(
+            text=obj.ip_address,
+            variant="secondary",
+            config=config
+        )
+    
+    @display(description="When")
+    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)

django_cfg/apps/accounts/admin/filters.py

@@ -1,51 +1,63 @@
 """
 Custom admin filters for Accounts app.
+
+Enhanced filters with better organization and performance.
 """
 
 from django.contrib import admin
 from django.utils import timezone
 from datetime import timedelta
+from django.db import models
+from django.db.models import Count
 
 
 class UserStatusFilter(admin.SimpleListFilter):
+    """Enhanced user status filter with clear categories."""
     title = "User Status"
     parameter_name = "user_status"
 
     def lookups(self, request, model_admin):
         return (
-            ("active", "Active"),
-            ("inactive", "Inactive"),
-            ("staff", "Staff"),
-            ("superuser", "Superuser"),
+            ("active", "✅ Active Users"),
+            ("inactive", "❌ Inactive Users"),
+            ("staff", "⚙️ Staff Members"),
+            ("superuser", "👑 Superusers"),
+            ("regular", "👤 Regular Users"),
         )
 
     def queryset(self, request, queryset):
         if self.value() == "active":
-            return queryset.filter(is_active=True, is_staff=False)
+            return queryset.filter(is_active=True, is_staff=False, is_superuser=False)
         elif self.value() == "inactive":
             return queryset.filter(is_active=False)
         elif self.value() == "staff":
-            return queryset.filter(is_staff=True)
+            return queryset.filter(is_staff=True, is_superuser=False)
         elif self.value() == "superuser":
             return queryset.filter(is_superuser=True)
+        elif self.value() == "regular":
+            return queryset.filter(is_active=True, is_staff=False, is_superuser=False)
         return queryset
 
 
 class OTPStatusFilter(admin.SimpleListFilter):
+    """Enhanced OTP status filter with time-based categories."""
     title = "OTP Status"
     parameter_name = "otp_status"
 
     def lookups(self, request, model_admin):
         return (
-            ("active", "Active"),
-            ("used", "Used"),
-            ("expired", "Expired"),
-            ("recent", "Recent (24h)"),
+            ("valid", "✅ Valid & Active"),
+            ("used", "🔒 Used"),
+            ("expired", "⏰ Expired"),
+            ("recent", "🕐 Recent (24h)"),
+            ("today", "📅 Today"),
         )
 
     def queryset(self, request, queryset):
         now = timezone.now()
-        if self.value() == "active":
+        today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        
+        if self.value() == "valid":
             return queryset.filter(is_used=False, expires_at__gt=now)
         elif self.value() == "used":
             return queryset.filter(is_used=True)
@@ -53,17 +65,21 @@ class OTPStatusFilter(admin.SimpleListFilter):
             return queryset.filter(is_used=False, expires_at__lte=now)
         elif self.value() == "recent":
             return queryset.filter(created_at__gte=now - timedelta(hours=24))
+        elif self.value() == "today":
+            return queryset.filter(created_at__gte=today_start)
         return queryset
 
 
 class RegistrationSourceStatusFilter(admin.SimpleListFilter):
-    title = "Registration Source Status"
-    parameter_name = "registration_source_status"
+    """Registration source status filter."""
+    title = "Source Status"
+    parameter_name = "source_status"
 
     def lookups(self, request, model_admin):
         return (
-            ("active", "Active"),
-            ("inactive", "Inactive"),
+            ("active", "✅ Active Sources"),
+            ("inactive", "❌ Inactive Sources"),
+            ("popular", "🔥 Popular (10+ users)"),
         )
 
     def queryset(self, request, queryset):
@@ -71,28 +87,88 @@ class RegistrationSourceStatusFilter(admin.SimpleListFilter):
             return queryset.filter(is_active=True)
         elif self.value() == "inactive":
             return queryset.filter(is_active=False)
+        elif self.value() == "popular":
+            # Sources with 10 or more users
+            return queryset.annotate(
+                user_count=Count('user_registration_sources')
+            ).filter(user_count__gte=10)
         return queryset
 
 
 class ActivityTypeFilter(admin.SimpleListFilter):
+    """Enhanced activity type filter with time-based options."""
     title = "Activity Type"
     parameter_name = "activity_type"
 
     def lookups(self, request, model_admin):
         return (
-            ("login", "Login"),
-            ("logout", "Logout"),
-            ("otp_requested", "OTP Requested"),
-            ("otp_verified", "OTP Verified"),
-            ("profile_updated", "Profile Updated"),
-            ("registration", "Registration"),
-            ("recent", "Recent (24h)"),
+            ("login", "🔐 Login"),
+            ("logout", "🚪 Logout"),
+            ("otp_requested", "📧 OTP Requested"),
+            ("otp_verified", "✅ OTP Verified"),
+            ("profile_updated", "✏️ Profile Updated"),
+            ("registration", "👤 Registration"),
+            ("recent", "🕐 Recent (24h)"),
+            ("today", "📅 Today"),
         )
 
     def queryset(self, request, queryset):
         now = timezone.now()
+        today_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        
         if self.value() == "recent":
             return queryset.filter(created_at__gte=now - timedelta(hours=24))
+        elif self.value() == "today":
+            return queryset.filter(created_at__gte=today_start)
         elif self.value():
             return queryset.filter(activity_type=self.value())
         return queryset
+
+
+class TwilioResponseStatusFilter(admin.SimpleListFilter):
+    """Twilio response status filter."""
+    title = "Response Status"
+    parameter_name = "twilio_status"
+
+    def lookups(self, request, model_admin):
+        return (
+            ("success", "✅ Successful"),
+            ("error", "❌ With Errors"),
+            ("pending", "⏳ Pending"),
+            ("recent", "🕐 Recent (24h)"),
+        )
+
+    def queryset(self, request, queryset):
+        now = timezone.now()
+        
+        if self.value() == "success":
+            return queryset.filter(error_code__isnull=True, error_message__isnull=True)
+        elif self.value() == "error":
+            return queryset.filter(
+                models.Q(error_code__isnull=False) | 
+                models.Q(error_message__isnull=False)
+            )
+        elif self.value() == "pending":
+            return queryset.filter(status__in=['queued', 'sending', 'sent'])
+        elif self.value() == "recent":
+            return queryset.filter(created_at__gte=now - timedelta(hours=24))
+        return queryset
+
+
+class TwilioResponseTypeFilter(admin.SimpleListFilter):
+    """Twilio response type filter."""
+    title = "Service Type"
+    parameter_name = "twilio_service"
+
+    def lookups(self, request, model_admin):
+        return (
+            ("sms", "📱 SMS"),
+            ("voice", "📞 Voice"),
+            ("verify", "🔐 Verify"),
+            ("email", "📧 Email"),
+        )
+
+    def queryset(self, request, queryset):
+        if self.value():
+            return queryset.filter(service_type=self.value())
+        return queryset

django_cfg/apps/accounts/admin/group_admin.py

@@ -0,0 +1,86 @@
+"""
+Group admin interface using Django Admin Utilities.
+
+Enhanced group management with Material Icons and user counts.
+"""
+
+from django.contrib import admin
+from django.contrib.auth.models import Group
+from unfold.admin import ModelAdmin
+
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    StatusBadgeConfig,
+    Icons,
+    display
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+
+
+# Unregister the default Group admin
+admin.site.unregister(Group)
+
+
+@admin.register(Group)
+class GroupAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Enhanced admin for Group model using Django Admin Utilities."""
+    
+    list_display = [
+        'name_display',
+        'users_count_display',
+        'permissions_count_display'
+    ]
+    list_display_links = ['name_display']
+    search_fields = ['name']
+    filter_horizontal = ['permissions']
+    ordering = ['name']
+    
+    fieldsets = (
+        ('Group Details', {
+            'fields': ('name',)
+        }),
+        ('Permissions', {
+            'fields': ('permissions',),
+            'classes': ('collapse',)
+        }),
+    )
+    
+    @display(description="Group Name")
+    def name_display(self, obj):
+        """Group name display with group icon."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.GROUP)
+        return StatusBadge.create(
+            text=obj.name,
+            variant="primary",
+            config=config
+        )
+    
+    @display(description="Users")
+    def users_count_display(self, obj):
+        """Count of users in this group."""
+        count = obj.user_set.count()
+        if count == 0:
+            return "—"
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.PEOPLE)
+        return StatusBadge.create(
+            text=f"{count} user{'s' if count != 1 else ''}",
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Permissions")
+    def permissions_count_display(self, obj):
+        """Count of permissions in this group."""
+        count = obj.permissions.count()
+        if count == 0:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.SECURITY)
+            return StatusBadge.create(text="No permissions", variant="secondary", config=config)
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.SECURITY)
+        return StatusBadge.create(
+            text=f"{count} permission{'s' if count != 1 else ''}",
+            variant="warning",
+            config=config
+        )

django_cfg/apps/accounts/admin/inlines.py

@@ -1,16 +1,24 @@
 """
-Inline admin classes for Accounts app.
+Inline admin classes for Accounts app using Django Admin Utilities.
+
+Enhanced inline classes with better organization and conditional loading.
 """
 
 from unfold.admin import TabularInline
-from ..models import UserRegistrationSource, UserActivity
 
+from django_cfg.modules.base import BaseCfgModule    
+from django_cfg.apps.support.models import Ticket
+from ..models import UserRegistrationSource, UserActivity
 
 class UserRegistrationSourceInline(TabularInline):
+    """Enhanced inline for user registration sources."""
     model = UserRegistrationSource
     extra = 0
     readonly_fields = ["registration_date"]
     fields = ["source", "first_registration", "registration_date"]
+    ordering = ["-registration_date"]
+    verbose_name = "Registration Source"
+    verbose_name_plural = "Registration Sources"
 
     def has_add_permission(self, request, obj=None):
         return True
@@ -20,10 +28,14 @@ class UserRegistrationSourceInline(TabularInline):
 
 
 class RegistrationSourceInline(TabularInline):
+    """Enhanced inline for registration source users."""
     model = UserRegistrationSource
     extra = 0
     readonly_fields = ["registration_date"]
     fields = ["user", "first_registration", "registration_date"]
+    ordering = ["-registration_date"]
+    verbose_name = "User Registration"
+    verbose_name_plural = "User Registrations"
 
     def has_add_permission(self, request, obj=None):
         return True
@@ -33,11 +45,19 @@ class RegistrationSourceInline(TabularInline):
 
 
 class UserActivityInline(TabularInline):
+    """Enhanced inline for user activities."""
     model = UserActivity
     extra = 0
-    readonly_fields = ["created_at"]
+    readonly_fields = ["created_at", "activity_type", "description"]
     fields = ["activity_type", "description", "ip_address", "created_at"]
     ordering = ["-created_at"]
+    verbose_name = "Activity"
+    verbose_name_plural = "Recent Activities"
+    
+    # Show only recent activities to avoid performance issues
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        return qs[:10]  # Limit to 10 most recent activities
 
     def has_add_permission(self, request, obj=None):
         return False
@@ -47,13 +67,12 @@ class UserActivityInline(TabularInline):
 
 
 class UserEmailLogInline(TabularInline):
-    """Inline for viewing user's email logs."""
+    """Enhanced inline for viewing user's email logs."""
     
     def __init__(self, *args, **kwargs):
         # Check if newsletter app is available and enabled
         self.model = None
         try:
-            from django_cfg.modules.base import BaseCfgModule
             base_module = BaseCfgModule()
             
             # Only import if newsletter is enabled
@@ -73,7 +92,14 @@ class UserEmailLogInline(TabularInline):
     fields = ["newsletter", "campaign", "subject", "status", "created_at", "sent_at"]
     ordering = ["-created_at"]
     verbose_name = "Email Log"
-    verbose_name_plural = "Email Logs"
+    verbose_name_plural = "Email History"
+    
+    # Show only recent emails to avoid performance issues
+    def get_queryset(self, request):
+        if not self.model:
+            return self.model.objects.none()
+        qs = super().get_queryset(request)
+        return qs[:15]  # Limit to 15 most recent emails
     
     def has_add_permission(self, request, obj=None):
         return False
@@ -86,7 +112,6 @@ class UserEmailLogInline(TabularInline):
         if not self.model:
             return False
         try:
-            from django_cfg.modules.base import BaseCfgModule
             base_module = BaseCfgModule()
             return base_module.is_newsletter_enabled()
         except Exception:
@@ -94,18 +119,16 @@ class UserEmailLogInline(TabularInline):
 
 
 class UserSupportTicketsInline(TabularInline):
-    """Inline for viewing user's support tickets."""
+    """Enhanced inline for viewing user's support tickets."""
     
     def __init__(self, *args, **kwargs):
         # Check if support app is available and enabled
         self.model = None
         try:
-            from django_cfg.modules.base import BaseCfgModule
             base_module = BaseCfgModule()
             
             # Only import if support is enabled
             if base_module.is_support_enabled():
-                from django_cfg.apps.support.models import Ticket
                 self.model = Ticket
         except (ImportError, Exception):
             # Support app not available or not enabled
@@ -116,12 +139,19 @@ class UserSupportTicketsInline(TabularInline):
             super().__init__(*args, **kwargs)
     
     extra = 0
-    readonly_fields = ["uuid", "subject", "status", "created_at"]
-    fields = ["uuid", "subject", "status", "created_at"]
+    readonly_fields = ["uuid", "subject", "status", "priority", "created_at"]
+    fields = ["uuid", "subject", "status", "priority", "created_at"]
     ordering = ["-created_at"]
     verbose_name = "Support Ticket"
     verbose_name_plural = "Support Tickets"
     
+    # Show only recent tickets to avoid performance issues
+    def get_queryset(self, request):
+        if not self.model:
+            return self.model.objects.none()
+        qs = super().get_queryset(request)
+        return qs[:10]  # Limit to 10 most recent tickets
+    
     def has_add_permission(self, request, obj=None):
         return False
     
@@ -133,7 +163,6 @@ class UserSupportTicketsInline(TabularInline):
         if not self.model:
             return False
         try:
-            from django_cfg.modules.base import BaseCfgModule
             base_module = BaseCfgModule()
             return base_module.is_support_enabled()
         except Exception: