Admin-Portal: Bearbeiten für Bereich/Kategorie/Objekttyp/Standort/Benutzer,

Vorlagen-Versionierung und Objekt-Duplizieren im Frontend nachgerüstet

Backend: PATCH-Endpoints für Bereich/Kategorie/Standort/Objekttyp ergänzt
(analog zu Material), die bislang fehlten und Bearbeiten grundsätzlich
unmöglich machten.

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

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

@@ -9,15 +9,19 @@ from app.models.stammdaten import Bereich, Kategorie, Material, Objekttyp, Stand
 from app.schemas.stammdaten import (
     BereichCreate,
     BereichRead,
+    BereichUpdate,
     KategorieCreate,
     KategorieRead,
+    KategorieUpdate,
     MaterialCreate,
     MaterialRead,
     MaterialUpdate,
     ObjekttypCreate,
     ObjekttypRead,
+    ObjekttypUpdate,
     StandortCreate,
     StandortRead,
+    StandortUpdate,
 )
 
 router = APIRouter()
@@ -45,6 +49,22 @@ async def erstelle_bereich(
     return bereich
 
 
+@router.patch("/bereiche/{bereich_id}", response_model=BereichRead)
+async def aendere_bereich(
+    bereich_id: int,
+    payload: BereichUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Bereich:
+    bereich = await db.get(Bereich, bereich_id)
+    if bereich is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bereich nicht gefunden")
+    for feld, wert in payload.model_dump(exclude_unset=True).items():
+        setattr(bereich, feld, wert)
+    await db.flush()
+    return bereich
+
+
 # -- Kategorie ------------------------------------------------------------------
 
 @router.get("/kategorien", response_model=list[KategorieRead])
@@ -67,6 +87,22 @@ async def erstelle_kategorie(
     return kategorie
 
 
+@router.patch("/kategorien/{kategorie_id}", response_model=KategorieRead)
+async def aendere_kategorie(
+    kategorie_id: int,
+    payload: KategorieUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Kategorie:
+    kategorie = await db.get(Kategorie, kategorie_id)
+    if kategorie is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Kategorie nicht gefunden")
+    for feld, wert in payload.model_dump(exclude_unset=True).items():
+        setattr(kategorie, feld, wert)
+    await db.flush()
+    return kategorie
+
+
 # -- Standort ------------------------------------------------------------------
 
 @router.get("/standorte", response_model=list[StandortRead])
@@ -89,6 +125,22 @@ async def erstelle_standort(
     return standort
 
 
+@router.patch("/standorte/{standort_id}", response_model=StandortRead)
+async def aendere_standort(
+    standort_id: int,
+    payload: StandortUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Standort:
+    standort = await db.get(Standort, standort_id)
+    if standort is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Standort nicht gefunden")
+    for feld, wert in payload.model_dump(exclude_unset=True).items():
+        setattr(standort, feld, wert)
+    await db.flush()
+    return standort
+
+
 # -- Objekttyp ------------------------------------------------------------------
 
 @router.get("/objekttypen", response_model=list[ObjekttypRead])
@@ -111,6 +163,22 @@ async def erstelle_objekttyp(
     return objekttyp
 
 
+@router.patch("/objekttypen/{objekttyp_id}", response_model=ObjekttypRead)
+async def aendere_objekttyp(
+    objekttyp_id: int,
+    payload: ObjekttypUpdate,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(require_roles(RolleTyp.administration)),
+) -> Objekttyp:
+    objekttyp = await db.get(Objekttyp, objekttyp_id)
+    if objekttyp is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Objekttyp nicht gefunden")
+    for feld, wert in payload.model_dump(exclude_unset=True).items():
+        setattr(objekttyp, feld, wert)
+    await db.flush()
+    return objekttyp
+
+
 # -- Material (Prompt 07) --------------------------------------------------
 
 @router.get("/materialien", response_model=list[MaterialRead])

backend/app/schemas/stammdaten.py

@@ -13,6 +13,11 @@ class BereichRead(BereichCreate):
     id: int
 
 
+class BereichUpdate(BaseModel):
+    name: str | None = None
+    beschreibung: str | None = None
+
+
 class KategorieCreate(BaseModel):
     bereich_id: int
     name: str
@@ -24,6 +29,12 @@ class KategorieRead(KategorieCreate):
     id: int
 
 
+class KategorieUpdate(BaseModel):
+    bereich_id: int | None = None
+    name: str | None = None
+    ueberkategorie_id: int | None = None
+
+
 class StandortCreate(BaseModel):
     name: str
     adresse: str | None = None
@@ -34,6 +45,11 @@ class StandortRead(StandortCreate):
     id: int
 
 
+class StandortUpdate(BaseModel):
+    name: str | None = None
+    adresse: str | None = None
+
+
 class ObjekttypCreate(BaseModel):
     bereich_id: int
     kategorie_id: int | None = None
@@ -45,6 +61,12 @@ class ObjekttypRead(ObjekttypCreate):
     id: int
 
 
+class ObjekttypUpdate(BaseModel):
+    bereich_id: int | None = None
+    kategorie_id: int | None = None
+    name: str | None = None
+
+
 class MaterialCreate(BaseModel):
     name: str
     artikelnummer: str | None = None

backend/tests/test_stammdaten.py

@@ -60,3 +60,65 @@ async def test_material_not_found(client, admin_user):
     token = await login(client, "admin1")
     response = await client.get("/api/v1/materialien/999999", headers=auth_header(token))
     assert response.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_admin_can_update_bereich(client, admin_user):
+    token = await login(client, "admin1")
+    erstellt = await client.post("/api/v1/bereiche", json={"name": "Alt"}, headers=auth_header(token))
+    bereich_id = erstellt.json()["id"]
+
+    response = await client.patch(
+        f"/api/v1/bereiche/{bereich_id}", json={"name": "Neu"}, headers=auth_header(token)
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "Neu"
+
+
+@pytest.mark.asyncio
+async def test_admin_can_update_kategorie(client, admin_user):
+    token = await login(client, "admin1")
+    bereich = await client.post("/api/v1/bereiche", json={"name": "B"}, headers=auth_header(token))
+    erstellt = await client.post(
+        "/api/v1/kategorien",
+        json={"bereich_id": bereich.json()["id"], "name": "Alt"},
+        headers=auth_header(token),
+    )
+    kategorie_id = erstellt.json()["id"]
+
+    response = await client.patch(
+        f"/api/v1/kategorien/{kategorie_id}", json={"name": "Neu"}, headers=auth_header(token)
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "Neu"
+
+
+@pytest.mark.asyncio
+async def test_admin_can_update_standort(client, admin_user):
+    token = await login(client, "admin1")
+    erstellt = await client.post("/api/v1/standorte", json={"name": "Alt"}, headers=auth_header(token))
+    standort_id = erstellt.json()["id"]
+
+    response = await client.patch(
+        f"/api/v1/standorte/{standort_id}", json={"name": "Neu"}, headers=auth_header(token)
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "Neu"
+
+
+@pytest.mark.asyncio
+async def test_admin_can_update_objekttyp(client, admin_user):
+    token = await login(client, "admin1")
+    bereich = await client.post("/api/v1/bereiche", json={"name": "B"}, headers=auth_header(token))
+    erstellt = await client.post(
+        "/api/v1/objekttypen",
+        json={"bereich_id": bereich.json()["id"], "name": "Alt"},
+        headers=auth_header(token),
+    )
+    objekttyp_id = erstellt.json()["id"]
+
+    response = await client.patch(
+        f"/api/v1/objekttypen/{objekttyp_id}", json={"name": "Neu"}, headers=auth_header(token)
+    )
+    assert response.status_code == 200
+    assert response.json()["name"] == "Neu"