django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/apps/integrations/grpc/admin/config.py

@@ -0,0 +1,261 @@
+"""
+Admin configuration for gRPC models.
+
+Declarative AdminConfig using PydanticAdmin patterns.
+"""
+
+from django_cfg.modules.django_admin import (
+    AdminConfig,
+    BadgeField,
+    BooleanField,
+    DateTimeField,
+    FieldsetConfig,
+    Icons,
+    TextField,
+    UserField,
+)
+
+from ..models import GRPCRequestLog, GRPCServerStatus, GrpcApiKey
+
+
+# Declarative configuration for GRPCRequestLog
+grpcrequestlog_config = AdminConfig(
+    model=GRPCRequestLog,
+    # Performance optimization
+    select_related=["user", "api_key"],
+
+    # List display
+    list_display=[
+        "service_badge",
+        "method_badge",
+        "status",
+        "grpc_status_code_display",
+        "user",
+        "api_key_display",
+        "duration_display",
+        "created_at",
+    ],
+
+    # Auto-generated display methods
+    display_fields=[
+        BadgeField(name="service_name", title="Service", variant="info", icon=Icons.API),
+        BadgeField(name="method_name", title="Method", variant="secondary", icon=Icons.CODE),
+        BadgeField(
+            name="status",
+            title="Status",
+            label_map={
+                "pending": "warning",
+                "success": "success",
+                "error": "danger",
+                "cancelled": "secondary",
+                "timeout": "danger",
+            },
+        ),
+        UserField(name="user", title="User", header=True),
+        DateTimeField(name="created_at", title="Created", ordering="created_at"),
+        DateTimeField(name="completed_at", title="Completed", ordering="completed_at"),
+    ],
+    # Filters
+    list_filter=["status", "grpc_status_code", "service_name", "method_name", "is_authenticated", "api_key", "created_at"],
+    search_fields=[
+        "request_id",
+        "service_name",
+        "method_name",
+        "full_method",
+        "user__username",
+        "user__email",
+        "api_key__name",
+        "api_key__key",
+        "error_message",
+        "client_ip",
+    ],
+    # Autocomplete for user and api_key fields
+    autocomplete_fields=["user", "api_key"],
+    # Readonly fields
+    readonly_fields=[
+        "id",
+        "request_id",
+        "created_at",
+        "completed_at",
+        "request_data_display",
+        "response_data_display",
+        "error_details_display",
+        "performance_stats_display",
+        "client_info_display",
+    ],
+    # Date hierarchy
+    date_hierarchy="created_at",
+    # Per page
+    list_per_page=50,
+)
+
+
+# Declarative configuration for GRPCServerStatus
+grpcserverstatus_config = AdminConfig(
+    model=GRPCServerStatus,
+
+    # List display
+    list_display=[
+        "instance_id",
+        "address",
+        "status",
+        "pid",
+        "hostname",
+        "uptime_display",
+        "started_at",
+        "last_heartbeat",
+    ],
+
+    # Auto-generated display methods
+    display_fields=[
+        BadgeField(
+            name="status",
+            title="Status",
+            label_map={
+                "starting": "info",
+                "running": "success",
+                "stopping": "warning",
+                "stopped": "secondary",
+                "error": "danger",
+            },
+            icon=Icons.CHECK_CIRCLE,
+        ),
+        DateTimeField(name="started_at", title="Started", ordering="started_at"),
+        DateTimeField(name="last_heartbeat", title="Last Heartbeat", ordering="last_heartbeat"),
+        DateTimeField(name="stopped_at", title="Stopped", ordering="stopped_at"),
+    ],
+
+    # Filters
+    list_filter=["status", "hostname", "started_at"],
+    search_fields=[
+        "instance_id",
+        "address",
+        "hostname",
+        "pid",
+    ],
+
+    # Readonly fields
+    readonly_fields=[
+        "id",
+        "instance_id",
+        "started_at",
+        "last_heartbeat",
+        "stopped_at",
+        "created_at",
+        "updated_at",
+        "uptime_display",
+        "is_running",
+        "server_config_display",
+        "process_info_display",
+        "registered_services_display",
+        "error_display",
+        "lifecycle_display",
+    ],
+
+    # Date hierarchy
+    date_hierarchy="started_at",
+
+    # Per page
+    list_per_page=50,
+
+    # Ordering
+    ordering=["-started_at"],
+)
+
+
+# Declarative configuration for GrpcApiKey
+grpcapikey_config = AdminConfig(
+    model=GrpcApiKey,
+
+    # Performance optimization
+    select_related=["user", "created_by"],
+
+    # List display
+    list_display=[
+        "status_indicator",
+        "name",
+        "key_type",
+        "user",
+        "masked_key_display",
+        "request_count_display",
+        "last_used_at",
+        "expires_display",
+        "created_at",
+    ],
+
+    # Auto-generated display methods
+    display_fields=[
+        TextField(name="name", title="Name", ordering="name"),
+        BadgeField(
+            name="key_type",
+            title="Type",
+            label_map={
+                "service": "info",
+                "cli": "primary",
+                "webhook": "warning",
+                "internal": "secondary",
+                "development": "danger",
+            },
+        ),
+        UserField(name="user", title="User", header=True, ordering="user__username"),
+        DateTimeField(name="last_used_at", title="Last Used", ordering="last_used_at"),
+        DateTimeField(name="created_at", title="Created", ordering="created_at"),
+    ],
+
+    # Filters
+    list_filter=["is_active", "key_type", "created_at", "expires_at", "user"],
+    search_fields=["name", "description", "user__username", "user__email", "key"],
+
+    # Readonly fields
+    readonly_fields=[
+        "key_display",
+        "masked_key",
+        "request_count",
+        "last_used_at",
+        "created_at",
+        "updated_at",
+        "created_by",
+    ],
+
+    # Fieldsets
+    fieldsets=[
+        FieldsetConfig(
+            title="Basic Information",
+            fields=["name", "description", "key_type", "is_active"],
+        ),
+        FieldsetConfig(
+            title="API Key",
+            fields=["key_display", "masked_key"],
+        ),
+        FieldsetConfig(
+            title="User Association",
+            fields=["user", "created_by"],
+        ),
+        FieldsetConfig(
+            title="Expiration",
+            fields=["expires_at"],
+        ),
+        FieldsetConfig(
+            title="Usage Statistics",
+            fields=["request_count", "last_used_at"],
+            collapsed=True,
+        ),
+        FieldsetConfig(
+            title="Timestamps",
+            fields=["created_at", "updated_at"],
+            collapsed=True,
+        ),
+    ],
+
+    # Autocomplete for user field
+    autocomplete_fields=["user"],
+
+    # Ordering
+    ordering=["-created_at"],
+
+    # Per page
+    list_per_page=50,
+)
+
+
+__all__ = ["grpcrequestlog_config", "grpcserverstatus_config", "grpcapikey_config"]

