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

django_cfg/apps/accounts/admin/twilio_admin.py

@@ -0,0 +1,327 @@
+"""
+Twilio Response admin interface using Django Admin Utilities.
+
+Enhanced Twilio response management with Material Icons and optimized queries.
+"""
+
+from django.contrib import admin
+from django.utils.html import format_html
+from unfold.admin import ModelAdmin
+from django_cfg import ExportMixin, ExportForm
+
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    MoneyDisplayConfig,
+    DateTimeDisplayConfig,
+    StatusBadgeConfig,
+    Icons,
+    display
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+
+from ..models import TwilioResponse
+from .filters import TwilioResponseStatusFilter, TwilioResponseTypeFilter
+from .resources import TwilioResponseResource
+
+
+class TwilioResponseInline(admin.TabularInline):
+    """Inline for showing Twilio responses in related models."""
+    model = TwilioResponse
+    extra = 0
+    readonly_fields = ['created_at', 'status', 'message_sid', 'error_code']
+    fields = ['response_type', 'service_type', 'status', 'message_sid', 'error_code', 'created_at']
+    
+    def has_add_permission(self, request, obj=None):
+        return False
+
+
+
+@admin.register(TwilioResponse)
+class TwilioResponseAdmin(OptimizedModelAdmin, DisplayMixin, ModelAdmin, ExportMixin):
+    """Enhanced Twilio Response admin using Django Admin Utilities."""
+    
+    # Export configuration
+    resource_class = TwilioResponseResource
+    export_form_class = ExportForm
+    
+    # Performance optimization
+    select_related_fields = ['otp_secret']
+    
+    list_display = [
+        'identifier_display',
+        'service_type_display',
+        'response_type_display',
+        'status_display',
+        'recipient_display',
+        'price_display',
+        'created_display',
+        'error_status_display'
+    ]
+    list_display_links = ['identifier_display']
+    list_filter = [
+        TwilioResponseStatusFilter,
+        TwilioResponseTypeFilter,
+        'service_type',
+        'response_type',
+        'created_at',
+    ]
+    search_fields = [
+        'message_sid',
+        'verification_sid',
+        'to_number',
+        'error_message',
+        'otp_secret__recipient'
+    ]
+    readonly_fields = [
+        'created_at',
+        'updated_at',
+        'twilio_created_at',
+        'response_data_display',
+        'request_data_display'
+    ]
+    ordering = ['-created_at']
+    
+    fieldsets = (
+        (
+            'Basic Information',
+            {
+                'fields': (
+                    'response_type',
+                    'service_type',
+                    'status',
+                    'otp_secret'
+                ),
+            },
+        ),
+        (
+            'Twilio Identifiers',
+            {
+                'fields': (
+                    'message_sid',
+                    'verification_sid',
+                ),
+            },
+        ),
+        (
+            'Recipients',
+            {
+                'fields': (
+                    'to_number',
+                    'from_number',
+                ),
+            },
+        ),
+        (
+            'Error Information',
+            {
+                'fields': (
+                    'error_code',
+                    'error_message',
+                ),
+                'classes': ('collapse',),
+            },
+        ),
+        (
+            'Pricing',
+            {
+                'fields': (
+                    'price',
+                    'price_unit',
+                ),
+                'classes': ('collapse',),
+            },
+        ),
+        (
+            'Request/Response Data',
+            {
+                'fields': (
+                    'request_data_display',
+                    'response_data_display',
+                ),
+                'classes': ('collapse',),
+            },
+        ),
+        (
+            'Timestamps',
+            {
+                'fields': (
+                    'created_at',
+                    'updated_at',
+                    'twilio_created_at',
+                ),
+                'classes': ('collapse',),
+            },
+        ),
+    )
+    
+    @display(description="Identifier")
+    def identifier_display(self, obj):
+        """Main identifier display with appropriate icon."""
+        identifier = obj.message_sid or obj.verification_sid
+        if not identifier:
+            return "—"
+        
+        # Truncate long identifiers
+        if len(identifier) > 20:
+            identifier = f"{identifier[:17]}..."
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.FINGERPRINT)
+        return StatusBadge.create(
+            text=identifier,
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Service")
+    def service_type_display(self, obj):
+        """Service type display with appropriate icon."""
+        service_icons = {
+            'sms': Icons.SMS,
+            'voice': Icons.PHONE,
+            'verify': Icons.VERIFIED,
+            'email': Icons.EMAIL,
+        }
+        
+        icon = service_icons.get(obj.service_type, Icons.CLOUD)
+        
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=obj.get_service_type_display(),
+            variant="primary",
+            config=config
+        )
+    
+    @display(description="Type")
+    def response_type_display(self, obj):
+        """Response type display with appropriate icon."""
+        type_icons = {
+            'send': Icons.SEND,
+            'verify': Icons.VERIFIED,
+            'check': Icons.CHECK_CIRCLE,
+        }
+        
+        icon = type_icons.get(obj.response_type, Icons.DESCRIPTION)
+        
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=obj.get_response_type_display(),
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Status", label=True)
+    def status_display(self, obj):
+        """Enhanced status display with appropriate colors and icons."""
+        if obj.has_error:
+            status = obj.status or 'Error'
+            icon = Icons.ERROR
+            variant = "danger"
+        elif obj.is_successful:
+            status = obj.status or 'Success'
+            icon = Icons.CHECK_CIRCLE
+            variant = "success"
+        else:
+            status = obj.status or 'Pending'
+            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="Recipient")
+    def recipient_display(self, obj):
+        """Recipient display with privacy masking."""
+        if not obj.to_number:
+            return "—"
+        
+        # Mask phone numbers and emails for privacy
+        recipient = obj.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
+            masked_recipient = f"{masked_local}@{domain}"
+            icon = Icons.EMAIL
+        else:
+            # Phone masking
+            masked_recipient = f"***{recipient[-4:]}" if len(recipient) > 4 else "***"
+            icon = Icons.PHONE
+        
+        config = StatusBadgeConfig(show_icons=True, icon=icon)
+        return StatusBadge.create(
+            text=masked_recipient,
+            variant="secondary",
+            config=config
+        )
+    
+    @display(description="Price")
+    def price_display(self, obj):
+        """Price display with currency formatting."""
+        if not obj.price or not obj.price_unit:
+            return "—"
+        
+        config = MoneyDisplayConfig(
+            currency=obj.price_unit.upper(),
+            decimal_places=4,
+            show_sign=False
+        )
+        
+        return self.display_money_amount(
+            type('obj', (), {'price': obj.price})(),
+            'price',
+            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="Error")
+    def error_status_display(self, obj):
+        """Error status indicator."""
+        if obj.has_error:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.ERROR)
+            return StatusBadge.create(text="Error", variant="danger", config=config)
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.CHECK_CIRCLE)
+        return StatusBadge.create(text="OK", variant="success", config=config)
+    
+    def request_data_display(self, obj):
+        """Display formatted request data."""
+        if not obj.request_data:
+            return "—"
+        
+        import json
+        try:
+            formatted = json.dumps(obj.request_data, indent=2, ensure_ascii=False)
+            return format_html('<pre style="font-size: 12px; max-height: 300px; overflow-y: auto;">{}</pre>', formatted)
+        except (TypeError, ValueError):
+            return str(obj.request_data)
+    
+    request_data_display.short_description = 'Request Data'
+    
+    def response_data_display(self, obj):
+        """Display formatted response data."""
+        if not obj.response_data:
+            return "—"
+        
+        import json
+        try:
+            formatted = json.dumps(obj.response_data, indent=2, ensure_ascii=False)
+            return format_html('<pre style="font-size: 12px; max-height: 300px; overflow-y: auto;">{}</pre>', formatted)
+        except (TypeError, ValueError):
+            return str(obj.response_data)
+    
+    response_data_display.short_description = 'Response Data'

