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

django_cfg/apps/accounts/admin/otp_admin.py

@@ -0,0 +1,115 @@
+"""
+OTP admin interface using Django Admin Utilities.
+
+Enhanced OTP management with status indicators and time displays.
+"""
+
+from django.contrib import admin
+from unfold.admin import ModelAdmin
+
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    DateTimeDisplayConfig,
+    StatusBadgeConfig,
+    Icons,
+    display
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+
+from ..models import OTPSecret
+from .filters import OTPStatusFilter
+
+
+@admin.register(OTPSecret)
+class OTPSecretAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Enhanced OTP admin using Django Admin Utilities."""
+    
+    list_display = [
+        'email_display',
+        'secret_display',
+        'status_display',
+        'created_display',
+        'expires_display'
+    ]
+    list_display_links = ['email_display', 'secret_display']
+    list_filter = [OTPStatusFilter, 'is_used', 'created_at']
+    search_fields = ['email', 'secret']
+    readonly_fields = ['created_at', 'expires_at']
+    ordering = ['-created_at']
+
+    fieldsets = (
+        (
+            "OTP Details",
+            {
+                "fields": ("email", "secret", "is_used"),
+            },
+        ),
+        (
+            "Timestamps",
+            {
+                "fields": ("created_at", "expires_at"),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+    
+    @display(description="Email")
+    def email_display(self, obj):
+        """Email display with email icon."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.EMAIL)
+        return StatusBadge.create(
+            text=obj.email,
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Secret")
+    def secret_display(self, obj):
+        """Secret display with key icon."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.KEY)
+        return StatusBadge.create(
+            text=obj.secret,
+            variant="secondary",
+            config=config
+        )
+    
+    @display(description="Status", label=True)
+    def status_display(self, obj):
+        """Enhanced OTP status with appropriate icons and colors."""
+        if obj.is_used:
+            status = "Used"
+            icon = Icons.CHECK_CIRCLE
+            variant = "secondary"
+        elif obj.is_valid:
+            status = "Valid"
+            icon = Icons.VERIFIED
+            variant = "success"
+        else:
+            status = "Expired"
+            icon = Icons.SCHEDULE
+            variant = "warning"
+        
+        config = StatusBadgeConfig(
+            show_icons=True,
+            icon=icon,
+            custom_mappings={status: variant}
+        )
+        
+        return self.display_status_auto(
+            type('obj', (), {'status': status})(),
+            'status',
+            config
+        )
+    
+    @display(description="Created")
+    def created_display(self, obj):
+        """Created time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'created_at', config)
+    
+    @display(description="Expires")
+    def expires_display(self, obj):
+        """Expires time with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'expires_at', config)

django_cfg/apps/accounts/admin/registration_admin.py

@@ -0,0 +1,173 @@
+"""
+Registration admin interfaces using Django Admin Utilities.
+
+Enhanced registration source management 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 RegistrationSource, UserRegistrationSource
+
+
+@admin.register(RegistrationSource)
+class RegistrationSourceAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Enhanced admin for RegistrationSource model using Django Admin Utilities."""
+    
+    list_display = [
+        'name_display',
+        'description_display',
+        'is_active_display',
+        'users_count_display',
+        'created_at_display'
+    ]
+    list_display_links = ['name_display']
+    list_filter = ['is_active', 'created_at']
+    search_fields = ['name', 'description']
+    readonly_fields = ['created_at', 'updated_at']
+    ordering = ['name']
+    
+    fieldsets = (
+        ('Source Details', {
+            'fields': ('name', 'description', 'is_active')
+        }),
+        ('Timestamps', {
+            'fields': ('created_at', 'updated_at'),
+            'classes': ('collapse',)
+        }),
+    )
+    
+    @display(description="Name")
+    def name_display(self, obj):
+        """Name display with source icon."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.SOURCE)
+        return StatusBadge.create(
+            text=obj.name,
+            variant="primary",
+            config=config
+        )
+    
+    @display(description="Description")
+    def description_display(self, obj):
+        """Description display with info icon."""
+        if not obj.description:
+            return "—"
+        
+        # Truncate long descriptions
+        description = obj.description
+        if len(description) > 50:
+            description = f"{description[:47]}..."
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.INFO)
+        return StatusBadge.create(
+            text=description,
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Status", label=True)
+    def is_active_display(self, obj):
+        """Active status display."""
+        status = "Active" if obj.is_active else "Inactive"
+        icon = Icons.CHECK_CIRCLE if obj.is_active else Icons.CANCEL
+        variant = "success" if obj.is_active else "secondary"
+        
+        config = StatusBadgeConfig(
+            show_icons=True,
+            icon=icon,
+            custom_mappings={status: variant}
+        )
+        
+        return self.display_status_auto(
+            type('obj', (), {'status': status})(),
+            'status',
+            config
+        )
+    
+    @display(description="Users")
+    def users_count_display(self, obj):
+        """Count of users from this source."""
+        count = obj.user_registration_sources.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="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)
+
+
+@admin.register(UserRegistrationSource)
+class UserRegistrationSourceAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin):
+    """Enhanced admin for UserRegistrationSource model using Django Admin Utilities."""
+    
+    # Performance optimization
+    select_related_fields = ['user', 'source']
+    
+    list_display = [
+        'user_display',
+        'source_display',
+        'registration_date_display'
+    ]
+    list_display_links = ['user_display', 'source_display']
+    list_filter = ['source', 'registration_date']
+    search_fields = ['user__email', 'user__first_name', 'user__last_name', 'source__name']
+    readonly_fields = ['registration_date']
+    date_hierarchy = 'registration_date'
+    ordering = ['-registration_date']
+    
+    fieldsets = (
+        ('Registration Details', {
+            'fields': ('user', 'source', 'first_registration')
+        }),
+        ('Timestamp', {
+            'fields': ('registration_date',)
+        }),
+    )
+    
+    @display(description="User")
+    def user_display(self, obj):
+        """User display with avatar."""
+        config = UserDisplayConfig(
+            show_avatar=True,
+            avatar_size=20,
+            show_email=True
+        )
+        return self.display_user_simple(obj.user, config)
+    
+    @display(description="Source")
+    def source_display(self, obj):
+        """Source display with source icon."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.SOURCE)
+        variant = "success" if obj.source.is_active else "secondary"
+        
+        return StatusBadge.create(
+            text=obj.source.name,
+            variant=variant,
+            config=config
+        )
+    
+    @display(description="Registered")
+    def registration_date_display(self, obj):
+        """Registration date with relative display."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'registration_date', config)

django_cfg/apps/accounts/admin/resources.py

@@ -1,16 +1,20 @@
 """
 Import/Export resources for Accounts app.
+
+Enhanced resources with better data validation and export optimization.
 """
 
 from import_export import resources, fields
 from import_export.widgets import ForeignKeyWidget, DateTimeWidget, BooleanWidget, ManyToManyWidget
 from django.contrib.auth.models import Group
+from django.utils import timezone
+from datetime import timedelta
 
 from ..models import CustomUser, UserActivity, RegistrationSource, TwilioResponse
 
 
 class CustomUserResource(resources.ModelResource):
-    """Resource for importing/exporting users."""
+    """Enhanced resource for importing/exporting users."""
     
     # Custom fields for better export/import
     full_name = fields.Field(
@@ -54,6 +58,17 @@ class CustomUserResource(resources.ModelResource):
         attribute='phone_verified',
         widget=BooleanWidget()
     )
+    
+    # Additional computed fields
+    registration_sources = fields.Field(
+        column_name='registration_sources',
+        readonly=True
+    )
+    
+    activities_count = fields.Field(
+        column_name='activities_count',
+        readonly=True
+    )
 
     class Meta:
         model = CustomUser
@@ -71,6 +86,8 @@ class CustomUserResource(resources.ModelResource):
             'is_staff',
             'is_superuser',
             'groups',
+            'registration_sources',
+            'activities_count',
             'last_login',
             'date_joined',
         )
@@ -79,11 +96,28 @@ class CustomUserResource(resources.ModelResource):
         skip_unchanged = True
         report_skipped = True
         
+    def dehydrate_registration_sources(self, user):
+        """Get registration sources for export."""
+        sources = user.user_registration_sources.select_related('source').all()
+        return '|'.join([source.source.name for source in sources])
+    
+    def dehydrate_activities_count(self, user):
+        """Get activities count for export."""
+        return user.activities.count()
+        
     def before_import_row(self, row, **kwargs):
-        """Process row before import."""
-        # Ensure email is lowercase
+        """Process row before import with enhanced validation."""
+        # Ensure email is lowercase and valid
         if 'email' in row:
-            row['email'] = row['email'].lower().strip()
+            email = row['email'].lower().strip()
+            if '@' not in email:
+                raise ValueError(f"Invalid email format: {email}")
+            row['email'] = email
+        
+        # Clean phone number
+        if 'phone' in row and row['phone']:
+            phone = ''.join(filter(str.isdigit, str(row['phone'])))
+            row['phone'] = phone if phone else None
             
     def skip_row(self, instance, original, row, import_validation_errors=None):
         """Skip rows with validation errors."""
@@ -93,7 +127,7 @@ class CustomUserResource(resources.ModelResource):
 
 
 class UserActivityResource(resources.ModelResource):
-    """Resource for exporting user activity (export only)."""
+    """Enhanced resource for exporting user activity (export only)."""
     
     user_email = fields.Field(
         column_name='user_email',
@@ -118,6 +152,12 @@ class UserActivityResource(resources.ModelResource):
         attribute='created_at',
         widget=DateTimeWidget(format='%Y-%m-%d %H:%M:%S')
     )
+    
+    # Additional context fields
+    user_agent_browser = fields.Field(
+        column_name='user_agent_browser',
+        readonly=True
+    )
 
     class Meta:
         model = UserActivity
@@ -130,12 +170,30 @@ class UserActivityResource(resources.ModelResource):
             'description',
             'ip_address',
             'user_agent',
