feat(personal): PERS-001/002 Person fachlich von Benutzer getrennt

Neue Tabelle person (Migration 0034, Backfill bestehender Benutzer 1:1
per Zeilennummer, keine Datenverluste). Benutzer.person_id optional -
Login kann bestehende Person verknüpfen oder legt automatisch eine neue
an (Rückwärtskompatibilität zum bisherigen Anlegen-Flow). /personen-CRUD
(admin-only), neue PersonSection.tsx im Personal-Tab, BenutzerSection
um Personen-Auswahl erweitert.

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

DEVLOG.md

@@ -11347,3 +11347,99 @@ Keine Commits in dieser Session.
 - frontend/src/pages/admin/ObjekttypSection.tsx      | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------
 
 ---
+## 2026-09-08 22:05 – 22:06 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** frontend
+
+### Commits
+- 847c303 feat(wartung): MAINT-005 Ersatzteile/Kosten je Wartungsauftrag
+
+### Geänderte Dateien
+- .claude/agents/DEVLOG.md                              |   11 +
+- DEVLOG.md                                             | 4565 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- arbeitskacheln/00_index.md                            |   11 +-
+- arbeitskacheln/22_ui_redesign_v2.md                   |  107 +++
+- backend/DEVLOG.md                                     |   50 +
+- backend/alembic/versions/0033_wartungsauftrag_teil.py |   33 +
+- backend/app/api/v1/endpoints/wartung.py               |   49 +-
+- backend/app/models/wartung.py                         |   10 +
+- backend/app/schemas/wartung.py                        |   15 +
+- backend/app/services/wartung.py                       |   22 +
+- backend/tests/test_wartung.py                         |   70 ++
+- frontend/DEVLOG.md                                    |  176 ++++
+- frontend/src/api/types.ts                             |    8 +
+- frontend/src/components/WartungSection.tsx            |  111 ++-
+
+---
+## 2026-09-08 22:06 – 22:06 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** asb-material
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .claude/agents/DEVLOG.md                              |   11 +
+- DEVLOG.md                                             | 4565 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- arbeitskacheln/00_index.md                            |   11 +-
+- arbeitskacheln/22_ui_redesign_v2.md                   |  107 +++
+- backend/DEVLOG.md                                     |   50 +
+- backend/alembic/versions/0033_wartungsauftrag_teil.py |   33 +
+- backend/app/api/v1/endpoints/wartung.py               |   49 +-
+- backend/app/models/wartung.py                         |   10 +
+- backend/app/schemas/wartung.py                        |   15 +
+- backend/app/services/wartung.py                       |   22 +
+- backend/tests/test_wartung.py                         |   70 ++
+- frontend/DEVLOG.md                                    |  176 ++++
+- frontend/src/api/types.ts                             |    8 +
+- frontend/src/components/WartungSection.tsx            |  111 ++-
+
+---
+## 2026-09-08 22:13 – 22:13 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** asb-material
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .claude/agents/DEVLOG.md                              |   11 +
+- DEVLOG.md                                             | 4565 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- arbeitskacheln/00_index.md                            |   11 +-
+- arbeitskacheln/22_ui_redesign_v2.md                   |  107 +++
+- backend/DEVLOG.md                                     |   50 +
+- backend/alembic/versions/0033_wartungsauftrag_teil.py |   33 +
+- backend/app/api/v1/endpoints/wartung.py               |   49 +-
+- backend/app/models/wartung.py                         |   10 +
+- backend/app/schemas/wartung.py                        |   15 +
+- backend/app/services/wartung.py                       |   22 +
+- backend/tests/test_wartung.py                         |   70 ++
+- frontend/DEVLOG.md                                    |  176 ++++
+- frontend/src/api/types.ts                             |    8 +
+- frontend/src/components/WartungSection.tsx            |  111 ++-
+
+---
+## 2026-09-08 22:13 – 22:24 (10m)
+**Beschreibung:** Claude Code Session
+**Projekt:** asb-material
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .claude/agents/DEVLOG.md                              |   11 +
+- DEVLOG.md                                             | 4565 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- arbeitskacheln/00_index.md                            |   11 +-
+- arbeitskacheln/22_ui_redesign_v2.md                   |  107 +++
+- backend/DEVLOG.md                                     |   50 +
+- backend/alembic/versions/0033_wartungsauftrag_teil.py |   33 +
+- backend/app/api/v1/endpoints/wartung.py               |   49 +-
+- backend/app/models/wartung.py                         |   10 +
+- backend/app/schemas/wartung.py                        |   15 +
+- backend/app/services/wartung.py                       |   22 +
+- backend/tests/test_wartung.py                         |   70 ++
+- frontend/DEVLOG.md                                    |  176 ++++
+- frontend/src/api/types.ts                             |    8 +
+- frontend/src/components/WartungSection.tsx            |  111 ++-
+
+---

