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

django_cfg/apps/integrations/grpc/views/api_keys.py

@@ -0,0 +1,255 @@
+"""
+gRPC API Keys ViewSet.
+
+Provides REST API endpoints for viewing API keys.
+Create/Update/Delete operations handled through Django Admin.
+"""
+
+from django.db.models import Count, Q, Sum
+from django.utils import timezone
+from django_cfg.mixins import AdminAPIMixin
+from django_cfg.modules.django_logging import get_logger
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ..models import GrpcApiKey
+from ..serializers.api_keys import (
+    ApiKeyListSerializer,
+    ApiKeySerializer,
+    ApiKeyStatsSerializer,
+)
+
+logger = get_logger("grpc.api_keys")
+
+
+class GRPCApiKeyViewSet(AdminAPIMixin, viewsets.GenericViewSet):
+    """
+    ViewSet for gRPC API Keys (Read-Only).
+
+    Provides listing and statistics for API keys.
+    Create/Update/Delete operations are handled through Django Admin.
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    queryset = GrpcApiKey.objects.none()
+    serializer_class = ApiKeySerializer
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="List API keys",
+        description="Returns a list of all API keys with their details. Uses standard DRF pagination.",
+        parameters=[
+            OpenApiParameter(
+                name="is_active",
+                type=OpenApiTypes.BOOL,
+                location=OpenApiParameter.QUERY,
+                description="Filter by active status",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="key_type",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.QUERY,
+                description="Filter by key type (service, cli, webhook, internal, development)",
+                required=False,
+            ),
+            OpenApiParameter(
+                name="user_id",
+                type=OpenApiTypes.INT,
+                location=OpenApiParameter.QUERY,
+                description="Filter by user ID",
+                required=False,
+            ),
+        ],
+        responses={
+            200: ApiKeySerializer(many=True),
+            400: {"description": "Invalid parameters"},
+        },
+    )
+    def list(self, request):
+        """List all API keys."""
+        try:
+            # Build queryset with filters
+            queryset = GrpcApiKey.objects.select_related("user", "created_by").all()
+
+            # Apply filters
+            is_active = request.GET.get("is_active")
+            if is_active is not None:
+                is_active_bool = is_active.lower() in ("true", "1", "yes")
+                queryset = queryset.filter(is_active=is_active_bool)
+
+            key_type = request.GET.get("key_type")
+            if key_type:
+                queryset = queryset.filter(key_type=key_type)
+
+            user_id = request.GET.get("user_id")
+            if user_id:
+                queryset = queryset.filter(user_id=user_id)
+
+            # Order by most recently created
+            queryset = queryset.order_by("-created_at")
+
+            # Paginate
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                # Serialize paginated data
+                results = []
+                for key in page:
+                    results.append({
+                        "id": key.id,
+                        "name": key.name,
+                        "key_type": key.key_type,
+                        "masked_key": key.masked_key,
+                        "is_active": key.is_active,
+                        "is_valid": key.is_valid,
+                        "user_id": key.user.id,
+                        "username": key.user.username,
+                        "user_email": key.user.email,
+                        "request_count": key.request_count,
+                        "last_used_at": key.last_used_at,
+                        "expires_at": key.expires_at,
+                        "created_at": key.created_at,
+                        "created_by": key.created_by.username if key.created_by else None,
+                    })
+                return self.get_paginated_response(results)
+
+            # No pagination fallback
+            results = []
+            for key in queryset[:100]:
+                results.append({
+                    "id": key.id,
+                    "name": key.name,
+                    "key_type": key.key_type,
+                    "masked_key": key.masked_key,
+                    "is_active": key.is_active,
+                    "is_valid": key.is_valid,
+                    "user_id": key.user.id,
+                    "username": key.user.username,
+                    "user_email": key.user.email,
+                    "request_count": key.request_count,
+                    "last_used_at": key.last_used_at,
+                    "expires_at": key.expires_at,
+                    "created_at": key.created_at,
+                    "created_by": key.created_by.username if key.created_by else None,
+                })
+
+            return Response({"results": results, "count": len(results)})
+
+        except ValueError as e:
+            logger.warning(f"API keys list validation error: {e}")
+            return Response(
+                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
+            )
+        except Exception as e:
+            logger.error(f"API keys list error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="Get API key details",
+        description="Returns detailed information about a specific API key.",
+        responses={
+            200: ApiKeySerializer,
+            404: {"description": "API key not found"},
+        },
+    )
+    def retrieve(self, request, pk=None):
+        """Get details of a specific API key."""
+        try:
+            key = GrpcApiKey.objects.select_related("user", "created_by").get(pk=pk)
+
+            data = {
+                "id": key.id,
+                "name": key.name,
+                "key_type": key.key_type,
+                "masked_key": key.masked_key,
+                "is_active": key.is_active,
+                "is_valid": key.is_valid,
+                "user_id": key.user.id,
+                "username": key.user.username,
+                "user_email": key.user.email,
+                "request_count": key.request_count,
+                "last_used_at": key.last_used_at,
+                "expires_at": key.expires_at,
+                "created_at": key.created_at,
+                "created_by": key.created_by.username if key.created_by else None,
+            }
+
+            serializer = ApiKeySerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except GrpcApiKey.DoesNotExist:
+            return Response(
+                {"error": "API key not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        except Exception as e:
+            logger.error(f"API key retrieve error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC API Keys"],
+        summary="Get API keys statistics",
+        description="Returns overall statistics about API keys usage.",
+        responses={
+            200: ApiKeyStatsSerializer,
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="stats")
+    def stats(self, request):
+        """Get API keys statistics."""
+        try:
+            # Total keys
+            total_keys = GrpcApiKey.objects.count()
+
+            # Active keys
+            active_keys = GrpcApiKey.objects.filter(is_active=True).count()
+
+            # Expired keys
+            expired_keys = GrpcApiKey.objects.filter(
+                Q(is_active=True) & Q(expires_at__lt=timezone.now())
+            ).count()
+
+            # Total requests across all keys
+            total_requests = GrpcApiKey.objects.aggregate(
+                total=Sum("request_count")
+            )["total"] or 0
+
+            # Keys by type
+            keys_by_type_qs = GrpcApiKey.objects.values("key_type").annotate(
+                count=Count("id")
+            )
+            keys_by_type = {item["key_type"]: item["count"] for item in keys_by_type_qs}
+
+            stats_data = {
+                "total_keys": total_keys,
+                "active_keys": active_keys,
+                "expired_keys": expired_keys,
+                "total_requests": total_requests,
+                "keys_by_type": keys_by_type,
+            }
+
+            serializer = ApiKeyStatsSerializer(data=stats_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"API keys stats error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCApiKeyViewSet"]

django_cfg/apps/integrations/grpc/views/charts.py

@@ -72,8 +72,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_server_uptime_data(hours)
-            serializer = ServerUptimeChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ServerUptimeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Server uptime chart error: {e}", exc_info=True)
             return Response(
@@ -94,8 +95,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_request_volume_data(hours)
-            serializer = RequestVolumeChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = RequestVolumeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Request volume chart error: {e}", exc_info=True)
             return Response(
@@ -116,8 +118,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_response_time_data(hours)
-            serializer = ResponseTimeChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ResponseTimeChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Response time chart error: {e}", exc_info=True)
             return Response(
@@ -138,8 +141,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_service_activity_data(hours)
-            serializer = ServiceActivityChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ServiceActivityChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Service activity chart error: {e}", exc_info=True)
             return Response(
@@ -160,8 +164,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_server_lifecycle_data(hours)
-            serializer = ServerLifecycleChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ServerLifecycleChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Server lifecycle chart error: {e}", exc_info=True)
             return Response(
@@ -182,8 +187,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_error_distribution_data(hours)
-            serializer = ErrorDistributionChartSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = ErrorDistributionChartSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Error distribution chart error: {e}", exc_info=True)
             return Response(
@@ -204,8 +210,9 @@ class GRPCChartsViewSet(AdminAPIMixin, viewsets.ViewSet):
         try:
             hours = self._validate_hours(request.GET.get("hours", "24"))
             data = ChartGeneratorService.generate_dashboard_data(hours)
-            serializer = DashboardChartsSerializer(**data)
-            return Response(serializer.model_dump())
+            serializer = DashboardChartsSerializer(data=data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
         except Exception as e:
             logger.error(f"Dashboard charts error: {e}", exc_info=True)
             return Response(

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

@@ -67,7 +67,7 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                     "host": grpc_config.server.host,
                     "port": grpc_config.server.port,
                     "enabled": grpc_config.server.enabled,
-                    "max_workers": grpc_config.server.max_workers,
+                    "max_concurrent_streams": grpc_config.server.max_concurrent_streams,
                     "max_concurrent_rpcs": None,  # Not in current config
                 },
                 "framework": {
@@ -77,7 +77,7 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                     "interceptors": grpc_config.server.interceptors,
                 },
                 "features": {
-                    "jwt_auth": grpc_config.auth.enabled,
+                    "api_key_auth": grpc_config.auth.enabled,
                     "request_logging": True,  # Always on
                     "metrics": True,  # Always on
                     "reflection": grpc_config.server.enable_reflection,
@@ -86,8 +86,9 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                 "total_methods": methods_count,
             }
 
-            serializer = GRPCConfigSerializer(**config_data)
-            return Response(serializer.model_dump())
+            serializer = GRPCConfigSerializer(data=config_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Config fetch error: {e}", exc_info=True)
@@ -177,8 +178,9 @@ class GRPCConfigViewSet(AdminAPIMixin, viewsets.ViewSet):
                 },
             }
 
-            serializer = GRPCServerInfoSerializer(**server_info_data)
-            return Response(serializer.model_dump())
+            serializer = GRPCServerInfoSerializer(data=server_info_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Server info error: {e}", exc_info=True)

django_cfg/apps/integrations/grpc/views/monitoring.py

@@ -11,6 +11,7 @@ from django.db import models
 from django.db.models import Avg, Count, Max
 from django.db.models.functions import TruncDay, TruncHour
 from django_cfg.mixins import AdminAPIMixin
+from django_cfg.middleware.pagination import DefaultPagination
 from django_cfg.modules.django_logging import get_logger
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, extend_schema
@@ -24,8 +25,6 @@ from ..serializers import (
     GRPCOverviewStatsSerializer,
     MethodListSerializer,
     MethodStatsSerializer,
-    MonitoringServiceStatsSerializer,
-    ServiceListSerializer,
 )
 from ..serializers.service_registry import RecentRequestSerializer
 from ..services import MonitoringService
@@ -48,6 +47,8 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     Requires admin authentication (JWT, Session, or Basic Auth).
     """
 
