feat(repairs): add repair management foundation

backend/hermes/app/api/audit.py

@@ -56,6 +56,8 @@ def can_read_activity(action: str, permissions: set[str]) -> bool:
         return "roles.read" in permissions
     if action.startswith("knowledge."):
         return "knowledge.read" in permissions
+    if action.startswith("repairs."):
+        return "repairs.read" in permissions
     if action.startswith("audit_logs."):
         return "audit_logs.read" in permissions
     if action.startswith("auth."):

backend/hermes/app/api/dashboard.py

@@ -9,6 +9,7 @@ from app.db.database import get_db
 from app.models.rbac import Role
 from app.models.user import User
 from app.repositories.customer_repository import CustomerRepository
+from app.repositories.repair_repository import RepairRepository
 from app.repositories.user_repository import UserRepository
 from app.schemas.dashboard import DashboardSummary, EmptyWidget, MetricCard
 
@@ -30,6 +31,7 @@ def get_dashboard_summary(
     latest_customers = []
     users: list[MetricCard] = []
     roles: list[MetricCard] = []
+    repairs: list[MetricCard] = []
 
     if "customers.read" in permissions:
         customers = [
@@ -54,6 +56,14 @@ def get_dashboard_summary(
             )
         ]
 
+    if "repairs.read" in permissions:
+        repairs = [
+            MetricCard(label="Neue Reparaturen", value=RepairRepository.count_by_status(db, "new")),
+            MetricCard(label="In Diagnose", value=RepairRepository.count_by_status(db, "diagnosis")),
+            MetricCard(label="Warten auf Kunde", value=RepairRepository.count_by_status(db, "waiting_for_customer")),
+            MetricCard(label="Abgeschlossen", value=RepairRepository.count_by_status(db, "completed")),
+        ]
+
     logger.info("dashboard.summary", extra={"actor_user_id": current_user.id})
 
     return DashboardSummary(
@@ -61,6 +71,7 @@ def get_dashboard_summary(
         latest_customers=latest_customers,
         users=users,
         roles=roles,
+        repairs=repairs,
         activities=EmptyWidget(
             title="Letzte Aktivitäten",
             message="Noch keine Aktivitäten vorhanden.",

backend/hermes/app/api/repairs.py

@@ -0,0 +1,142 @@
+from fastapi import APIRouter, Depends, Header, HTTPException, Query, status
+from sqlalchemy.orm import Session
+from starlette.requests import Request
+from typing import cast
+
+from app.core.config import settings
+from app.core.rbac import require_permission
+from app.db.database import get_db
+from app.models.repair import Repair
+from app.models.user import User
+from app.repositories.repair_repository import RepairRepository
+from app.schemas.repair import (
+    RepairCreate,
+    RepairIntakePayload,
+    RepairIntakeResponse,
+    RepairListResponse,
+    RepairResponse,
+    RepairStatus,
+    RepairStatusHistoryResponse,
+    RepairStatusUpdate,
+    RepairUpdate,
+)
+from app.services.repair_service import RepairService
+
+router = APIRouter(tags=["Repairs"])
+
+
+def get_repair_or_404(db: Session, repair_id: int) -> Repair:
+    repair = RepairRepository.get_by_id(db, repair_id)
+    if repair is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Reparatur nicht gefunden")
+    return repair
+
+
+@router.get("/repairs", response_model=RepairListResponse)
+@router.get("/repairs/", response_model=RepairListResponse, include_in_schema=False)
+def get_repairs(
+    status_filter: str | None = Query(default=None, alias="status"),
+    q: str | None = None,
+    customer_id: int | None = None,
+    source: str | None = None,
+    priority: str | None = None,
+    limit: int = Query(default=50, ge=1, le=100),
+    offset: int = Query(default=0, ge=0),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_permission("repairs.read")),
+):
+    items, total = RepairRepository.list(
+        db,
+        status=status_filter,
+        q=q,
+        customer_id=customer_id,
+        source=source,
+        priority=priority,
+        limit=limit,
+        offset=offset,
+    )
+    return RepairListResponse(items=items, total=total, limit=limit, offset=offset)
+
+
+@router.get("/repairs/{repair_id}", response_model=RepairResponse)
+def get_repair(
+    repair_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_permission("repairs.read")),
+):
+    return get_repair_or_404(db, repair_id)
+
+
+@router.post("/repairs", response_model=RepairResponse, status_code=status.HTTP_201_CREATED)
+@router.post("/repairs/", response_model=RepairResponse, status_code=status.HTTP_201_CREATED, include_in_schema=False)
+def create_repair(
+    repair: RepairCreate,
+    request: Request,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_permission("repairs.create")),
+):
+    return RepairService.create(db, repair, actor=current_user, request=request)
+
+
+@router.put("/repairs/{repair_id}", response_model=RepairResponse)
+def update_repair(
+    repair_id: int,
+    repair: RepairUpdate,
+    request: Request,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_permission("repairs.update")),
+):
+    db_repair = get_repair_or_404(db, repair_id)
+    return RepairService.update(db, db_repair, repair, actor=current_user, request=request)
+
+
+@router.delete("/repairs/{repair_id}", response_model=RepairResponse)
+def delete_repair(
+    repair_id: int,
+    request: Request,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_permission("repairs.delete")),
+):
+    db_repair = get_repair_or_404(db, repair_id)
+    return RepairService.cancel(db, db_repair, actor=current_user, request=request)
+
+
+@router.put("/repairs/{repair_id}/status", response_model=RepairResponse)
+def update_repair_status(
+    repair_id: int,
+    payload: RepairStatusUpdate,
+    request: Request,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_permission("repairs.status.update")),
+):
+    db_repair = get_repair_or_404(db, repair_id)
+    return RepairService.update_status(db, db_repair, payload, actor=current_user, request=request)
+
+
+@router.get("/repairs/{repair_id}/history", response_model=list[RepairStatusHistoryResponse])
+def get_repair_history(
+    repair_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(require_permission("repairs.read")),
+):
+    get_repair_or_404(db, repair_id)
+    return RepairRepository.get_history(db, repair_id)
+
+
+@router.post("/public/repair-intake", response_model=RepairIntakeResponse, status_code=status.HTTP_201_CREATED)
+def create_repair_intake(
+    payload: RepairIntakePayload,
+    request: Request,
+    x_olympus_intake_token: str | None = Header(default=None, alias="X-Olympus-Intake-Token"),
+    db: Session = Depends(get_db),
+):
+    expected_token = settings.olympus_repair_intake_token
+    if not expected_token or not x_olympus_intake_token or x_olympus_intake_token != expected_token:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Nicht autorisiert")
+
+    repair = RepairService.create_from_intake(db, payload, request=request)
+    return RepairIntakeResponse(
+        repair_number=repair.repair_number,
+        status=cast(RepairStatus, repair.status),
+        message="Reparaturanfrage übernommen",
+    )