refactor(d3): ARCH-051 — 14 dict-body-Routes auf Pydantic-Schemas umgestellt (entity_permissions bulk ×2, guests invite, users menu-order, system_settings backup-config+dsar, knowledge ×3, self_improvement ×5); DSAR-Export F821-Bug behoben (datetime/timezone undefined → NameError beim GDPR-Export), Zeitstempel auf datetime.now(UTC); Validierung jetzt im Schema statt in Routen

app/plugins/builtins/knowledge/routes.py

@@ -1,51 +1,70 @@
 """Knowledge plugin routes — extraction, ask, review queue."""
 from __future__ import annotations
+
 import uuid
+
 from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel, Field
 from sqlalchemy.ext.asyncio import AsyncSession
+
 from app.core.db import get_db
 from app.deps import require_permission
-from app.plugins.builtins.knowledge.services import extract_knowledge, ask_knowledge, get_review_queue, review_extraction
+from app.plugins.builtins.knowledge.services import (
+    ask_knowledge,
+    extract_knowledge,
+    get_review_queue,
+    review_extraction,
+)
 
 router = APIRouter(prefix="/api/v1/knowledge", tags=["knowledge"])
 
+
+class KnowledgeExtractRequest(BaseModel):
+    """Extract knowledge from a source."""
+
+    source_type: str = Field(..., min_length=1)
+    source_id: uuid.UUID
+    source_title: str | None = None
+    source_text: str = Field(..., min_length=1)
+
+
+class KnowledgeAskRequest(BaseModel):
+    """Ask a knowledge question."""
+
+    question: str = Field(..., min_length=1)
+
+
+class KnowledgeReviewRequest(BaseModel):
+    """Approve or reject a knowledge extraction."""
+
+    approved: bool = False
+    notes: str | None = None
+
+
 @router.post("/extract")
 async def extract(
-    body: dict,
+    body: KnowledgeExtractRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("wiki:read")),
 ):
     """Extract knowledge from a source (wiki article, dms file, mail, communication)."""
     tenant_id = uuid.UUID(current_user["tenant_id"])
-    source_type = body.get("source_type", "")
-    source_id = body.get("source_id", "")
-    source_title = body.get("source_title")
-    source_text = body.get("source_text", "")
-    if not source_type or not source_id or not source_text:
-        raise HTTPException(400, detail={"detail": "source_type, source_id, source_text required", "code": "missing_fields"})
-    try:
-        sid = uuid.UUID(source_id)
-    except ValueError:
-        raise HTTPException(400, detail={"detail": "Invalid source_id", "code": "invalid_id"}) from None
     result = await extract_knowledge(
-        db=db, tenant_id=tenant_id, source_type=source_type, source_id=sid,
-        source_title=source_title, source_text=source_text,
+        db=db, tenant_id=tenant_id, source_type=body.source_type, source_id=body.source_id,
+        source_title=body.source_title, source_text=body.source_text,
         user_id=uuid.UUID(current_user["user_id"]) if current_user.get("user_id") else None,
     )
     return result
 
 @router.post("/ask")
 async def ask(
-    body: dict,
+    body: KnowledgeAskRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("wiki:read")),
 ):
     """Ask a knowledge question — uses wiki + graph_rag as context."""
     tenant_id = uuid.UUID(current_user["tenant_id"])
-    question = body.get("question") or body.get("query", "")
-    if not question:
-        raise HTTPException(400, detail={"detail": "question required", "code": "missing_question"})
-    result = await ask_knowledge(db=db, tenant_id=tenant_id, question=question)
+    result = await ask_knowledge(db=db, tenant_id=tenant_id, question=body.question)
     return result
 
 @router.get("/review")
@@ -62,22 +81,20 @@ async def review_queue(
 @router.post("/review/{extraction_id}")
 async def review(
     extraction_id: str,
-    body: dict,
+    body: KnowledgeReviewRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("wiki:write")),
 ):
     """Approve or reject a knowledge extraction."""
     tenant_id = uuid.UUID(current_user["tenant_id"])
-    approved = body.get("approved", False)
-    notes = body.get("notes")
     try:
         eid = uuid.UUID(extraction_id)
     except ValueError:
         raise HTTPException(400, detail={"detail": "Invalid extraction_id", "code": "invalid_id"}) from None
     result = await review_extraction(
-        db=db, tenant_id=tenant_id, extraction_id=eid, approved=approved,
+        db=db, tenant_id=tenant_id, extraction_id=eid, approved=body.approved,
         user_id=uuid.UUID(current_user["user_id"]) if current_user.get("user_id") else None,
-        notes=notes,
+        notes=body.notes,
     )
     if "error" in result:
         raise HTTPException(404, detail={"detail": result["error"], "code": "not_found"})

app/plugins/builtins/self_improvement/routes.py

@@ -6,6 +6,7 @@ from datetime import datetime
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel, Field
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.db import get_db
@@ -28,6 +29,46 @@ from app.plugins.builtins.self_improvement.services import (
 router = APIRouter(prefix="/api/v1/improvement", tags=["improvement"])
 
 
+class CollectSignalsRequest(BaseModel):
+    """Collect improvement signals from existing system data."""
+
+    since: datetime | None = None
+    limit: int = Field(100, ge=1, le=500)
+
+
+class DetectPatternsRequest(BaseModel):
+    """Detect recurring patterns from collected signals."""
+
+    min_occurrences: int = Field(2, ge=2)
+
+
+class CreateProposalRequest(BaseModel):
+    """Create a new improvement proposal."""
+
+    pattern_id: uuid.UUID | None = None
+    title: str = Field(..., min_length=1)
+    description: str = ""
+    target_type: str = Field(..., min_length=1)
+    target_ref_id: uuid.UUID | None = None
+    target_name: str | None = None
+    proposed_config: dict[str, Any] = Field(default_factory=dict)
+    rationale: str = ""
+    expected_benefit: str = ""
+    risk_assessment: str = ""
+
+
+class RequestApprovalRequest(BaseModel):
+    """Request human approval for a proposal."""
+
+    approver_id: uuid.UUID | None = None
+
+
+class RollbackProposalRequest(BaseModel):
+    """Rollback an active proposal."""
+
+    reason: str = ""
+
+
 # ──────────────────────────────────────────────────────────────────────────
 # J-SIGNAL: Signal Collection
 # NOTE: /signals/collect must be defined before /signals to avoid route conflicts
@@ -35,21 +76,13 @@ router = APIRouter(prefix="/api/v1/improvement", tags=["improvement"])
 
 @router.post("/signals/collect")
 async def collect(
-    body: dict,
+    body: CollectSignalsRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("automation:read")),
 ):
     """Collect improvement signals from existing system data."""
     tenant_id = uuid.UUID(current_user["tenant_id"])
-    since_str = body.get("since")
-    since = None
-    if since_str:
-        try:
-            since = datetime.fromisoformat(since_str)
-        except ValueError:
-            raise HTTPException(400, detail={"detail": "Invalid since format", "code": "invalid_date"}) from None
-    limit = min(body.get("limit", 100), 500)
-    result = await collect_signals(db=db, tenant_id=tenant_id, since=since, limit=limit)
+    result = await collect_signals(db=db, tenant_id=tenant_id, since=body.since, limit=body.limit)
     await db.commit()
     return result
 
@@ -73,14 +106,13 @@ async def signals(
 
 @router.post("/patterns/detect")
 async def detect(
-    body: dict,
+    body: DetectPatternsRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("automation:read")),
 ):
     """Detect recurring patterns from collected signals."""
     tenant_id = uuid.UUID(current_user["tenant_id"])
-    min_occurrences = body.get("min_occurrences", 2)
-    result = await detect_patterns(db=db, tenant_id=tenant_id, min_occurrences=min_occurrences)
+    result = await detect_patterns(db=db, tenant_id=tenant_id, min_occurrences=body.min_occurrences)
     await db.commit()
     return result
 
@@ -103,7 +135,7 @@ async def patterns(
 
 @router.post("/proposals")
 async def create(
-    body: dict,
+    body: CreateProposalRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("automation:write")),
 ):
@@ -111,35 +143,18 @@ async def create(
     tenant_id = uuid.UUID(current_user["tenant_id"])
     user_id = uuid.UUID(current_user["user_id"]) if current_user.get("user_id") else None
 
-    pattern_id = None
-    if body.get("pattern_id"):
-        try:
-            pattern_id = uuid.UUID(body["pattern_id"])
-        except ValueError:
-            raise HTTPException(400, detail={"detail": "Invalid pattern_id", "code": "invalid_id"}) from None
-
-    target_ref_id = None
-    if body.get("target_ref_id"):
-        try:
-            target_ref_id = uuid.UUID(body["target_ref_id"])
-        except ValueError:
-            raise HTTPException(400, detail={"detail": "Invalid target_ref_id", "code": "invalid_id"}) from None
-
-    if not body.get("title") or not body.get("target_type"):
-        raise HTTPException(400, detail={"detail": "title and target_type required", "code": "missing_fields"})
-
     proposal = await create_proposal(
         db=db, tenant_id=tenant_id,
-        pattern_id=pattern_id,
-        title=body["title"],
-        description=body.get("description", ""),
-        target_type=body["target_type"],
-        target_ref_id=target_ref_id,
-        target_name=body.get("target_name"),
-        proposed_config=body.get("proposed_config", {}),
-        rationale=body.get("rationale", ""),
-        expected_benefit=body.get("expected_benefit", ""),
-        risk_assessment=body.get("risk_assessment", ""),
+        pattern_id=body.pattern_id,
+        title=body.title,
+        description=body.description,
+        target_type=body.target_type,
+        target_ref_id=body.target_ref_id,
+        target_name=body.target_name,
+        proposed_config=body.proposed_config,
+        rationale=body.rationale,
+        expected_benefit=body.expected_benefit,
+        risk_assessment=body.risk_assessment,
         user_id=user_id,
     )
     await db.commit()
@@ -207,7 +222,7 @@ async def evaluate(
 @router.post("/proposals/{proposal_id}/request-approval")
 async def req_approval(
     proposal_id: str,
-    body: dict,
+    body: RequestApprovalRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("automation:write")),
 ):
@@ -218,13 +233,7 @@ async def req_approval(
         pid = uuid.UUID(proposal_id)
     except ValueError:
         raise HTTPException(400, detail={"detail": "Invalid proposal_id", "code": "invalid_id"}) from None
-    approver_id = None
-    if body.get("approver_id"):
-        try:
-            approver_id = uuid.UUID(body["approver_id"])
-        except ValueError:
-            raise HTTPException(400, detail={"detail": "Invalid approver_id", "code": "invalid_id"}) from None
-    result = await request_approval(db=db, tenant_id=tenant_id, proposal_id=pid, requested_by=user_id, approver_id=approver_id)
+    result = await request_approval(db=db, tenant_id=tenant_id, proposal_id=pid, requested_by=user_id, approver_id=body.approver_id)
     if "error" in result:
         raise HTTPException(400, detail={"detail": result["error"], "code": "invalid_state"})
     await db.commit()
@@ -258,7 +267,7 @@ async def activate(
 @router.post("/proposals/{proposal_id}/rollback")
 async def rollback(
     proposal_id: str,
-    body: dict,
+    body: RollbackProposalRequest,
     db: AsyncSession = Depends(get_db),
     current_user: dict = Depends(require_permission("automation:admin")),
 ):
@@ -268,8 +277,7 @@ async def rollback(
         pid = uuid.UUID(proposal_id)
     except ValueError:
         raise HTTPException(400, detail={"detail": "Invalid proposal_id", "code": "invalid_id"}) from None
-    reason = body.get("reason", "")
-    result = await rollback_proposal(db=db, tenant_id=tenant_id, proposal_id=pid, reason=reason)
+    result = await rollback_proposal(db=db, tenant_id=tenant_id, proposal_id=pid, reason=body.reason)
     if "error" in result:
         raise HTTPException(400, detail={"detail": result["error"], "code": "invalid_state"})
     await db.commit()