arbeitskacheln/00_index.md

@@ -202,8 +202,8 @@ vergeben statt geraten.
 | DEFECT-003 | Defects | Verantwortlicher & Reparaturzuordnung | P1 | S | LOW | DEFECT-002, PERS-002 | ✅ (Zustaendigkeit/Kontrollverantwortung koppelt an Mangel-Objekt) |
 | DEFECT-004 | Defects | Abschluss & Dokumentation | P1 | S | LOW | DEFECT-003 | ✅ (`PATCH /maengel/{id}` Statuswechsel inkl. Abschluss) |
 | DEFECT-005 | Defects | Readiness-Einfluss (kritisch) | P1 | S | MEDIUM | DEFECT-002, READY-001 | ✅ (`services/mangel.py`: Priorität "hoch" macht Objekt "nicht einsatzbereit") |
-| PERS-001 | Personnel | Person (fachlich) | P1 | M | HIGH | FOUND-002 | ⬜ (laut DECISION-Abschnitt der Datei selbst nicht getrennt, nur `Benutzer`) |
-| PERS-002 | Personnel | Benutzer (technisch, verknüpft) | P0 | M | HIGH | PERS-001, FOUND-003 | ✅ (`Benutzer`-Modell, `benutzer.py`-Endpunkt) |
+| PERS-001 | Personnel | Person (fachlich) | P1 | M | HIGH | FOUND-002 | ✅ (`Person`-Modell, Migration 0034 mit Backfill bestehender Benutzer, `/personen`-CRUD, Admin-UI `PersonSection.tsx`) |
+| PERS-002 | Personnel | Benutzer (technisch, verknüpft) | P0 | M | HIGH | PERS-001, FOUND-003 | ✅ (`Benutzer.person_id` FK, `/benutzer` verknüpft bestehende oder legt automatisch neue Person an) |
 | PERS-003 | Personnel | Einheiten/Organisationsstruktur | P1 | S | LOW | PERS-001 | ✅ (`Einheit`-Modell, hierarchisch, `einheiten`-Endpunkt) |
 | PERS-004 | Personnel | Funktionen/Rollen im Einsatzkontext | P2 | S | LOW | PERS-003 | ✅ (`Einsatzfunktion`-Stammdaten, Migration 0031, `benutzer.einsatzfunktion_id`, Admin-UI in BenutzerSection) |
 | PERS-005 | Personnel | Qualifikationen/Lehrgänge | P1 | S | LOW | PERS-001 | ✅ (`Qualifikationstyp`, `BenutzerQualifikation`) |

backend/alembic/versions/0034_person.py

@@ -0,0 +1,58 @@
+"""PERS-001/002: Person fachlich getrennt von Benutzer (Login), Backfill bestehender Benutzer.
+
+Revision ID: 0034_person
+Revises: 0033_wartungsauftrag_teil
+Create Date: 2026-09-08
+"""
+from typing import Sequence, Union
+
+from alembic import op
+
+revision: str = "0034_person"
+down_revision: Union[str, None] = "0033_wartungsauftrag_teil"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.execute(
+        """
+        CREATE TABLE person (
+            id SERIAL PRIMARY KEY,
+            name TEXT NOT NULL,
+            geburtsdatum DATE,
+            kontakt TEXT
+        )
+        """
+    )
+    op.execute("ALTER TABLE benutzer ADD COLUMN person_id INTEGER REFERENCES person(id)")
+    op.execute("CREATE INDEX ix_benutzer_person_id ON benutzer (person_id)")
+
+    # Backfill: jeder bestehende Benutzer bekommt eine EIGENE Person mit gleichem
+    # Namen (1:1 per Zeilennummer statt Namensvergleich, sonst würden Benutzer
+    # mit identischem Namen fälschlich derselben Person zugeordnet).
+    op.execute(
+        """
+        INSERT INTO person (name)
+        SELECT name FROM benutzer ORDER BY id
+        """
+    )
+    op.execute(
+        """
+        WITH benutzer_rang AS (
+            SELECT id, ROW_NUMBER() OVER (ORDER BY id) AS rang FROM benutzer
+        ), person_rang AS (
+            SELECT id, ROW_NUMBER() OVER (ORDER BY id) AS rang FROM person
+        )
+        UPDATE benutzer
+        SET person_id = person_rang.id
+        FROM benutzer_rang
+        JOIN person_rang ON person_rang.rang = benutzer_rang.rang
+        WHERE benutzer.id = benutzer_rang.id
+        """
+    )
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE benutzer DROP COLUMN person_id")
+    op.execute("DROP TABLE person")

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