django_cfg/apps/integrations/grpc/admin/grpc_api_key.py

@@ -0,0 +1,129 @@
+"""
+gRPC API Key Admin.
+
+PydanticAdmin for GrpcApiKey model with enhanced UI and status tracking.
+"""
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import Icons, computed_field
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from ..models import GrpcApiKey
+from .config import grpcapikey_config
+
+
+@admin.register(GrpcApiKey)
+class GrpcApiKeyAdmin(PydanticAdmin):
+    """
+    Admin interface for gRPC API keys.
+
+    Features:
+    - List view with status indicators
+    - Search by name, description, user
+    - Filter by status, type, user
+    - Read-only key display (masked)
+    - Actions for revoking keys
+    - Type-safe configuration via AdminConfig
+    """
+
+    config = grpcapikey_config
+
+    # Permissions
+    def save_model(self, request, obj, form, change):
+        """Save model with created_by tracking."""
+        if not change:  # New object
+            obj.created_by = request.user
+        super().save_model(request, obj, form, change)
+
+    # Display methods
+    @computed_field("Status", ordering="is_active")
+    def status_indicator(self, obj):
+        """Display status indicator with expiration check."""
+        if obj.is_valid:
+            return self.html.badge(
+                "Active",
+                variant="success",
+                icon=Icons.CHECK_CIRCLE
+            )
+        elif obj.is_expired:
+            return self.html.badge(
+                "Expired",
+                variant="warning",
+                icon=Icons.SCHEDULE
+            )
+        else:
+            return self.html.badge(
+                "Revoked",
+                variant="danger",
+                icon=Icons.CANCEL
+            )
+
+    @computed_field("Masked Key")
+    def masked_key_display(self, obj):
+        """Display masked API key."""
+        return self.html.code(obj.masked_key)
+
+    def key_display(self, obj):
+        """Display full API key (read-only, for copying)."""
+        if obj.pk:
+            return self.html.code(obj.key)
+        return self.html.empty()
+
+    key_display.short_description = "Full API Key"
+
+    @computed_field("Requests", ordering="request_count")
+    def request_count_display(self, obj):
+        """Display request count with badge."""
+        if obj.request_count == 0:
+            return self.html.empty("0")
+
+        # Color based on usage
+        if obj.request_count > 1000:
+            variant = "success"
+        elif obj.request_count > 100:
+            variant = "info"
+        else:
+            variant = "secondary"
+
+        return self.html.badge(
+            str(obj.request_count),
+            variant=variant,
+            icon=Icons.ANALYTICS
+        )
+
+    @computed_field("Expires", ordering="expires_at")
+    def expires_display(self, obj):
+        """Display expiration date with status."""
+        if not obj.expires_at:
+            return self.html.badge(
+                "Never",
+                variant="success",
+                icon=Icons.ALL_INCLUSIVE
+            )
+
+        from django.utils import timezone
+        if obj.expires_at < timezone.now():
+            return self.html.badge(
+                obj.expires_at.strftime("%Y-%m-%d"),
+                variant="danger",
+                icon=Icons.ERROR
+            )
+
+        return self.html.text(
+            obj.expires_at.strftime("%Y-%m-%d"),
+            variant="primary"
+        )
+
+    # Actions
+    @admin.action(description="Revoke selected API keys")
+    def revoke_selected_keys(self, request, queryset):
+        """Revoke selected API keys."""
+        count = queryset.filter(is_active=True).count()
+        queryset.update(is_active=False)
+        self.message_user(
+            request,
+            f"Successfully revoked {count} API key(s).",
+        )
+
+
+__all__ = ["GrpcApiKeyAdmin"]

