Sprint 1: Stammdaten-Modelle/-Endpunkte, Admin-Benutzerverwaltung, Zuständigkeits-Vererbung (E2)

- ORM-Modelle: Bereich, Kategorie, Standort, Objekttyp, Material (Prompt 06/07),
  minimales Objekt-Modell (voll ausgebaut erst Sprint 2), Zustaendigkeit/
  Kontrollverantwortung
- Admin-API 7a: GET/POST Stammdaten-Endpunkte, PATCH Material, Benutzerverwaltung
  (anlegen/Rollen ändern), Zuständigkeits-/Kontrollverantwortungs-CRUD
- Vererbungslogik E2 als eigener Service (app/services/zustaendigkeit.py):
  Standort-Zuordnung vererbt sich auf alle Objekte, Objekt-Zeile ist Vereinigung
  statt Ersatz - GET /zustaendigkeiten/benutzer/{id}/objekte exponiert das
- Tests: Stammdaten-CRUD + Rollenrechte, Benutzerverwaltung (inkl. 409 bei
  Login-Duplikat), E2-Vererbungslogik (Standort-only, Standort+Objekt-Vereinigung,
  End-to-End über den Endpunkt)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L85hmKbvX7Cqkq47KnQhFt

backend/app/api/v1/api.py

@@ -1,7 +1,10 @@
 from fastapi import APIRouter
 
-from app.api.v1.endpoints import auth, health
+from app.api.v1.endpoints import auth, benutzer, health, stammdaten, zustaendigkeit
 
 api_router = APIRouter()
 api_router.include_router(health.router, tags=["health"])
 api_router.include_router(auth.router, tags=["auth"])
+api_router.include_router(stammdaten.router, tags=["stammdaten"])
+api_router.include_router(benutzer.router, tags=["benutzer"])
+api_router.include_router(zustaendigkeit.router, tags=["zustaendigkeit"])

backend/app/api/v1/endpoints/benutzer.py

@@ -0,0 +1,70 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import require_roles
+from app.core.security import hash_password
+from app.db.session import get_db
+from app.models.auth import Benutzer, BenutzerRolle, RolleTyp
+from app.schemas.benutzer import BenutzerCreate, BenutzerRead, BenutzerUpdate
+
+router = APIRouter()
+
+_admin_only = require_roles(RolleTyp.administration)
+
+
+@router.get("/benutzer", response_model=list[BenutzerRead])
+async def liste_benutzer(db: AsyncSession = Depends(get_db), _=Depends(_admin_only)) -> list[BenutzerRead]:
+    result = await db.execute(select(Benutzer))
+    return [BenutzerRead.from_orm_benutzer(b) for b in result.scalars().all()]
+
+
+@router.post("/benutzer", response_model=BenutzerRead, status_code=status.HTTP_201_CREATED)
+async def erstelle_benutzer(
+    payload: BenutzerCreate, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
+) -> BenutzerRead:
+    result = await db.execute(select(Benutzer).where(Benutzer.login == payload.login))
+    if result.scalar_one_or_none() is not None:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Login bereits vergeben")
+
+    benutzer = Benutzer(
+        name=payload.name,
+        login=payload.login,
+        passwort_hash=hash_password(payload.passwort),
+        aktiv=True,
+    )
+    db.add(benutzer)
+    await db.flush()
+    for rolle in payload.rollen:
+        db.add(BenutzerRolle(benutzer_id=benutzer.id, rolle=rolle))
+    await db.flush()
+    await db.refresh(benutzer, attribute_names=["rollen"])
+    return BenutzerRead.from_orm_benutzer(benutzer)
+
+
+@router.patch("/benutzer/{benutzer_id}", response_model=BenutzerRead)
+async def aendere_benutzer(
+    benutzer_id: int,
+    payload: BenutzerUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(_admin_only),
+) -> BenutzerRead:
+    benutzer = await db.get(Benutzer, benutzer_id)
+    if benutzer is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Benutzer nicht gefunden")
+
+    if payload.name is not None:
+        benutzer.name = payload.name
+    if payload.aktiv is not None:
+        benutzer.aktiv = payload.aktiv
+    if payload.rollen is not None:
+        result = await db.execute(select(BenutzerRolle).where(BenutzerRolle.benutzer_id == benutzer_id))
+        for bestehende in result.scalars().all():
+            await db.delete(bestehende)
+        await db.flush()
+        for rolle in payload.rollen:
+            db.add(BenutzerRolle(benutzer_id=benutzer_id, rolle=rolle))
+
+    await db.flush()
+    await db.refresh(benutzer, attribute_names=["rollen"])
+    return BenutzerRead.from_orm_benutzer(benutzer)

backend/app/api/v1/endpoints/stammdaten.py

@@ -0,0 +1,161 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_current_user, require_roles
+from app.db.session import get_db
+from app.models.auth import RolleTyp
+from app.models.stammdaten import Bereich, Kategorie, Material, Objekttyp, Standort
+from app.schemas.stammdaten import (
+    BereichCreate,
+    BereichRead,
+    KategorieCreate,
+    KategorieRead,
+    MaterialCreate,
+    MaterialRead,
+    MaterialUpdate,
+    ObjekttypCreate,
+    ObjekttypRead,
+    StandortCreate,
+    StandortRead,
+)
+
+router = APIRouter()
+
+
+# -- Bereich ------------------------------------------------------------------
+
+@router.get("/bereiche", response_model=list[BereichRead])
+async def liste_bereiche(
+    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
+) -> list[Bereich]:
+    result = await db.execute(select(Bereich))
+    return list(result.scalars().all())
+
+
+@router.post("/bereiche", response_model=BereichRead, status_code=status.HTTP_201_CREATED)
+async def erstelle_bereich(
+    payload: BereichCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Bereich:
+    bereich = Bereich(**payload.model_dump())
+    db.add(bereich)
+    await db.flush()
+    return bereich
+
+
+# -- Kategorie ------------------------------------------------------------------
+
+@router.get("/kategorien", response_model=list[KategorieRead])
+async def liste_kategorien(
+    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
+) -> list[Kategorie]:
+    result = await db.execute(select(Kategorie))
+    return list(result.scalars().all())
+
+
+@router.post("/kategorien", response_model=KategorieRead, status_code=status.HTTP_201_CREATED)
+async def erstelle_kategorie(
+    payload: KategorieCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Kategorie:
+    kategorie = Kategorie(**payload.model_dump())
+    db.add(kategorie)
+    await db.flush()
+    return kategorie
+
+
+# -- Standort ------------------------------------------------------------------
+
+@router.get("/standorte", response_model=list[StandortRead])
+async def liste_standorte(
+    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
+) -> list[Standort]:
+    result = await db.execute(select(Standort))
+    return list(result.scalars().all())
+
+
+@router.post("/standorte", response_model=StandortRead, status_code=status.HTTP_201_CREATED)
+async def erstelle_standort(
+    payload: StandortCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Standort:
+    standort = Standort(**payload.model_dump())
+    db.add(standort)
+    await db.flush()
+    return standort
+
+
+# -- Objekttyp ------------------------------------------------------------------
+
+@router.get("/objekttypen", response_model=list[ObjekttypRead])
+async def liste_objekttypen(
+    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
+) -> list[Objekttyp]:
+    result = await db.execute(select(Objekttyp))
+    return list(result.scalars().all())
+
+
+@router.post("/objekttypen", response_model=ObjekttypRead, status_code=status.HTTP_201_CREATED)
+async def erstelle_objekttyp(
+    payload: ObjekttypCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Objekttyp:
+    objekttyp = Objekttyp(**payload.model_dump())
+    db.add(objekttyp)
+    await db.flush()
+    return objekttyp
+
+
+# -- Material (Prompt 07) --------------------------------------------------
+
+@router.get("/materialien", response_model=list[MaterialRead])
+async def liste_materialien(
+    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
+) -> list[Material]:
+    result = await db.execute(select(Material))
+    return list(result.scalars().all())
+
+
+@router.get("/materialien/{material_id}", response_model=MaterialRead)
+async def hole_material(
+    material_id: int,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+) -> Material:
+    material = await db.get(Material, material_id)
+    if material is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Material nicht gefunden")
+    return material
+
+
+@router.post("/materialien", response_model=MaterialRead, status_code=status.HTTP_201_CREATED)
+async def erstelle_material(
+    payload: MaterialCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Material:
+    material = Material(**payload.model_dump())
+    db.add(material)
+    await db.flush()
+    return material
+
+
+@router.patch("/materialien/{material_id}", response_model=MaterialRead)
+async def aendere_material(
+    material_id: int,
+    payload: MaterialUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Material:
+    material = await db.get(Material, material_id)
+    if material is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Material nicht gefunden")
+    for feld, wert in payload.model_dump(exclude_unset=True).items():
+        setattr(material, feld, wert)
+    await db.flush()
+    return material

backend/app/api/v1/endpoints/zustaendigkeit.py

@@ -0,0 +1,89 @@
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import require_roles
+from app.db.session import get_db
+from app.models.auth import RolleTyp
+from app.models.zustaendigkeit import Kontrollverantwortung, Zustaendigkeit
+from app.schemas.zustaendigkeit import (
+    KontrollverantwortungCreate,
+    KontrollverantwortungRead,
+    ObjektKurz,
+    ZustaendigkeitCreate,
+    ZustaendigkeitRead,
+)
+from app.services.zustaendigkeit import zustaendige_objekte
+
+router = APIRouter()
+
+_admin_only = require_roles(RolleTyp.administration)
+_verantwortliche = require_roles(
+    RolleTyp.administration, RolleTyp.materialverantwortlicher, RolleTyp.leitungsverantwortlicher
+)
+
+
+@router.get("/zustaendigkeiten", response_model=list[ZustaendigkeitRead])
+async def liste_zustaendigkeiten(
+    db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
+) -> list[Zustaendigkeit]:
+    result = await db.execute(select(Zustaendigkeit))
+    return list(result.scalars().all())
+
+
+@router.post(
+    "/zustaendigkeiten", response_model=ZustaendigkeitRead, status_code=status.HTTP_201_CREATED
+)
+async def erstelle_zustaendigkeit(
+    payload: ZustaendigkeitCreate, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
+) -> Zustaendigkeit:
+    zustaendigkeit = Zustaendigkeit(**payload.model_dump())
+    db.add(zustaendigkeit)
+    await db.flush()
+    return zustaendigkeit
+
+
+@router.delete("/zustaendigkeiten/{zustaendigkeit_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def loesche_zustaendigkeit(
+    zustaendigkeit_id: uuid.UUID, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
+) -> None:
+    zustaendigkeit = await db.get(Zustaendigkeit, zustaendigkeit_id)
+    if zustaendigkeit is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Zuständigkeit nicht gefunden")
+    await db.delete(zustaendigkeit)
+
+
+@router.get("/zustaendigkeiten/benutzer/{benutzer_id}/objekte", response_model=list[ObjektKurz])
+async def objekte_eines_verantwortlichen(
+    benutzer_id: int, db: AsyncSession = Depends(get_db), _=Depends(_verantwortliche)
+) -> list[ObjektKurz]:
+    """Vererbungslogik E2: Standort-Zuordnung + Objekt-Zuordnung als Vereinigung."""
+    objekte = await zustaendige_objekte(db, benutzer_id)
+    return [ObjektKurz.model_validate(o) for o in objekte]
+
+
+@router.get("/kontrollverantwortung", response_model=list[KontrollverantwortungRead])
+async def liste_kontrollverantwortung(
+    db: AsyncSession = Depends(get_db), _=Depends(_verantwortliche)
+) -> list[Kontrollverantwortung]:
+    result = await db.execute(select(Kontrollverantwortung))
+    return list(result.scalars().all())
+
+
+@router.post(
+    "/kontrollverantwortung",
+    response_model=KontrollverantwortungRead,
+    status_code=status.HTTP_201_CREATED,
+)
+async def erstelle_kontrollverantwortung(
+    payload: KontrollverantwortungCreate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(_verantwortliche),
+) -> Kontrollverantwortung:
+    """Karte 01 / E3: reine Sichtbarkeit/Priorisierung, erzwingt keine Pflichtkontrolle."""
+    kontrollverantwortung = Kontrollverantwortung(**payload.model_dump())
+    db.add(kontrollverantwortung)
+    await db.flush()
+    return kontrollverantwortung