@@ -6,6 +6,7 @@ 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.models.personal import Person
 from app.schemas.benutzer import BenutzerCreate, BenutzerRead, BenutzerUpdate
 
 router = APIRouter()
@@ -31,6 +32,19 @@ async def erstelle_benutzer(
     if result.scalar_one_or_none() is not None:
         raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Login bereits vergeben")
 
+    person_id = payload.person_id
+    if person_id is not None:
+        if await db.get(Person, person_id) is None:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Person nicht gefunden")
+    else:
+        # PERS-002: kein bestehender Person-Datensatz gewählt -> automatisch
+        # anlegen, damit jeder Benutzer weiterhin ohne Zusatzschritt eine
+        # verknüpfte Person hat (Rückwärtskompatibilität zum bisherigen Flow).
+        person = Person(name=payload.name)
+        db.add(person)
+        await db.flush()
+        person_id = person.id
+
     benutzer = Benutzer(
         name=payload.name,
         login=payload.login,
@@ -39,6 +53,7 @@ async def erstelle_benutzer(
         aktiv=True,
         einheit_id=payload.einheit_id,
         einsatzfunktion_id=payload.einsatzfunktion_id,
+        person_id=person_id,
     )
     db.add(benutzer)
     await db.flush()

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

@@ -11,6 +11,7 @@ from app.models.personal import (
     Einheit,
     Einsatzfunktion,
     ObjekttypQualifikationsanforderung,
+    Person,
     Qualifikationstyp,
 )
 from app.schemas.personal import (
@@ -24,12 +25,15 @@ from app.schemas.personal import (
     EinsatzfunktionRead,
     ObjekttypQualifikationsanforderungCreate,
     ObjekttypQualifikationsanforderungRead,
+    PersonCreate,
+    PersonRead,
+    PersonUpdate,
     QualifikationstypCreate,
     QualifikationstypRead,
     QualifikationstypUpdate,
 )
 from app.services import historie as historie_service
-from app.services.personal import pruefe_berechtigung
+from app.services.personal import erstelle_person, liste_personen, pruefe_berechtigung
 
 router = APIRouter()
 
@@ -41,6 +45,39 @@ async def _hauptserver_id(db: AsyncSession) -> int:
 _admin_only = require_roles(RolleTyp.administration)
 
 
+# -- Person (PERS-001) ---------------------------------------------------------
+
+@router.get("/personen", response_model=list[PersonRead])
+async def liste_personen_endpunkt(db: AsyncSession = Depends(get_db), _=Depends(_admin_only)) -> list[Person]:
+    return await liste_personen(db)
+
+
+@router.post("/personen", response_model=PersonRead, status_code=status.HTTP_201_CREATED)
+async def erstelle_person_endpunkt(
+    payload: PersonCreate, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
+) -> Person:
+    return await erstelle_person(
+        db, name=payload.name, geburtsdatum=payload.geburtsdatum, kontakt=payload.kontakt
+    )
+
+
+@router.patch("/personen/{person_id}", response_model=PersonRead)
+async def aendere_person(
+    person_id: int, payload: PersonUpdate, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
+) -> Person:
+    person = await db.get(Person, person_id)
+    if person is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Person nicht gefunden")
+    if payload.name is not None:
+        person.name = payload.name
+    if "geburtsdatum" in payload.model_fields_set:
+        person.geburtsdatum = payload.geburtsdatum
+    if "kontakt" in payload.model_fields_set:
+        person.kontakt = payload.kontakt
+    await db.flush()
+    return person
+
+
 # -- Einheit ------------------------------------------------------------------
 
 @router.get("/einheiten", response_model=list[EinheitRead])

backend/app/models/auth.py

@@ -47,6 +47,11 @@ class Benutzer(Base):
     einheit_id: Mapped[int | None] = mapped_column(ForeignKey("einheit.id"))  # Personal-Modul (Migration 0012)
     # PERS-004: primäre Funktion im Einsatzkontext, optional.
     einsatzfunktion_id: Mapped[int | None] = mapped_column(ForeignKey("einsatzfunktion.id"))
+    # PERS-002: Verknüpfung zum fachlichen Person-Datensatz. Bestehende Benutzer
+    # wurden per Migration 0034 rückwirkend mit einer Person verknüpft, bleibt
+    # aber nullable - ein Login ohne fachliche Person(Übergang) wäre sonst nicht
+    # anlegbar, wenn die Migration künftig übersprungen wird.
+    person_id: Mapped[int | None] = mapped_column(ForeignKey("person.id"))
 
     rollen: Mapped[list["BenutzerRolle"]] = relationship(back_populates="benutzer", lazy="selectin")
 

backend/app/models/personal.py

@@ -20,6 +20,19 @@ qualifikationskategorie_pg = PgEnum(
 )
 
 
+class Person(Base):
+    """PERS-001: fachliches Konzept einer Person, getrennt vom technischen Login
+    (Benutzer). Kann ohne Benutzerkonto existieren (z.B. Jugendgruppe, externe
+    Helfer ohne Systemzugang) - Benutzer.person_id verweist optional hierher."""
+
+    __tablename__ = "person"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String, nullable=False)
+    geburtsdatum: Mapped[date | None] = mapped_column(Date)
+    kontakt: Mapped[str | None] = mapped_column(String)
+
+
 class Einheit(Base):
     """Roadmap-Erweiterung (Personal-Modul): Organisationseinheit (Zug/Gruppe),
     self-referenzierend für Hierarchie (analog Kategorie.ueberkategorie_id).

backend/app/schemas/benutzer.py

@@ -11,6 +11,10 @@ class BenutzerCreate(BaseModel):
     rollen: list[RolleTyp] = []
     einheit_id: int | None = None
     einsatzfunktion_id: int | None = None
+    # PERS-002: bestehende Person verknüpfen statt automatisch eine neue anzulegen
+    # (z.B. wenn eine bereits erfasste Person - Jugendgruppe o.ä. - nachträglich
+    # einen Login bekommt).
+    person_id: int | None = None
 
 
 class BenutzerRead(BaseModel):
@@ -23,6 +27,7 @@ class BenutzerRead(BaseModel):
     rollen: list[str]
     einheit_id: int | None
     einsatzfunktion_id: int | None
+    person_id: int | None
 
     @classmethod
     def from_orm_benutzer(cls, benutzer) -> "BenutzerRead":
@@ -35,6 +40,7 @@ class BenutzerRead(BaseModel):
             rollen=benutzer.rollen_namen,
             einheit_id=benutzer.einheit_id,
             einsatzfunktion_id=benutzer.einsatzfunktion_id,
+            person_id=benutzer.person_id,
         )
 
 

backend/app/schemas/personal.py

@@ -6,6 +6,26 @@ from pydantic import BaseModel, ConfigDict
 from app.models.personal import Qualifikationskategorie
 
 
+class PersonCreate(BaseModel):
+    name: str
+    geburtsdatum: date | None = None
+    kontakt: str | None = None
+
+
+class PersonRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    id: int
+    name: str
+    geburtsdatum: date | None
+    kontakt: str | None
+
+
+class PersonUpdate(BaseModel):
+    name: str | None = None
+    geburtsdatum: date | None = None
+    kontakt: str | None = None
+
+
 class EinheitCreate(BaseModel):
     name: str
     uebergeordnete_einheit_id: int | None = None

backend/app/services/personal.py

@@ -7,10 +7,23 @@ from app.models.objekt import Objekt
 from app.models.personal import (
     BenutzerQualifikation,
     ObjekttypQualifikationsanforderung,
+    Person,
     Qualifikationstyp,
 )
 
 
+async def erstelle_person(db: AsyncSession, *, name: str, geburtsdatum, kontakt: str | None) -> Person:
+    person = Person(name=name, geburtsdatum=geburtsdatum, kontakt=kontakt)
+    db.add(person)
+    await db.flush()
+    return person
+
+
+async def liste_personen(db: AsyncSession) -> list[Person]:
+    result = await db.execute(select(Person))
+    return list(result.scalars().all())
+
+
 async def pruefe_berechtigung(db: AsyncSession, *, benutzer_id: int, objekt_id: int) -> list[Qualifikationstyp]:
     """Nutzer-Beispiel Personal-Modul: "wer darf dieses Fahrzeug fahren?".
     Liefert die Qualifikationstypen, die der Objekttyp verlangt, aber der

backend/tests/test_personal.py

@@ -243,6 +243,95 @@ async def test_unbefristete_qualifikation_erscheint_nicht_im_dashboard(client, a
     assert response.json() == []
 
 
+@pytest.mark.asyncio
+async def test_person_ohne_benutzer_anlegbar(client, admin_user):
+    """PERS-001: Person kann ohne jeden Systemzugang existieren (z.B. Jugendgruppe)."""
+    token = await login(client, "admin1")
+    person = await client.post(
+        "/api/v1/personen",
+        json={"name": "Max Mustermann (Jugendgruppe)", "geburtsdatum": "2012-04-01"},
+        headers=auth_header(token),
+    )
+    assert person.status_code == 201
+    body = person.json()
+    assert body["name"] == "Max Mustermann (Jugendgruppe)"
+    assert body["geburtsdatum"] == "2012-04-01"
+
+    liste = await client.get("/api/v1/personen", headers=auth_header(token))
+    assert any(p["id"] == body["id"] for p in liste.json())
+
+    geaendert = await client.patch(
+        f"/api/v1/personen/{body['id']}", json={"kontakt": "Erziehungsberechtigter: 0170..."}, headers=auth_header(token)
+    )
+    assert geaendert.json()["kontakt"] == "Erziehungsberechtigter: 0170..."
+
+
+@pytest.mark.asyncio
+async def test_mitarbeiter_darf_person_nicht_anlegen(client, mitarbeiter_user):
+    token = await login(client, "mitarbeiter1")
+    response = await client.post("/api/v1/personen", json={"name": "Jemand"}, headers=auth_header(token))
+    assert response.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_benutzer_bekommt_automatisch_verknuepfte_person(client, admin_user):
+    """PERS-002: bestehender Flow (Benutzer ohne explizite person_id anlegen)
+    bleibt unverändert - Person wird automatisch mitangelegt."""
+    token = await login(client, "admin1")
+    benutzer = await client.post(
+        "/api/v1/benutzer",
+        json={"name": "Auto-Person Helfer", "login": "autoperson1", "passwort": "test-passwort-123"},
+        headers=auth_header(token),
+    )
+    assert benutzer.status_code == 201
+    person_id = benutzer.json()["person_id"]
+    assert person_id is not None
+
+    personen = await client.get("/api/v1/personen", headers=auth_header(token))
+    assert any(p["id"] == person_id and p["name"] == "Auto-Person Helfer" for p in personen.json())
+
+
+@pytest.mark.asyncio
+async def test_benutzer_mit_bestehender_person_verknuepfen(client, admin_user):
+    """PERS-002: bereits erfasste Person (z.B. aus der Jugendgruppe) bekommt
+    nachträglich einen Login, ohne dass eine zweite Person entsteht."""
+    token = await login(client, "admin1")
+    person = await client.post("/api/v1/personen", json={"name": "Bestehende Person"}, headers=auth_header(token))
+    person_id = person.json()["id"]
+
+    benutzer = await client.post(
+        "/api/v1/benutzer",
+        json={
+            "name": "Bestehende Person",
+            "login": "bestehendeperson1",
+            "passwort": "test-passwort-123",
+            "person_id": person_id,
+        },
+        headers=auth_header(token),
+    )
+    assert benutzer.status_code == 201
+    assert benutzer.json()["person_id"] == person_id
+
+    personen = await client.get("/api/v1/personen", headers=auth_header(token))
+    assert len([p for p in personen.json() if p["id"] == person_id]) == 1
+
+
+@pytest.mark.asyncio
+async def test_benutzer_mit_unbekannter_person_id_abgelehnt(client, admin_user):
+    token = await login(client, "admin1")
+    response = await client.post(
+        "/api/v1/benutzer",
+        json={
+            "name": "X",
+            "login": "unbekanntperson1",
+            "passwort": "test-passwort-123",
+            "person_id": 999999,
+        },
+        headers=auth_header(token),
+    )
+    assert response.status_code == 404
+
+
 @pytest.mark.asyncio
 async def test_qualifikation_erfassen_steht_in_historie(client, admin_user, mitarbeiter_user):
     from datetime import date

frontend/DEVLOG.md

@@ -803,3 +803,27 @@ Keine Commits in dieser Session.
 - frontend/src/pages/admin/ObjekttypSection.tsx      | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------
 
 ---
+## 2026-09-08 22:25 – 22:30 (5m)
+**Beschreibung:** Claude Code Session
+**Projekt:** asb-material
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .claude/agents/DEVLOG.md                              |   11 +
+- DEVLOG.md                                             | 4565 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- arbeitskacheln/00_index.md                            |   11 +-
+- arbeitskacheln/22_ui_redesign_v2.md                   |  107 +++
+- backend/DEVLOG.md                                     |   50 +
+- backend/alembic/versions/0033_wartungsauftrag_teil.py |   33 +
+- backend/app/api/v1/endpoints/wartung.py               |   49 +-
+- backend/app/models/wartung.py                         |   10 +
+- backend/app/schemas/wartung.py                        |   15 +
+- backend/app/services/wartung.py                       |   22 +
+- backend/tests/test_wartung.py                         |   70 ++
+- frontend/DEVLOG.md                                    |  176 ++++
+- frontend/src/api/types.ts                             |    8 +
+- frontend/src/components/WartungSection.tsx            |  111 ++-
+
+---

frontend/src/api/types.ts

@@ -408,6 +408,14 @@ export interface Benutzer {
   rollen: string[];
   einheit_id: number | null;
   einsatzfunktion_id: number | null;
+  person_id: number | null;
+}
+
+export interface Person {
+  id: number;
+  name: string;
+  geburtsdatum: string | null;
+  kontakt: string | null;
 }
 
 export interface Einsatzfunktion {

frontend/src/pages/AdminPage.tsx

@@ -4,7 +4,7 @@ import { useSearchParams } from "react-router-dom";
 import { apiRequest } from "../api/client";
 import { AusgabeSection } from "./admin/AusgabeSection";
 import { useAuth } from "../auth/AuthContext";
-import type { Benutzer, Bereich, Beladungsvorlage, Einheit, Einsatzfunktion, Fach, Kategorie, Material, Nummernschema, Objekt, Objekttyp, Qualifikationstyp, Standort } from "../api/types";
+import type { Benutzer, Bereich, Beladungsvorlage, Einheit, Einsatzfunktion, Fach, Kategorie, Material, Nummernschema, Objekt, Objekttyp, Person, Qualifikationstyp, Standort } from "../api/types";
 import { BenutzerSection } from "./admin/BenutzerSection";
 import { BereichSection } from "./admin/BereichSection";
 import { EinheitSection } from "./admin/EinheitSection";
@@ -19,6 +19,7 @@ import { KontrollverantwortungSection } from "./admin/KontrollverantwortungSecti
 import { MaterialSection } from "./admin/MaterialSection";
 import { ObjektSection } from "./admin/ObjektSection";
 import { ObjekttypSection } from "./admin/ObjekttypSection";
+import { PersonSection } from "./admin/PersonSection";
 import { QualifikationSection } from "./admin/QualifikationSection";
 import { StandortSection } from "./admin/StandortSection";
 import { VorlageSection } from "./admin/VorlageSection";
@@ -110,6 +111,7 @@ export function AdminPage() {
   const [einheiten, setEinheiten] = useState<Einheit[]>([]);
   const [einsatzfunktionen, setEinsatzfunktionen] = useState<Einsatzfunktion[]>([]);
   const [nummernschemata, setNummernschemata] = useState<Nummernschema[]>([]);
+  const [personen, setPersonen] = useState<Person[]>([]);
   const [qualifikationstypen, setQualifikationstypen] = useState<Qualifikationstyp[]>([]);
   const [fehler, setFehler] = useState<string | null>(null);
   const [laedt, setLaedt] = useState(true);
@@ -129,7 +131,7 @@ export function AdminPage() {
     // Seite als "nicht geladen" zeigen, obwohl deren Tabs (z.B. Kontroll-
     // verantwortung) trotzdem funktionieren sollen. allSettled + leerer
     // Fallback statt hartem Fehler.
-    const [be, ka, ot, s, v, o, m, b, f, ei, qt, ef, ns] = await Promise.allSettled([
+    const [be, ka, ot, s, v, o, m, b, f, ei, qt, ef, ns, pe] = await Promise.allSettled([
       apiRequest<Bereich[]>("/bereiche"),
       apiRequest<Kategorie[]>("/kategorien"),
       apiRequest<Objekttyp[]>("/objekttypen"),
@@ -143,6 +145,7 @@ export function AdminPage() {
       apiRequest<Qualifikationstyp[]>("/qualifikationstypen"),
       apiRequest<Einsatzfunktion[]>("/einsatzfunktionen"),
       apiRequest<Nummernschema[]>("/nummernschemata"),
+      apiRequest<Person[]>("/personen"),
     ]);
     const wert = <T,>(r: PromiseSettledResult<T[]>): T[] => (r.status === "fulfilled" ? r.value : []);
     setBereiche(wert(be));
@@ -158,6 +161,7 @@ export function AdminPage() {
     setQualifikationstypen(wert(qt));
     setEinsatzfunktionen(wert(ef));
     setNummernschemata(wert(ns));
+    setPersonen(wert(pe));
   }
 
   useEffect(() => {
@@ -249,6 +253,7 @@ export function AdminPage() {
           benutzer={benutzer}
           einheiten={einheiten}
           einsatzfunktionen={einsatzfunktionen}
+          personen={personen}
           onGeaendert={ladeAlles}
           onFehler={setFehler}
         />
@@ -274,6 +279,7 @@ export function AdminPage() {
       {aktiverTab === "eskalation" && <EskalationSection onFehler={setFehler} />}
       {aktiverTab === "personal" && (
         <>
+          <PersonSection personen={personen} onGeaendert={ladeAlles} onFehler={setFehler} />
           <EinheitSection einheiten={einheiten} standorte={standorte} onGeaendert={ladeAlles} onFehler={setFehler} />
           <QualifikationSection
             qualifikationstypen={qualifikationstypen}

frontend/src/pages/admin/BenutzerSection.tsx

@@ -1,12 +1,13 @@
 import { useState } from "react";
 
 import { apiRequest } from "../../api/client";
-import type { Benutzer, Einheit, Einsatzfunktion, Rolle } from "../../api/types";
+import type { Benutzer, Einheit, Einsatzfunktion, Person, Rolle } from "../../api/types";
 
 interface Props {
   benutzer: Benutzer[];
   einheiten: Einheit[];
   einsatzfunktionen: Einsatzfunktion[];
+  personen: Person[];
   onGeaendert: () => Promise<void>;
   onFehler: (text: string) => void;
 }
@@ -18,13 +19,14 @@ const ALLE_ROLLEN: Rolle[] = [
   "administration",
 ];
 
-export function BenutzerSection({ benutzer, einheiten, einsatzfunktionen, onGeaendert, onFehler }: Props) {
+export function BenutzerSection({ benutzer, einheiten, einsatzfunktionen, personen, onGeaendert, onFehler }: Props) {
   const [name, setName] = useState("");
   const [login, setLogin] = useState("");
   const [passwort, setPasswort] = useState("");
   const [email, setEmail] = useState("");
   const [einheitId, setEinheitId] = useState<number | "">("");
   const [einsatzfunktionId, setEinsatzfunktionId] = useState<number | "">("");
+  const [personId, setPersonId] = useState<number | "">("");
   const [neueEinsatzfunktion, setNeueEinsatzfunktion] = useState("");
   const [rollen, setRollen] = useState<Rolle[]>(["mitarbeiter"]);
   const [wirdAngelegt, setWirdAngelegt] = useState(false);
@@ -65,6 +67,7 @@ export function BenutzerSection({ benutzer, einheiten, einsatzfunktionen, onGeae
           email: email || null,
           einheit_id: einheitId === "" ? null : einheitId,
           einsatzfunktion_id: einsatzfunktionId === "" ? null : einsatzfunktionId,
+          person_id: personId === "" ? null : personId,
           rollen,
         },
       });
@@ -74,6 +77,7 @@ export function BenutzerSection({ benutzer, einheiten, einsatzfunktionen, onGeae
       setEmail("");
       setEinheitId("");
       setEinsatzfunktionId("");
+      setPersonId("");
       setRollen(["mitarbeiter"]);
       await onGeaendert();
     } catch {
@@ -177,6 +181,14 @@ export function BenutzerSection({ benutzer, einheiten, einsatzfunktionen, onGeae
               </option>
             ))}
           </select>
+          <select className="input" value={personId} onChange={(e) => setPersonId(Number(e.target.value) || "")}>
+            <option value="">Neue Person anlegen (Standard)</option>
+            {personen.map((p) => (
+              <option key={p.id} value={p.id}>
+                Bestehende Person: {p.name}
+              </option>
+            ))}
+          </select>
           <input
             className="input"
             value={neueEinsatzfunktion}

frontend/src/pages/admin/PersonSection.tsx

@@ -0,0 +1,143 @@
+import { useState } from "react";
+
+import { apiRequest } from "../../api/client";
+import type { Person } from "../../api/types";
+
+interface Props {
+  personen: Person[];
+  onGeaendert: () => Promise<void>;
+  onFehler: (text: string) => void;
+}
+
+export function PersonSection({ personen, onGeaendert, onFehler }: Props) {
+  const [name, setName] = useState("");
+  const [geburtsdatum, setGeburtsdatum] = useState("");
+  const [kontakt, setKontakt] = useState("");
+  const [wirdAngelegt, setWirdAngelegt] = useState(false);
+  const [bearbeiteteId, setBearbeiteteId] = useState<number | null>(null);
+  const [bearbeitungsName, setBearbeitungsName] = useState("");
+  const [bearbeitungsGeburtsdatum, setBearbeitungsGeburtsdatum] = useState("");
+  const [bearbeitungsKontakt, setBearbeitungsKontakt] = useState("");
+
+  async function anlegen() {
+    setWirdAngelegt(true);
+    try {
+      await apiRequest("/personen", {
+        method: "POST",
+        body: { name, geburtsdatum: geburtsdatum || null, kontakt: kontakt || null },
+      });
+      setName("");
+      setGeburtsdatum("");
+      setKontakt("");
+      await onGeaendert();
+    } catch {
+      onFehler("Person konnte nicht angelegt werden.");
+    } finally {
+      setWirdAngelegt(false);
+    }
+  }
+
+  function bearbeiten(p: Person) {
+    setBearbeiteteId(p.id);
+    setBearbeitungsName(p.name);
+    setBearbeitungsGeburtsdatum(p.geburtsdatum ?? "");
+    setBearbeitungsKontakt(p.kontakt ?? "");
+  }
+
+  async function speichern(id: number) {
+    try {
+      await apiRequest(`/personen/${id}`, {
+        method: "PATCH",
+        body: {
+          name: bearbeitungsName,
+          geburtsdatum: bearbeitungsGeburtsdatum || null,
+          kontakt: bearbeitungsKontakt || null,
+        },
+      });
+      setBearbeiteteId(null);
+      await onGeaendert();
+    } catch {
+      onFehler("Person konnte nicht geändert werden.");
+    }
+  }
+
+  return (
+    <section className="section">
+      <h2>Personen</h2>
+      <p className="text-muted" style={{ marginTop: 0 }}>
+        Fachliche Personen unabhängig vom Systemzugang – z. B. Jugendgruppe oder externe
+        Helfer ohne Login. Ein Login (Tab „Benutzer") kann optional mit einer bestehenden
+        Person verknüpft werden.
+      </p>
+      <div className="card">
+        <div className="row" style={{ flexWrap: "wrap", gap: "0.5rem", marginBottom: "0.75rem" }}>
+          <input className="input" value={name} onChange={(e) => setName(e.target.value)} placeholder="Name" />
+          <input
+            className="input"
+            type="date"
+            value={geburtsdatum}
+            onChange={(e) => setGeburtsdatum(e.target.value)}
+          />
+          <input
+            className="input"
+            value={kontakt}
+            onChange={(e) => setKontakt(e.target.value)}
+            placeholder="Kontakt (optional)"
+          />
+          <button className="btn btn-primary" onClick={anlegen} disabled={!name || wirdAngelegt}>
+            Anlegen
+          </button>
+        </div>
+
+        {personen.length === 0 ? (
+          <p className="text-muted">Keine Personen erfasst.</p>
+        ) : (
+          <ul className="card-list">
+            {personen.map((p) => (
+              <li key={p.id} style={{ padding: "0.4rem 0" }}>
+                {bearbeiteteId === p.id ? (
+                  <div className="row" style={{ flexWrap: "wrap", gap: "0.5rem" }}>
+                    <input
+                      className="input"
+                      value={bearbeitungsName}
+                      onChange={(e) => setBearbeitungsName(e.target.value)}
+                    />
+                    <input
+                      className="input"
+                      type="date"
+                      value={bearbeitungsGeburtsdatum}
+                      onChange={(e) => setBearbeitungsGeburtsdatum(e.target.value)}
+                    />
+                    <input
+                      className="input"
+                      value={bearbeitungsKontakt}
+                      onChange={(e) => setBearbeitungsKontakt(e.target.value)}
+                      placeholder="Kontakt"
+                    />
+                    <button className="btn btn-primary" onClick={() => speichern(p.id)}>
+                      Speichern
+                    </button>
+                    <button className="btn btn-secondary" onClick={() => setBearbeiteteId(null)}>
+                      Abbrechen
+                    </button>
+                  </div>
+                ) : (
+                  <div className="row-between">
+                    <span>
+                      {p.name}
+                      {p.geburtsdatum && <span className="text-muted"> · geb. {p.geburtsdatum}</span>}
+                      {p.kontakt && <span className="text-muted"> · {p.kontakt}</span>}
+                    </span>
+                    <button className="btn btn-secondary" onClick={() => bearbeiten(p)}>
+                      Bearbeiten
+                    </button>
+                  </div>
+                )}
+              </li>
+            ))}
+          </ul>
+        )}
+      </div>
+    </section>
+  );
+}