+    pagination_class = DefaultPagination
+
     # Required for GenericViewSet
     queryset = GRPCRequestLog.objects.none()  # Placeholder, actual queries in actions
     serializer_class = RecentRequestSerializer  # Default serializer for schema
@@ -67,7 +68,9 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
         try:
             service = MonitoringService()
             health_data = service.get_health_status()
-            return Response(health_data)
+            serializer = GRPCHealthCheckSerializer(data=health_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except ValueError as e:
             return Response(
@@ -107,7 +110,9 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
 
             service = MonitoringService()
             stats = service.get_overview_statistics(hours=hours)
-            return Response(stats)
+            serializer = GRPCOverviewStatsSerializer(data=stats)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except ValueError as e:
             logger.warning(f"Overview stats validation error: {e}")
@@ -149,7 +154,7 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
             ),
         ],
         responses={
-            200: RecentRequestSerializer,
+            200: RecentRequestSerializer(many=True),  # Use many=True for paginated list
             400: {"description": "Invalid parameters"},
         },
     )
@@ -174,37 +179,49 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 # Serialize paginated data
                 requests_list = []
                 for req in page:
-                    req_serializer = RecentRequestSerializer(
-                        id=req.id,
-                        request_id=req.request_id,
-                        service_name=req.service_name,
-                        method_name=req.method_name,
-                        status=req.status,
-                        duration_ms=req.duration_ms or 0,
-                        grpc_status_code=req.grpc_status_code or "",
-                        error_message=req.error_message or "",
-                        created_at=req.created_at.isoformat(),
-                        client_ip=req.client_ip or "",
-                    )
-                    requests_list.append(req_serializer.model_dump())
+                    requests_list.append({
+                        "id": req.id,
+                        "request_id": req.request_id,
+                        "service_name": req.service_name,
+                        "method_name": req.method_name,
+                        "status": req.status,
+                        "duration_ms": req.duration_ms or 0,
+                        "grpc_status_code": req.grpc_status_code or "",
+                        "error_message": req.error_message or "",
+                        "created_at": req.created_at.isoformat(),
+                        "client_ip": req.client_ip or "",
+                        # User information
+                        "user_id": req.user.id if req.user else None,
+                        "username": req.user.username if req.user else "",
+                        "is_authenticated": req.is_authenticated,
+                        # API Key information
+                        "api_key_id": req.api_key.id if req.api_key else None,
+                        "api_key_name": req.api_key.name if req.api_key else "",
+                    })
                 return self.get_paginated_response(requests_list)
 
             # No pagination fallback
             requests_list = []
             for req in queryset[:100]:
