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

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

@@ -0,0 +1,214 @@
+"""
+gRPC Proto Files ViewSet.
+
+Provides REST API endpoints for downloading proto files generated from Django models.
+"""
+
+from django.http import FileResponse, HttpResponse
+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 ..serializers.proto_files import (
+    ProtoFileListSerializer,
+    ProtoGenerateRequestSerializer,
+    ProtoGenerateResponseSerializer,
+)
+from ..services import ProtoFilesManager
+
+logger = get_logger("grpc.proto_files")
+
+
+class GRPCProtoFilesViewSet(AdminAPIMixin, viewsets.ViewSet):
+    """
+    ViewSet for gRPC proto files management.
+
+    Provides endpoints for:
+    - List all available proto files
+    - Download specific proto file
+    - Download all proto files as .zip
+    - Trigger proto generation
+
+    Requires admin authentication (JWT, Session, or Basic Auth).
+    """
+
+    lookup_value_regex = r'[^/]+'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.manager = ProtoFilesManager()
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="List all proto files",
+        description="Returns list of all available proto files with metadata.",
+        responses={
+            200: ProtoFileListSerializer,
+        },
+    )
+    def list(self, request):
+        """List all available proto files."""
+        try:
+            from django.urls import reverse
+            from django_cfg.core.state import get_current_config
+
+            proto_files = self.manager.scan_proto_files(request=request)
+
+            config = get_current_config()
+
+            # Build download-all URL
+            # Use api_url from config (respects HTTPS behind reverse proxy)
+            # Falls back to request.build_absolute_uri if config not available
+            if config and hasattr(config, 'api_url'):
+                path = reverse('django_cfg_grpc:proto-files-download-all')
+                download_all_url = f"{config.api_url}{path}"
+            else:
+                download_all_url = request.build_absolute_uri(
+                    reverse('django_cfg_grpc:proto-files-download-all')
+                )
+
+            response_data = {
+                "files": proto_files,
+                "total_files": len(proto_files),
+                "proto_dir": str(self.manager.get_proto_dir()),
+                "download_all_url": download_all_url,
+            }
+
+            serializer = ProtoFileListSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"Proto files list error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="Download proto file",
+        description="Download specific proto file by app label.",
+        parameters=[
+            OpenApiParameter(
+                name="pk",
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.PATH,
+                description="App label (e.g., 'crypto')",
+                required=True,
+            ),
+        ],
+        responses={
+            200: {
+                "description": "Proto file content",
+                "content": {"text/plain": {}},
+            },
+            404: {"description": "Proto file not found"},
+        },
+    )
+    def retrieve(self, request, pk=None):
+        """Download specific proto file."""
+        try:
+            app_label = pk
+            proto_file = self.manager.get_proto_file(app_label)
+
+            if not proto_file:
+                return Response(
+                    {"error": f"Proto file for app '{app_label}' not found"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Return proto file content
+            response = FileResponse(
+                open(proto_file, "rb"),
+                content_type="text/plain; charset=utf-8",
+            )
+            response["Content-Disposition"] = f'attachment; filename="{proto_file.name}"'
+            return response
+
+        except Exception as e:
+            logger.error(f"Proto file download error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="Download all proto files",
+        description="Download all proto files as a .zip archive.",
+        responses={
+            200: {
+                "description": "Zip archive with all proto files",
+                "content": {"application/zip": {}},
+            },
+            404: {"description": "No proto files found"},
+        },
+    )
+    @action(detail=False, methods=["get"], url_path="download-all")
+    def download_all(self, request):
+        """Download all proto files as .zip archive."""
+        try:
+            zip_data = self.manager.create_zip_archive()
+
+            if not zip_data:
+                return Response(
+                    {"error": "No proto files found"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            # Return zip file
+            response = HttpResponse(zip_data, content_type="application/zip")
+            response["Content-Disposition"] = 'attachment; filename="protos.zip"'
+            return response
+
+        except Exception as e:
+            logger.error(f"Proto files zip error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    @extend_schema(
+        tags=["gRPC Proto Files"],
+        summary="Generate proto files",
+        description="Trigger proto file generation for specified apps.",
+        request=ProtoGenerateRequestSerializer,
+        responses={
+            200: ProtoGenerateResponseSerializer,
+            400: {"description": "Bad request"},
+        },
+    )
+    @action(detail=False, methods=["post"], url_path="generate")
+    def generate(self, request):
+        """Trigger proto generation for specified apps."""
+        try:
+            serializer = ProtoGenerateRequestSerializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+
+            apps = serializer.validated_data.get("apps")
+            force = serializer.validated_data.get("force", False)
+
+            # Generate protos via service
+            result = self.manager.generate_protos(apps=apps, force=force)
+
+            # Add proto_dir to response
+            result["proto_dir"] = str(self.manager.get_proto_dir())
+
+            response_serializer = ProtoGenerateResponseSerializer(data=result)
+            response_serializer.is_valid(raise_exception=True)
+            return Response(response_serializer.data)
+
+        except Exception as e:
+            logger.error(f"Proto generation error: {e}", exc_info=True)
+            return Response(
+                {"error": "Internal server error"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+__all__ = ["GRPCProtoFilesViewSet"]

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

@@ -6,6 +6,7 @@ Provides REST API endpoints for viewing registered gRPC services and their metho
 
 from django.db import models
 from django.db.models import Avg, Count, Max, Min
+from django_cfg.middleware.pagination import DefaultPagination
 from django_cfg.mixins import AdminAPIMixin
 from django_cfg.modules.django_logging import get_logger
 from drf_spectacular.types import OpenApiTypes
@@ -20,13 +21,14 @@ from ..serializers.service_registry import (
     ServiceDetailSerializer,
     ServiceListSerializer,
     ServiceMethodsSerializer,
+    ServiceSummarySerializer,
 )
 from ..services import ServiceRegistryManager
 
 logger = get_logger("grpc.services")
 
 
-class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
+class GRPCServiceViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     """
     ViewSet for gRPC service registry and management.
 
@@ -39,13 +41,20 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
     Requires admin authentication (JWT, Session, or Basic Auth).
     """
 
+    # Pagination for list endpoint
+    pagination_class = DefaultPagination
+
+    # Required for GenericViewSet
+    queryset = GRPCRequestLog.objects.none()  # Placeholder
+    serializer_class = ServiceSummarySerializer
+
     # Allow dots in service names (e.g., apps.CryptoService)
     lookup_value_regex = r'[^/]+'
 
     @extend_schema(
         tags=["gRPC Services"],
         summary="List all services",
-        description="Returns list of all registered gRPC services with basic statistics.",
+        description="Returns paginated list of all registered gRPC services with basic statistics.",
         parameters=[
             OpenApiParameter(
                 name="hours",
@@ -54,13 +63,14 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
                 description="Statistics period in hours (default: 24)",
                 required=False,
             ),
+            # Note: page, page_size added automatically by pagination_class
         ],
         responses={
-            200: ServiceListSerializer,
+            200: ServiceSummarySerializer(many=True),
         },
     )
     def list(self, request):
-        """List all registered gRPC services."""
+        """List all registered gRPC services with pagination."""
         try:
             hours = int(request.GET.get("hours", 24))
             hours = min(max(hours, 1), 168)
@@ -68,23 +78,20 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
             # Use service registry manager
             registry = ServiceRegistryManager()
 
-            if not registry.is_server_running():
-                # No running server - return empty list
-                return Response({
-                    "services": [],
-                    "total_services": 0,
-                })
-
             # Get services with stats from service layer
+            # Note: This will return empty list if server is not running,
+            # but that's expected - services are only known when server is started
             services_list = registry.get_all_services_with_stats(hours=hours)
 
-            response_data = {
-                "services": services_list,
-                "total_services": len(services_list),
-            }
+            # Paginate the services list (works with empty list too)
+            page = self.paginate_queryset(services_list)
+            if page is not None:
+                serializer = ServiceSummarySerializer(page, many=True)
+                return self.get_paginated_response(serializer.data)
 
-            serializer = ServiceListSerializer(**response_data)
-            return Response(serializer.model_dump())
+            # Fallback (no pagination)
+            serializer = ServiceSummarySerializer(services_list, many=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Service list error: {e}", exc_info=True)
@@ -216,8 +223,9 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
                 ],
             }
 
-            serializer = ServiceDetailSerializer(**service_detail)
-            return Response(serializer.model_dump())
+            serializer = ServiceDetailSerializer(data=service_detail)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Service detail error: {e}", exc_info=True)
@@ -275,8 +283,9 @@ class GRPCServiceViewSet(AdminAPIMixin, viewsets.ViewSet):
                 "total_methods": len(methods_list),
             }
 
-            serializer = ServiceMethodsSerializer(**response_data)
-            return Response(serializer.model_dump())
+            serializer = ServiceMethodsSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Service methods error: {e}", exc_info=True)

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

@@ -85,8 +85,9 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 "total_examples": len(examples),
             }
 
-            serializer = GRPCExamplesListSerializer(**response_data)
-            return Response(serializer.model_dump())
+            serializer = GRPCExamplesListSerializer(data=response_data)
+            serializer.is_valid(raise_exception=True)
+            return Response(serializer.data)
 
         except Exception as e:
             logger.error(f"Examples fetch error: {e}", exc_info=True)
@@ -147,35 +148,33 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
                 # Serialize paginated data
                 logs_list = []
                 for log in page:
-                    log_serializer = GRPCTestLogSerializer(
-                        request_id=log.request_id,
-                        service=log.service_name,
-                        method=log.method_name,
-                        status=log.status,
-                        grpc_status_code=log.grpc_status_code or "",
-                        error_message=log.error_message or "",
-                        duration_ms=log.duration_ms or 0,
-                        created_at=log.created_at.isoformat(),
-                        user=log.user.username if log.user else None,
-                    )
-                    logs_list.append(log_serializer.model_dump())
+                    logs_list.append({
+                        "request_id": log.request_id,
+                        "service": log.service_name,
+                        "method": log.method_name,
+                        "status": log.status,
+                        "grpc_status_code": log.grpc_status_code or "",
+                        "error_message": log.error_message or "",
+                        "duration_ms": log.duration_ms or 0,
+                        "created_at": log.created_at.isoformat(),
+                        "user": log.user.username if log.user else None,
+                    })
                 return self.get_paginated_response(logs_list)
 
             # No pagination (shouldn't happen with default pagination)
             logs_list = []
             for log in queryset[:100]:  # Safety limit
-                log_serializer = GRPCTestLogSerializer(
-                    request_id=log.request_id,
-                    service=log.service_name,
-                    method=log.method_name,
-                    status=log.status,
-                    grpc_status_code=log.grpc_status_code or "",
-                    error_message=log.error_message or "",
-                    duration_ms=log.duration_ms or 0,
-                    created_at=log.created_at.isoformat(),
-                    user=log.user.username if log.user else None,
-                )
-                logs_list.append(log_serializer.model_dump())
+                logs_list.append({
+                    "request_id": log.request_id,
+                    "service": log.service_name,
+                    "method": log.method_name,
+                    "status": log.status,
+                    "grpc_status_code": log.grpc_status_code or "",
+                    "error_message": log.error_message or "",
+                    "duration_ms": log.duration_ms or 0,
+                    "created_at": log.created_at.isoformat(),
+                    "user": log.user.username if log.user else None,
+                })
             return Response({"logs": logs_list, "count": len(logs_list)})
 
         except Exception as e:
@@ -221,9 +220,10 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
         from django.utils import timezone
 
         try:
-            # Validate request - Pydantic validation
-            serializer = GRPCCallRequestSerializer(**request.data)
-            data = serializer.model_dump()
+            # Validate request - DRF validation
+            serializer = GRPCCallRequestSerializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+            data = serializer.validated_data
 
             service_name = data["service"]
             method_name = data["method"]
@@ -275,21 +275,23 @@ class GRPCTestingViewSet(AdminAPIMixin, viewsets.GenericViewSet):
             if response_data and isinstance(response_data, dict):
                 response_data = json.dumps(response_data)
 
-            response_serializer = GRPCCallResponseSerializer(
-                success=result["success"],
-                request_id=request_id,
-                service=result["service"],
-                method=result["method"],
-                status=log.status,
-                grpc_status_code=result["grpc_status_code"],
-                duration_ms=result["duration_ms"],
-                response=response_data,
-                error=result.get("error_message"),
-                metadata={},
-                timestamp=end_time.isoformat(),
-            )
+            response_data_dict = {
+                "success": result["success"],
+                "request_id": request_id,
+                "service": result["service"],
+                "method": result["method"],
+                "status": log.status,
+                "grpc_status_code": result["grpc_status_code"],
+                "duration_ms": result["duration_ms"],
+                "response": response_data,
+                "error": result.get("error_message"),
+                "metadata": {},
+                "timestamp": end_time.isoformat(),
+            }
 
-            return Response(response_serializer.model_dump(), status=status.HTTP_200_OK)
+            response_serializer = GRPCCallResponseSerializer(data=response_data_dict)
+            response_serializer.is_valid(raise_exception=True)
+            return Response(response_serializer.data, status=status.HTTP_200_OK)
 
         except Exception as e:
             logger.error(f"gRPC call endpoint error: {e}", exc_info=True)

django_cfg/apps/integrations/rq/views/jobs.py

@@ -19,7 +19,7 @@ from ..services import job_to_model
 logger = get_logger("rq.jobs")
 
 
-class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
+class JobViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     """
     ViewSet for RQ job management.
 
@@ -33,6 +33,8 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
     Requires admin authentication (JWT, Session, or Basic Auth).
     """
 
+    serializer_class = JobListSerializer
+
     @extend_schema(
         tags=["RQ Jobs"],
         summary="List all jobs",
@@ -455,9 +457,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get failed jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Failed jobs list error: {e}", exc_info=True)
@@ -530,9 +534,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get finished jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Finished jobs list error: {e}", exc_info=True)
@@ -795,9 +801,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get deferred jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Deferred jobs list error: {e}", exc_info=True)
@@ -870,9 +878,11 @@ class JobViewSet(AdminAPIMixin, viewsets.ViewSet):
                 except Exception as e:
                     logger.debug(f"Failed to get started jobs for queue {queue_name}: {e}")
 
-            serializer = JobListSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = JobListSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Started jobs list error: {e}", exc_info=True)

django_cfg/apps/integrations/rq/views/schedule.py

@@ -23,7 +23,7 @@ from ..serializers import (
 logger = get_logger("rq.schedule")
 
 
-class ScheduleViewSet(AdminAPIMixin, viewsets.ViewSet):
+class ScheduleViewSet(AdminAPIMixin, viewsets.GenericViewSet):
     """
     ViewSet for RQ schedule management.
 
@@ -37,6 +37,8 @@ class ScheduleViewSet(AdminAPIMixin, viewsets.ViewSet):
     Requires rq-scheduler to be installed: pip install rq-scheduler
     """
 
+    serializer_class = ScheduledJobSerializer
+
     @extend_schema(
         tags=["RQ Schedules"],
         summary="List scheduled jobs",
@@ -131,9 +133,11 @@ class ScheduleViewSet(AdminAPIMixin, viewsets.ViewSet):
                         }
                         all_jobs.append(job_data)
 
-            serializer = ScheduledJobSerializer(data=all_jobs, many=True)
+            # Use DRF pagination
+            page = self.paginate_queryset(all_jobs)
+            serializer = ScheduledJobSerializer(data=page, many=True)
             serializer.is_valid(raise_exception=True)
-            return Response(serializer.data)
+            return self.get_paginated_response(serializer.data)
 
         except Exception as e:
             logger.error(f"Failed to list scheduled jobs: {e}", exc_info=True)

django_cfg/apps/system/dashboard/serializers/commands.py

@@ -8,7 +8,14 @@ from rest_framework import serializers
 
 
 class CommandSerializer(serializers.Serializer):
-    """Django management command serializer."""
+    """
+    Django management command serializer.
+
+    Includes security metadata from base classes (SafeCommand, InteractiveCommand, etc.):
+    - web_executable: Can be executed via web interface
+    - requires_input: Requires interactive user input
+    - is_destructive: Modifies or deletes data
+    """
     name = serializers.CharField()
     app = serializers.CharField()
     help = serializers.CharField()
@@ -17,6 +24,23 @@ class CommandSerializer(serializers.Serializer):
     is_allowed = serializers.BooleanField(required=False)
     risk_level = serializers.CharField(required=False)
 
+    # Security metadata from command base classes
+    web_executable = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Can be executed via web interface"
+    )
+    requires_input = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Requires interactive user input"
+    )
+    is_destructive = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Modifies or deletes data"
+    )
+
 
 class CommandsSummarySerializer(serializers.Serializer):
     """Commands summary serializer."""

django_cfg/apps/system/dashboard/services/commands_service.py

@@ -55,7 +55,7 @@ class CommandsService:
                     continue
 
                 try:
-                    # Try to load command to get help text
+                    # Try to load command to get help text and metadata
                     command = load_command_class(app_name, command_name)
                     help_text = getattr(command, 'help', 'No description available')
 
@@ -66,6 +66,11 @@ class CommandsService:
                     # Get risk level
                     risk_level = get_command_risk_level(command_name, app_name)
 
+                    # Extract security metadata from command instance
+                    web_executable = getattr(command, 'web_executable', None)
+                    requires_input = getattr(command, 'requires_input', None)
+                    is_destructive = getattr(command, 'is_destructive', None)
+
                     commands_list.append({
                         'name': command_name,
                         'app': app_name,
@@ -74,6 +79,9 @@ class CommandsService:
                         'is_custom': is_custom,
                         'is_allowed': is_allowed,
                         'risk_level': risk_level,
+                        'web_executable': web_executable,
+                        'requires_input': requires_input,
+                        'is_destructive': is_destructive,
                     })
                 except Exception as e:
                     # If we can't load the command, still include basic info
@@ -86,6 +94,9 @@ class CommandsService:
                         'is_custom': app_name == 'django_cfg',
                         'is_allowed': is_allowed,
                         'risk_level': get_command_risk_level(command_name, app_name),
+                        'web_executable': None,
+                        'requires_input': None,
+                        'is_destructive': None,
                     })
 
             # Sort by name

django_cfg/apps/system/maintenance/management/commands/maintenance.py

@@ -7,16 +7,19 @@ Usage: python manage.py maintenance enable/disable/status/sync domain.com
 
 from typing import Any
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 from django.db import transaction
 
+from django_cfg.management.utils import InteractiveCommand
+
 from ...models import CloudflareSite, MaintenanceLog
 from ...services import MaintenanceService
 
 
-class Command(BaseCommand):
+class Command(InteractiveCommand):
     """Simple maintenance management command."""
 
+    command_name = 'maintenance'
     help = 'Manage maintenance mode for Cloudflare sites'
 
     def add_arguments(self, parser) -> None: