django-cfg 1.5.8__py3-none-any.whl → 1.5.20__py3-none-any.whl

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

@@ -58,6 +58,18 @@ class GRPCRequestLogAdmin(PydanticAdmin):
 
         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."""
@@ -86,7 +98,7 @@ class GRPCRequestLogAdmin(PydanticAdmin):
             formatted = json.dumps(obj.request_data, indent=2)
             return self.html.code_block(formatted, language="json", max_height="400px")
         except Exception:
-            return str(obj.request_data)
+            return self.html.code(str(obj.request_data))
 
     request_data_display.short_description = "Request Data"
 
@@ -99,7 +111,7 @@ class GRPCRequestLogAdmin(PydanticAdmin):
             formatted = json.dumps(obj.response_data, indent=2)
             return self.html.code_block(formatted, language="json", max_height="400px")
         except Exception:
-            return str(obj.response_data)
+            return self.html.code(str(obj.response_data))
 
     response_data_display.short_description = "Response Data"
 
@@ -112,87 +124,84 @@ class GRPCRequestLogAdmin(PydanticAdmin):
                 separator=" "
             )
 
-        # gRPC status code
-        code_line = 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
-
-        # Error message
-        msg_line = self.html.key_value(
-            "Message",
-            self.html.text(obj.error_message, variant="danger")
-        ) if obj.error_message else None
-
-        # Error details
-        details_line = None
+        # Error details JSON
+        error_details_json = None
         if obj.error_details:
             try:
                 formatted = json.dumps(obj.error_details, indent=2)
-                details_line = self.html.key_value(
+                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(code_line, msg_line, details_line) if (code_line or msg_line) else self.html.empty()
+        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."""
-        # Duration
-        duration_line = self.html.key_value(
-            "Duration",
-            self.html.number(obj.duration_ms, suffix="ms") if obj.duration_ms else "N/A"
-        )
-
-        # Request size
-        request_size_line = self.html.key_value(
-            "Request Size",
-            self.html.number(obj.request_size, suffix=" bytes") if obj.request_size else "N/A"
-        )
-
-        # Response size
-        response_size_line = self.html.key_value(
-            "Response Size",
-            self.html.number(obj.response_size, suffix=" bytes") if obj.response_size else "N/A"
-        )
-
-        # Authentication
-        auth_line = self.html.key_value(
-            "Authenticated",
-            self.html.badge("Yes" if obj.is_authenticated else "No",
-                          variant="success" if obj.is_authenticated else "secondary")
+        """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,
         )
 
-        return self.html.breakdown(duration_line, request_size_line, response_size_line, auth_line)
-
     performance_stats_display.short_description = "Performance Statistics"
 
     def client_info_display(self, obj):
         """Display client information."""
-        # Client IP
-        ip_line = self.html.key_value(
-            "Client IP",
-            obj.client_ip if obj.client_ip else "N/A"
-        )
-
-        # User Agent
-        ua_line = self.html.key_value(
-            "User Agent",
-            obj.user_agent if obj.user_agent else "N/A"
-        )
-
-        # Peer
-        peer_line = self.html.key_value(
-            "Peer",
-            self.html.text(obj.peer, variant="secondary") if obj.peer else "N/A"
+        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,
         )
 
-        return self.html.breakdown(ip_line, ua_line, peer_line)
-
     client_info_display.short_description = "Client Information"
 
     # Fieldsets for detail view
@@ -205,7 +214,7 @@ class GRPCRequestLogAdmin(PydanticAdmin):
             ),
             (
                 "User Context",
-                {"fields": ("user", "is_authenticated")},
+                {"fields": ("user", "api_key", "is_authenticated")},
             ),
             (
                 "Performance",

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

@@ -0,0 +1,236 @@
+"""
+gRPC Server Status Admin.
+
+PydanticAdmin for GRPCServerStatus model with server monitoring and lifecycle 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 GRPCServerStatus
+from .config import grpcserverstatus_config
+
+
+@admin.register(GRPCServerStatus)
+class GRPCServerStatusAdmin(PydanticAdmin):
+    """
+    Admin interface for gRPC server status monitoring.
+
+    Features:
+    - Real-time server status indicators
+    - Uptime tracking and display
+    - Process information (PID, hostname)
+    - Service registration details
+    - Error tracking and display
+    """
+
+    config = grpcserverstatus_config
+
+    @computed_field("Uptime", ordering="started_at")
+    def uptime_display(self, obj):
+        """Display server uptime with performance indicator."""
+        uptime_text = obj.uptime_display
+
+        if not obj.is_running:
+            return self.html.badge(
+                uptime_text,
+                variant="secondary",
+                icon=Icons.SCHEDULE
+            )
+
+        # Color code based on uptime
+        uptime_seconds = obj.uptime_seconds
+        if uptime_seconds > 86400:  # > 1 day
+            variant = "success"
+            icon = Icons.CHECK_CIRCLE
+        elif uptime_seconds > 3600:  # > 1 hour
+            variant = "info"
+            icon = Icons.TIMER
+        else:  # < 1 hour
+            variant = "warning"
+            icon = Icons.SCHEDULE
+
+        return self.html.badge(uptime_text, variant=variant, icon=icon)
+
+    def server_config_display(self, obj):
+        """Display server configuration details."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Address",
+                self.html.badge(obj.address, variant="info", icon=Icons.CLOUD)
+            ),
+            self.html.key_value(
+                "Host",
+                self.html.code(obj.host)
+            ),
+            self.html.key_value(
+                "Port",
+                self.html.text(str(obj.port), variant="primary")
+            ),
+            self.html.key_value(
+                "Max Workers",
+                self.html.badge(str(obj.max_workers), variant="secondary", icon=Icons.SETTINGS)
+            ),
+            self.html.key_value(
+                "Reflection",
+                self.html.badge(
+                    "Enabled" if obj.enable_reflection else "Disabled",
+                    variant="success" if obj.enable_reflection else "secondary",
+                    icon=Icons.VISIBILITY if obj.enable_reflection else Icons.VISIBILITY_OFF
+                )
+            ),
+            self.html.key_value(
+                "Health Check",
+                self.html.badge(
+                    "Enabled" if obj.enable_health_check else "Disabled",
+                    variant="success" if obj.enable_health_check else "secondary",
+                    icon=Icons.HEALTH_AND_SAFETY if obj.enable_health_check else Icons.CANCEL
+                )
+            ),
+        )
+
+    server_config_display.short_description = "Server Configuration"
+
+    def process_info_display(self, obj):
+        """Display process information."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Instance ID",
+                self.html.code(obj.instance_id)
+            ),
+            self.html.key_value(
+                "PID",
+                self.html.badge(str(obj.pid), variant="info", icon=Icons.MEMORY)
+            ),
+            self.html.key_value(
+                "Hostname",
+                self.html.text(obj.hostname, variant="secondary")
+            ),
+            self.html.key_value(
+                "Running",
+                self.html.badge(
+                    "Yes" if obj.is_running else "No",
+                    variant="success" if obj.is_running else "danger",
+                    icon=Icons.CHECK_CIRCLE if obj.is_running else Icons.CANCEL
+                )
+            ),
+        )
+
+    process_info_display.short_description = "Process Information"
+
+    def registered_services_display(self, obj):
+        """Display registered services."""
+        if not obj.registered_services:
+            return self.html.empty("No services registered")
+
+        import json
+        try:
+            formatted = json.dumps(obj.registered_services, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return self.html.code(str(obj.registered_services))
+
+    registered_services_display.short_description = "Registered Services"
+
+    def error_display(self, obj):
+        """Display error information if status is ERROR."""
+        if obj.status != "error" or not obj.error_message:
+            return self.html.inline(
+                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                self.html.text("No errors", variant="success"),
+                separator=" "
+            )
+
+        return self.html.breakdown(
+            self.html.key_value(
+                "Error Message",
+                self.html.text(obj.error_message, variant="danger")
+            ),
+            self.html.key_value(
+                "Stopped At",
+                self.html.text(
+                    obj.stopped_at.strftime("%Y-%m-%d %H:%M:%S") if obj.stopped_at else "N/A",
+                    variant="secondary"
+                )
+            ),
+        )
+
+    error_display.short_description = "Error Details"
+
+    def lifecycle_display(self, obj):
+        """Display server lifecycle timestamps."""
+        return self.html.breakdown(
+            self.html.key_value(
+                "Started",
+                self.html.text(
+                    obj.started_at.strftime("%Y-%m-%d %H:%M:%S"),
+                    variant="success"
+                )
+            ),
+            self.html.key_value(
+                "Last Heartbeat",
+                self.html.text(
+                    obj.last_heartbeat.strftime("%Y-%m-%d %H:%M:%S"),
+                    variant="info"
+                )
+            ) if obj.last_heartbeat else None,
+            self.html.key_value(
+                "Stopped",
+                self.html.text(
+                    obj.stopped_at.strftime("%Y-%m-%d %H:%M:%S"),
+                    variant="danger"
+                )
+            ) if obj.stopped_at else None,
+            self.html.key_value(
+                "Uptime",
+                self.html.badge(obj.uptime_display, variant="primary", icon=Icons.TIMER)
+            ),
+        )
+
+    lifecycle_display.short_description = "Lifecycle"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            (
+                "Server Identity",
+                {"fields": ("id", "instance_id", "address", "status")},
+            ),
+            (
+                "Configuration",
+                {"fields": ("server_config_display", "host", "port", "max_workers", "enable_reflection", "enable_health_check")},
+            ),
+            (
+                "Process Information",
+                {"fields": ("process_info_display", "pid", "hostname", "is_running")},
+            ),
+            (
+                "Lifecycle",
+                {"fields": ("lifecycle_display", "started_at", "last_heartbeat", "stopped_at", "uptime_display")},
+            ),
+        ]
+
+        # Add registered services section if available
+        if obj and obj.registered_services:
+            fieldsets.append(
+                (
+                    "Registered Services",
+                    {"fields": ("registered_services_display",), "classes": ("collapse",)},
+                )
+            )
+
+        # Add error section only if status is ERROR
+        if obj and obj.status == "error":
+            fieldsets.append(
+                (
+                    "Error Details",
+                    {"fields": ("error_display", "error_message")},
+                )
+            )
+
+        return fieldsets
+
+
+__all__ = ["GRPCServerStatusAdmin"]

django_cfg/apps/integrations/grpc/auth/__init__.py

@@ -1,9 +1,17 @@
 """
 gRPC authentication components.
 
-Provides JWT authentication for gRPC services.
+Provides API key authentication for gRPC services.
 """
 
-from .jwt_auth import JWTAuthInterceptor
+from .api_key_auth import (
+    ApiKeyAuthInterceptor,
+    get_current_grpc_user,
+    get_current_grpc_api_key,
+)
 
-__all__ = ["JWTAuthInterceptor"]
+__all__ = [
+    "ApiKeyAuthInterceptor",
+    "get_current_grpc_user",
+    "get_current_grpc_api_key",
+]