+            'user_agent_browser',
             'object_id',
             'object_type',
             'created_at',
         )
         export_order = fields
         # No import - this is export only
+    
+    def dehydrate_user_agent_browser(self, activity):
+        """Extract browser info from user agent."""
+        if not activity.user_agent:
+            return "Unknown"
+        
+        user_agent = activity.user_agent.lower()
+        if 'chrome' in user_agent:
+            return "Chrome"
+        elif 'firefox' in user_agent:
+            return "Firefox"
+        elif 'safari' in user_agent:
+            return "Safari"
+        elif 'edge' in user_agent:
+            return "Edge"
+        else:
+            return "Other"
         
     def get_queryset(self):
         """Optimize queryset for export."""
@@ -143,7 +201,7 @@ class UserActivityResource(resources.ModelResource):
 
 
 class RegistrationSourceResource(resources.ModelResource):
-    """Resource for importing/exporting registration sources."""
+    """Enhanced resource for importing/exporting registration sources."""
     
     is_active = fields.Field(
         column_name='is_active',
@@ -167,45 +225,56 @@ class RegistrationSourceResource(resources.ModelResource):
         column_name='users_count',
         readonly=True
     )
+    
+    recent_registrations = fields.Field(
+        column_name='recent_registrations_7d',
+        readonly=True
+    )
 
     class Meta:
         model = RegistrationSource
         fields = (
             'id',
-            'url',
             'name',
             'description',
             'is_active',
             'users_count',
+            'recent_registrations',
             'created_at',
             'updated_at',
         )
         export_order = fields
-        import_id_fields = ('url',)  # Use URL as unique identifier
+        import_id_fields = ('name',)  # Use name as unique identifier
         skip_unchanged = True
         report_skipped = True
         
     def dehydrate_users_count(self, registration_source):
-        """Calculate users count for export."""
+        """Calculate total users count for export."""
         return registration_source.user_registration_sources.count()
+    
+    def dehydrate_recent_registrations(self, registration_source):
+        """Calculate recent registrations count."""
+        
+        week_ago = timezone.now() - timedelta(days=7)
+        return registration_source.user_registration_sources.filter(
+            created_at__gte=week_ago
+        ).count()
         
     def before_import_row(self, row, **kwargs):
-        """Process row before import."""
-        # Ensure URL is properly formatted
-        if 'url' in row and row['url']:
-            url = row['url'].strip()
-            if not url.startswith(('http://', 'https://')):
-                row['url'] = f'https://{url}'
-            else:
-                row['url'] = url
+        """Process row before import with validation."""
+        # Clean and validate name
+        if 'name' in row and row['name']:
+            row['name'] = row['name'].strip()
+            if len(row['name']) < 2:
+                raise ValueError(f"Registration source name too short: {row['name']}")
 
 
 class TwilioResponseResource(resources.ModelResource):
-    """Resource for exporting Twilio responses (export only)."""
+    """Enhanced resource for exporting Twilio responses (export only)."""
     
     otp_recipient = fields.Field(
         column_name='otp_recipient',
-        attribute='otp_secret__recipient',
+        attribute='otp_secret__email',
         readonly=True
     )
     
@@ -240,6 +309,17 @@ class TwilioResponseResource(resources.ModelResource):
         widget=BooleanWidget(),
         readonly=True
     )
+    
+    # Additional computed fields
+    response_time_ms = fields.Field(
+        column_name='response_time_ms',
+        readonly=True
+    )
+    
+    masked_recipient = fields.Field(
+        column_name='masked_recipient',
+        readonly=True
+    )
 
     class Meta:
         model = TwilioResponse
@@ -251,12 +331,14 @@ class TwilioResponseResource(resources.ModelResource):
             'message_sid',
             'verification_sid',
             'to_number',
+            'masked_recipient',
             'from_number',
             'otp_recipient',
             'error_code',
             'error_message',
             'price',
             'price_unit',
+            'response_time_ms',
             'has_error',
             'is_successful',
             'created_at',
@@ -265,6 +347,28 @@ class TwilioResponseResource(resources.ModelResource):
         )
         export_order = fields
         # No import - this is export only
+    
+    def dehydrate_response_time_ms(self, twilio_response):
+        """Calculate response time if available."""
+        if twilio_response.twilio_created_at and twilio_response.created_at:
+            delta = twilio_response.twilio_created_at - twilio_response.created_at
+            return int(delta.total_seconds() * 1000)
+        return None
+    
+    def dehydrate_masked_recipient(self, twilio_response):
+        """Mask recipient for privacy."""
+        if not twilio_response.to_number:
+            return "—"
+        
+        recipient = twilio_response.to_number
+        if '@' in recipient:
+            # Email masking
+            local, domain = recipient.split('@', 1)
+            masked_local = local[:2] + '*' * (len(local) - 2) if len(local) > 2 else local
+            return f"{masked_local}@{domain}"
+        else:
+            # Phone masking
+            return f"***{recipient[-4:]}" if len(recipient) > 4 else "***"
         
     def get_queryset(self):
         """Optimize queryset for export."""