django_cfg/apps/accounts/admin/user_admin.py

@@ -0,0 +1,362 @@
+"""
+User admin interface using Django Admin Utilities.
+
+Enhanced user management with Material Icons, status badges, and optimized queries.
+"""
+
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from django.shortcuts import redirect
+from django.urls import reverse
+from unfold.admin import ModelAdmin
+from unfold.forms import AdminPasswordChangeForm, UserChangeForm, UserCreationForm
+from django_cfg import ImportExportModelAdmin
+
+from django_cfg.modules.base import BaseCfgModule
+from django_cfg.modules.django_admin import (
+    OptimizedModelAdmin,
+    DisplayMixin,
+    StandaloneActionsMixin,
+    standalone_action,
+    UserDisplayConfig,
+    DateTimeDisplayConfig,
+    StatusBadgeConfig,
+    Icons,
+    ActionVariant,
+    display,
+    action
+)
+from django_cfg.modules.django_admin.utils.badges import StatusBadge
+
+from ..models import CustomUser
+from .filters import UserStatusFilter
+from .inlines import UserRegistrationSourceInline, UserActivityInline, UserEmailLogInline, UserSupportTicketsInline
+from .resources import CustomUserResource
+
+
+@admin.register(CustomUser)
+class CustomUserAdmin(BaseUserAdmin, OptimizedModelAdmin, DisplayMixin, StandaloneActionsMixin, ModelAdmin, ImportExportModelAdmin):
+    """Enhanced user admin using Django Admin Utilities."""
+    
+    # Import/Export configuration
+    resource_class = CustomUserResource
+    
+    # Forms loaded from unfold.forms
+    form = UserChangeForm
+    add_form = UserCreationForm
+    change_password_form = AdminPasswordChangeForm
+    
+    # Performance optimization
+    select_related_fields = []
+    prefetch_related_fields = ['groups', 'user_permissions']
+    
+    list_display = [
+        'avatar_display',
+        'email_display',
+        'full_name_display',
+        'status_display',
+        'sources_count_display',
+        'activity_count_display',
+        'emails_count_display',
+        'tickets_count_display',
+        'last_login_display',
+        'date_joined_display',
+    ]
+    list_display_links = ['avatar_display', 'email_display', 'full_name_display']
+    search_fields = ['email', 'first_name', 'last_name']
+    list_filter = [UserStatusFilter, 'is_staff', 'is_active', 'date_joined']
+    ordering = ['-date_joined']
+    readonly_fields = ['date_joined', 'last_login']
+    
+    # Register standalone actions
+    actions_list = ['view_user_emails', 'view_user_tickets', 'export_user_data']
+    
+    fieldsets = (
+        (
+            "Personal Information",
+            {
+                "fields": ("email", "first_name", "last_name", "avatar"),
+            },
+        ),
+        (
+            "Contact Information",
+            {
+                "fields": ("company", "phone", "position"),
+            },
+        ),
+        (
+            "Authentication",
+            {
+                "fields": ("password",),
+                "classes": ("collapse",),
+            },
+        ),
+        (
+            "Permissions & Status",
+            {
+                "fields": (
+                    ("is_active", "is_staff", "is_superuser"),
+                    ("groups",),
+                    ("user_permissions",),
+                ),
+            },
+        ),
+        (
+            "Important Dates",
+            {
+                "fields": ("last_login", "date_joined"),
+                "classes": ("collapse",),
+            },
+        ),
+    )
+
+    add_fieldsets = (
+        (
+            None,
+            {
+                "classes": ("wide",),
+                "fields": ("email", "password1", "password2"),
+            },
+        ),
+    )
+    
+    def get_inlines(self, request, obj):
+        """Get inlines based on enabled apps."""
+        inlines = [UserRegistrationSourceInline, UserActivityInline]
+        
+        # Add email log inline if newsletter app is enabled
+        try:
+            base_module = BaseCfgModule()
+            if base_module.is_newsletter_enabled():
+                inlines.append(UserEmailLogInline)
+            if base_module.is_support_enabled():
+                inlines.append(UserSupportTicketsInline)
+        except Exception:
+            pass
+            
+        return inlines
+    
+    @display(description="Avatar")
+    def avatar_display(self, obj):
+        """Enhanced avatar display with fallback initials."""
+        config = UserDisplayConfig(
+            show_avatar=True,
+            avatar_size=32
+        )
+        return self.display_user_avatar(obj, config)
+    
+    @display(description="Email")
+    def email_display(self, obj):
+        """Email display with user icon."""
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.EMAIL)
+        return StatusBadge.create(
+            text=obj.email,
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Full Name")
+    def full_name_display(self, obj):
+        """Full name display."""
+        full_name = obj.__class__.objects.get_full_name(obj)
+        if not full_name:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.PERSON)
+            return StatusBadge.create(text="No name", variant="secondary", config=config)
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.PERSON)
+        return StatusBadge.create(text=full_name, variant="primary", config=config)
+    
+    @display(description="Status", label=True)
+    def status_display(self, obj):
+        """Enhanced status display with appropriate icons and colors."""
+        if obj.is_superuser:
+            status = "Superuser"
+            icon = Icons.ADMIN_PANEL_SETTINGS
+            variant = "danger"
+        elif obj.is_staff:
+            status = "Staff"
+            icon = Icons.SETTINGS
+            variant = "warning"
+        elif obj.is_active:
+            status = "Active"
+            icon = Icons.CHECK_CIRCLE
+            variant = "success"
+        else:
+            status = "Inactive"
+            icon = Icons.CANCEL
+            variant = "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="Sources")
+    def sources_count_display(self, obj):
+        """Show count of registration sources for user."""
+        count = obj.user_registration_sources.count()
+        if count == 0:
+            return "—"
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.SOURCE)
+        return StatusBadge.create(
+            text=f"{count} source{'s' if count != 1 else ''}",
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Activities")
+    def activity_count_display(self, obj):
+        """Show count of user activities."""
+        count = obj.activities.count()
+        if count == 0:
+            return "—"
+        
+        config = StatusBadgeConfig(show_icons=True, icon=Icons.HISTORY)
+        return StatusBadge.create(
+            text=f"{count} activit{'ies' if count != 1 else 'y'}",
+            variant="info",
+            config=config
+        )
+    
+    @display(description="Emails")
+    def emails_count_display(self, obj):
+        """Show count of emails sent to user (if newsletter app is enabled)."""
+        try:
+            base_module = BaseCfgModule()
+            
+            if not base_module.is_newsletter_enabled():
+                return "—"
+            
+            from django_cfg.apps.newsletter.models import EmailLog
+            count = EmailLog.objects.filter(user=obj).count()
+            if count == 0:
+                return "—"
+            
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.EMAIL)
+            return StatusBadge.create(
+                text=f"{count} email{'s' if count != 1 else ''}",
+                variant="success",
+                config=config
+            )
+        except (ImportError, Exception):
+            return "—"
+    
+    @display(description="Tickets")
+    def tickets_count_display(self, obj):
+        """Show count of support tickets for user (if support app is enabled)."""
+        try:
+            from django_cfg.modules.base import BaseCfgModule
+            base_module = BaseCfgModule()
+            
+            if not base_module.is_support_enabled():
+                return "—"
+            
+            from django_cfg.apps.support.models import Ticket
+            count = Ticket.objects.filter(user=obj).count()
+            if count == 0:
+                return "—"
+            
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.SUPPORT_AGENT)
+            return StatusBadge.create(
+                text=f"{count} ticket{'s' if count != 1 else ''}",
+                variant="warning",
+                config=config
+            )
+        except (ImportError, Exception):
+            return "—"
+    
+    @display(description="Last Login")
+    def last_login_display(self, obj):
+        """Last login with relative time."""
+        if not obj.last_login:
+            config = StatusBadgeConfig(show_icons=True, icon=Icons.LOGIN)
+            return StatusBadge.create(text="Never", variant="secondary", config=config)
+        
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'last_login', config)
+    
+    @display(description="Joined")
+    def date_joined_display(self, obj):
+        """Join date with relative time."""
+        config = DateTimeDisplayConfig(show_relative=True)
+        return self.display_datetime_relative(obj, 'date_joined', config)
+    
+    # Standalone Actions
+    @standalone_action(
+        description="📧 View Email History",
+        variant=ActionVariant.INFO,
+        icon="mail_outline",
+        success_message="Redirected to email history for {result}",
+        error_message="❌ Error accessing email history: {error}"
+    )
+    def view_user_emails(self, request, object_id):
+        """View all emails sent to this user."""
+        # Get the user object
+        user = self.get_object(request, object_id)
+        if not user:
+            raise Exception("User not found")
+        
+        # Check if newsletter app is enabled
+        from django_cfg.modules.base import BaseCfgModule
+        base_module = BaseCfgModule()
+        
+        if not base_module.is_newsletter_enabled():
+            raise Exception("Newsletter app is not enabled")
+        
+        # Redirect to EmailLog changelist filtered by this user
+        url = reverse('admin:django_cfg_newsletter_emaillog_changelist')
+        redirect_url = f"{url}?user__id__exact={user.id}"
+        
+        # Return redirect (handled by standalone_action decorator)
+        return redirect(redirect_url)
+    
+    @standalone_action(
+        description="🎫 View Support Tickets",
+        variant=ActionVariant.SUCCESS,
+        icon="support_agent",
+        success_message="Redirected to support tickets for {result}",
+        error_message="❌ Error accessing support tickets: {error}"
+    )
+    def view_user_tickets(self, request, object_id):
+        """View all support tickets for this user."""
+        # Get the user object
+        user = self.get_object(request, object_id)
+        if not user:
+            raise Exception("User not found")
+        
+        # Check if support app is enabled
+        from django_cfg.modules.base import BaseCfgModule
+        base_module = BaseCfgModule()
+        
+        if not base_module.is_support_enabled():
+            raise Exception("Support app is not enabled")
+        
+        # Redirect to Ticket changelist filtered by this user
+        url = reverse('admin:django_cfg_support_ticket_changelist')
+        redirect_url = f"{url}?user__id__exact={user.id}"
+        
+        return redirect(redirect_url)
+    
+    @standalone_action(
+        description="📊 Export User Data",
+        variant=ActionVariant.WARNING,
+        icon="download",
+        success_message="📊 User data export completed: {result}",
+        error_message="❌ Export failed: {error}"
+    )
+    def export_user_data(self, request, object_id):
+        """Export comprehensive user data."""
+        user = self.get_object(request, object_id)
+        if not user:
+            raise Exception("User not found")
+        
+        # Here you would implement actual export logic
+        # For now, just return a success message
+        return f"Data for {user.get_full_name() or user.email}"