django_cfg/apps/integrations/grpc/admin/grpc_request_log.py

@@ -0,0 +1,261 @@
+"""
+gRPC Request Log Admin.
+
+PydanticAdmin for GRPCRequestLog model with custom computed fields.
+"""
+
+import json
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import Icons, computed_field
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from ..models import GRPCRequestLog
+from .config import grpcrequestlog_config
+
+
+@admin.register(GRPCRequestLog)
+class GRPCRequestLogAdmin(PydanticAdmin):
+    """
+    gRPC request log admin with analytics and filtering.
+
+    Features:
+    - Color-coded status badges
+    - Performance metrics visualization
+    - Duration display with performance indicators
+    - Formatted JSON for request/response data
+    - Error details with highlighted display
+    """
+
+    config = grpcrequestlog_config
+
+    @computed_field("Service", ordering="service_name")
+    def service_badge(self, obj):
+        """Display service name as badge."""
+        return self.html.badge(obj.service_name, variant="info", icon=Icons.API)
+
+    @computed_field("Method", ordering="method_name")
+    def method_badge(self, obj):
+        """Display method name as badge."""
+        return self.html.badge(obj.method_name, variant="secondary", icon=Icons.CODE)
+
+    @computed_field("gRPC Status", ordering="grpc_status_code")
+    def grpc_status_code_display(self, obj):
+        """Display gRPC status code with color coding."""
+        if not obj.grpc_status_code:
+            return self.html.empty()
+
+        # Color code based on status
+        if obj.grpc_status_code == "OK":
+            variant = "success"
+            icon = Icons.CHECK_CIRCLE
+        elif obj.grpc_status_code in ["CANCELLED", "DEADLINE_EXCEEDED"]:
+            variant = "warning"
+            icon = Icons.TIMER
+        else:
+            variant = "danger"
+            icon = Icons.ERROR
+
+        return self.html.badge(obj.grpc_status_code, variant=variant, icon=icon)
+
+    @computed_field("API Key", ordering="api_key__name")
+    def api_key_display(self, obj):
+        """Display API key name if used for authentication."""
+        if not obj.api_key:
+            return self.html.empty()
+
+        return self.html.badge(
+            obj.api_key.name,
+            variant="info" if obj.api_key.is_valid else "danger",
+            icon=Icons.KEY
+        )
+
+    @computed_field("Duration", ordering="duration_ms")
+    def duration_display(self, obj):
+        """Display duration with color coding based on speed."""
+        if obj.duration_ms is None:
+            return self.html.empty()
+
+        # Color code based on duration
+        if obj.duration_ms < 100:
+            variant = "success"  # Fast
+            icon = Icons.SPEED
+        elif obj.duration_ms < 1000:
+            variant = "warning"  # Moderate
+            icon = Icons.TIMER
+        else:
+            variant = "danger"  # Slow
+            icon = Icons.ERROR
+
+        return self.html.badge(f"{obj.duration_ms}ms", variant=variant, icon=icon)
+
+    def request_data_display(self, obj):
+        """Display formatted JSON request data."""
+        if not obj.request_data:
+            return self.html.empty("No request data logged")
+
+        try:
+            formatted = json.dumps(obj.request_data, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return self.html.code(str(obj.request_data))
+
+    request_data_display.short_description = "Request Data"
+
+    def response_data_display(self, obj):
+        """Display formatted JSON response data."""
+        if not obj.response_data:
+            return self.html.empty("No response data logged")
+
+        try:
+            formatted = json.dumps(obj.response_data, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return self.html.code(str(obj.response_data))
+
+    response_data_display.short_description = "Response Data"
+
+    def error_details_display(self, obj):
+        """Display error information if request failed."""
+        if obj.is_successful or obj.status == "pending":
+            return self.html.inline(
+                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                self.html.text("No errors", variant="success"),
+                separator=" "
+            )
+
+        # Error details JSON
+        error_details_json = None
+        if obj.error_details:
+            try:
+                formatted = json.dumps(obj.error_details, indent=2)
+                error_details_json = self.html.key_value(
+                    "Details",
+                    self.html.code_block(formatted, language="json", max_height="200px")
+                )
+            except Exception:
+                pass
+
+        return self.html.breakdown(
+            self.html.key_value(
+                "gRPC Status",
+                self.html.badge(obj.grpc_status_code, variant="danger", icon=Icons.ERROR)
+            ) if obj.grpc_status_code else None,
+            self.html.key_value(
+                "Message",
+                self.html.text(obj.error_message, variant="danger")
+            ) if obj.error_message else None,
+            error_details_json,
+        )
+
+    error_details_display.short_description = "Error Details"
+
+    def performance_stats_display(self, obj):
+        """Display performance statistics and authentication info."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Duration",
+                self.html.badge(f"{obj.duration_ms}ms", variant="info", icon=Icons.TIMER)
+            ) if obj.duration_ms is not None else None,
+            self.html.key_value(
+                "Request Size",
+                self.html.text(f"{obj.request_size:,} bytes", variant="secondary")
+            ) if obj.request_size else None,
+            self.html.key_value(
+                "Response Size",
+                self.html.text(f"{obj.response_size:,} bytes", variant="secondary")
+            ) if obj.response_size else None,
+            self.html.key_value(
+                "Authenticated",
+                self.html.badge(
+                    "Yes" if obj.is_authenticated else "No",
+                    variant="success" if obj.is_authenticated else "secondary",
+                    icon=Icons.VERIFIED_USER if obj.is_authenticated else Icons.PERSON
+                )
+            ),
+            self.html.key_value(
+                "API Key",
+                self.html.inline(
+                    self.html.badge(obj.api_key.name, variant="info", icon=Icons.KEY),
+                    self.html.text(f"({obj.api_key.masked_key})", variant="secondary"),
+                    separator=" "
+                )
+            ) if obj.api_key else None,
+        )
+
+    performance_stats_display.short_description = "Performance Statistics"
+
+    def client_info_display(self, obj):
+        """Display client information."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Client IP",
+                self.html.text(obj.client_ip, variant="info") if obj.client_ip else self.html.empty("N/A")
+            ),
+            self.html.key_value(
+                "User Agent",
+                self.html.code(obj.user_agent)
+            ) if obj.user_agent else None,
+            self.html.key_value(
+                "Peer",
+                self.html.text(obj.peer, variant="secondary")
+            ) if obj.peer else None,
+        )
+
+    client_info_display.short_description = "Client Information"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            (
+                "Request Information",
+                {"fields": ("id", "request_id", "full_method", "service_name", "method_name", "status")},
+            ),
+            (
+                "User Context",
+                {"fields": ("user", "api_key", "is_authenticated")},
+            ),
+            (
+                "Performance",
+                {"fields": ("performance_stats_display", "duration_ms", "created_at", "completed_at")},
+            ),
+            (
+                "Client Information",
+                {"fields": ("client_info_display", "client_ip", "user_agent", "peer"), "classes": ("collapse",)},
+            ),
+        ]
+
+        # Add request/response data sections if available
+        if obj and obj.request_data:
+            fieldsets.insert(
+                3,
+                (
+                    "Request Data",
+                    {"fields": ("request_data_display",), "classes": ("collapse",)},
+                ),
+            )
+
+        if obj and obj.response_data:
+            fieldsets.insert(
+                4,
+                (
+                    "Response Data",
+                    {"fields": ("response_data_display",), "classes": ("collapse",)},
+                ),
+            )
+
+        # Add error section only if failed
+        if obj and not obj.is_successful and obj.status != "pending":
+            fieldsets.insert(
+                5,
+                (
+                    "Error Details",
+                    {"fields": ("error_details_display", "grpc_status_code", "error_message", "error_details")},
+                ),
+            )
+
+        return fieldsets
+
+
+__all__ = ["GRPCRequestLogAdmin"]