-                req_serializer = RecentRequestSerializer(
-                    id=req.id,
-                    request_id=req.request_id,
-                    service_name=req.service_name,
-                    method_name=req.method_name,
-                    status=req.status,
-                    duration_ms=req.duration_ms or 0,
-                    grpc_status_code=req.grpc_status_code or "",
-                    error_message=req.error_message or "",
-                    created_at=req.created_at.isoformat(),
-                    client_ip=req.client_ip or "",
-                )
-                requests_list.append(req_serializer.model_dump())
+                requests_list.append({
+                    "id": req.id,
+                    "request_id": req.request_id,
+                    "service_name": req.service_name,
+                    "method_name": req.method_name,
+                    "status": req.status,
+                    "duration_ms": req.duration_ms or 0,
+                    "grpc_status_code": req.grpc_status_code or "",
+                    "error_message": req.error_message or "",
+                    "created_at": req.created_at.isoformat(),
+                    "client_ip": req.client_ip or "",
+                    # User information
+                    "user_id": req.user.id if req.user else None,
+                    "username": req.user.username if req.user else "",
+                    "is_authenticated": req.is_authenticated,
+                    # API Key information
+                    "api_key_id": req.api_key.id if req.api_key else None,
+                    "api_key_name": req.api_key.name if req.api_key else "",
+                })
             return Response({"requests": requests_list, "count": len(requests_list)})
 
         except ValueError as e:
@@ -219,52 +236,6 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 status=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
-    @extend_schema(
-        tags=["gRPC Monitoring"],
-        summary="Get service statistics",
-        description="Returns statistics grouped by service.",
-        parameters=[
-            OpenApiParameter(
-                name="hours",
-                type=OpenApiTypes.INT,
-                location=OpenApiParameter.QUERY,
-                description="Statistics period in hours (default: 24)",
-                required=False,
-            ),
-        ],
-        responses={
-            200: ServiceListSerializer,
-            400: {"description": "Invalid parameters"},
-        },
-    )
-    @action(detail=False, methods=["get"], url_path="services", pagination_class=None)
-    def services(self, request):
-        """Get statistics per service."""
-        try:
-            hours = int(request.GET.get("hours", 24))
-
-            service = MonitoringService()
-            services_list = service.get_service_statistics(hours=hours)
-
-            response_data = {
-                "services": services_list,
-                "total_services": len(services_list),
-            }
-
-            return Response(response_data)
-
-        except ValueError as e:
-            logger.warning(f"Service stats validation error: {e}")
-            return Response(
-                {"error": str(e)}, status=status.HTTP_400_BAD_REQUEST
-            )
-        except Exception as e:
-            logger.error(f"Service stats error: {e}", exc_info=True)
-            return Response(
-                {"error": "Internal server error"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
-
     @extend_schema(
         tags=["gRPC Monitoring"],
         summary="Get method statistics",
@@ -308,8 +279,9 @@ class GRPCMonitorViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 "total_methods": len(methods_list),
             }
 
-            serializer = MethodListSerializer(**response_data)
-            return Response(serializer.model_dump())
+            serializer = MethodListSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except ValueError as e:
             logger.warning(f"Method stats validation error: {e}")