feat(dokument): Dokumente-Modul (Roadmap Phase 5)

Polymorphe Datei-Anhänge (PDF/JPEG/PNG/WebP, Whitelist statt Blacklist -
owasp-Grundsatz) an beliebige Ressource, gleiches entitaet_typ/entitaet_id-
Muster wie Mangel/Historie. Lokale Ablage (settings.upload_dir, kein Cloud-
Zwang, Self-Hosting-Anforderung), server-generierter Dateiname verhindert
Path-Traversal/Namenskollisionen.

POST /dokumente (multipart), GET /dokumente (Filter Pflicht: entitaet_typ +
entitaet_id), GET /dokumente/{id}/download, DELETE /dokumente/{id}. Hochladen:
alle Mitarbeiter+, Löschen: Materialverantwortliche+Leitung+Admin.

Frontend: wiederverwendbares DokumentePanel (Upload/Liste/Download/Löschen),
eingebunden in ObjektSection (je Objekt) und MangelListePage (Fotos zu
Mängeln) - weitere Ressourcen (Geräteinstanz, Fahrzeugdetails, Benutzer)
können denselben Baustein später einfach wiederverwenden.

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

DEVLOG.md

@@ -4087,3 +4087,22 @@ Keine Commits in dieser Session.
 - frontend/src/pages/admin/ObjektSection.tsx        |  62 ++++++++++++++++++++++++++++++++++++++++++
 
 ---
+## 2026-09-05 13:47 – 13:51 (3m)
+**Beschreibung:** Claude Code Session
+**Projekt:** asb-material
+
+### Commits
+- 11ad747 fix(historie): Audit-Lücke bei Mangel/Personal/Objekt-Änderungen geschlossen
+
+### Geänderte Dateien
+- DEVLOG.md                                    | 22 ++++++++++++++++++++++
+- backend/app/api/v1/endpoints/mangel.py       | 33 +++++++++++++++++++++++++--------
+- backend/app/api/v1/endpoints/objekte.py      | 23 ++++++++++++++++++++++-
+- backend/app/api/v1/endpoints/personal.py     | 27 +++++++++++++++++++++++++--
+- backend/app/services/mangel.py               | 28 ++++++++++++++++++++++++----
+- backend/tests/test_fahrzeugdetails.py        | 15 +++++++++++++++
+- backend/tests/test_mangel.py                 | 26 ++++++++++++++++++++++++++
+- backend/tests/test_personal.py               | 32 ++++++++++++++++++++++++++++++++
+- frontend/src/pages/admin/HistorieSection.tsx | 11 ++++++++++-
+
+---

backend/.gitignore

@@ -7,3 +7,4 @@ venv/
 .coverage
 htmlcov/
 *.egg-info/
+/uploads/

backend/alembic/versions/0016_dokument.py

@@ -0,0 +1,43 @@
+"""Dokumente-Modul (Roadmap Phase 5): polymorphe Datei-Anhänge (PDF/Bilder/
+Prüfprotokolle/Wartungsberichte/Bedienungsanleitungen/Rechnungen/Zulassungs-
+dokumente) an beliebige Ressource. entitaet_typ/entitaet_id als String-
+Polymorphie, gleiches Muster wie historie.entitaet_typ/mangel.entitaet_typ
+(bewusst kein FK - Dokument bleibt lesbar, auch wenn die konkrete Ressource
+später gelöscht wird).
+
+Revision ID: 0016_dokument
+Revises: 0015_lagerbewegung
+Create Date: 2026-09-05
+"""
+from typing import Sequence, Union
+
+from alembic import op
+
+revision: str = "0016_dokument"
+down_revision: Union[str, None] = "0015_lagerbewegung"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.execute(
+        """
+        CREATE TABLE dokument (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            entitaet_typ TEXT NOT NULL,
+            entitaet_id TEXT NOT NULL,
+            dateiname TEXT NOT NULL,
+            speicherpfad TEXT NOT NULL,
+            mime_type TEXT NOT NULL,
+            groesse_bytes INTEGER NOT NULL,
+            beschreibung TEXT,
+            hochgeladen_von INTEGER NOT NULL REFERENCES benutzer(id),
+            hochgeladen_am TIMESTAMPTZ NOT NULL
+        )
+        """
+    )
+    op.execute("CREATE INDEX idx_dokument_entitaet ON dokument (entitaet_typ, entitaet_id)")
+
+
+def downgrade() -> None:
+    op.execute("DROP TABLE dokument")

backend/app/api/v1/api.py

@@ -4,6 +4,7 @@ from app.api.v1.endpoints import (
     auth,
     benutzer,
     dashboard,
+    dokument,
     eskalation,
     fehlbestaende,
     geraet_instanz,
@@ -36,3 +37,4 @@ api_router.include_router(dashboard.router, tags=["dashboard"])
 api_router.include_router(personal.router, tags=["personal"])
 api_router.include_router(mangel.router, tags=["mangel"])
 api_router.include_router(lagerbewegung.router, tags=["lagerbewegung"])
+api_router.include_router(dokument.router, tags=["dokument"])

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

@@ -0,0 +1,95 @@
+import uuid
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile, status
+from fastapi.responses import FileResponse
+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.dokument import Dokument
+from app.schemas.dokument import DokumentRead, EntitaetTyp
+from app.services.dokument import (
+    DateityperlaubtError,
+    DateizugrossError,
+    dateipfad,
+    liste_fuer_entitaet,
+    loesche_dokument,
+    speichere_dokument,
+)
+
+router = APIRouter()
+
+_mitarbeiter_plus = require_roles(
+    RolleTyp.mitarbeiter,
+    RolleTyp.materialverantwortlicher,
+    RolleTyp.leitungsverantwortlicher,
+    RolleTyp.administration,
+)
+_materialverantwortliche = require_roles(
+    RolleTyp.administration, RolleTyp.materialverantwortlicher, RolleTyp.leitungsverantwortlicher
+)
+
+
+@router.get("/dokumente", response_model=list[DokumentRead])
+async def liste_dokumente(
+    entitaet_typ: EntitaetTyp,
+    entitaet_id: str,
+    db: AsyncSession = Depends(get_db),
+    _=Depends(get_current_user),
+) -> list[Dokument]:
+    return await liste_fuer_entitaet(db, entitaet_typ=entitaet_typ, entitaet_id=entitaet_id)
+
+
+@router.post("/dokumente", response_model=DokumentRead, status_code=status.HTTP_201_CREATED)
+async def lade_dokument_hoch(
+    entitaet_typ: EntitaetTyp = Form(...),
+    entitaet_id: str = Form(...),
+    beschreibung: str | None = Form(None),
+    datei: UploadFile = File(...),
+    db: AsyncSession = Depends(get_db),
+    current_user=Depends(_mitarbeiter_plus),
+) -> Dokument:
+    inhalt = await datei.read()
+    try:
+        return await speichere_dokument(
+            db,
+            entitaet_typ=entitaet_typ,
+            entitaet_id=entitaet_id,
+            dateiname=datei.filename or "unbenannt",
+            mime_type=datei.content_type or "application/octet-stream",
+            inhalt=inhalt,
+            beschreibung=beschreibung,
+            hochgeladen_von=current_user.id,
+        )
+    except DateityperlaubtError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, detail=f"Dateityp nicht erlaubt: {exc}"
+        ) from exc
+    except DateizugrossError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="Datei zu groß"
+        ) from exc
+
+
+@router.get("/dokumente/{dokument_id}/download")
+async def lade_dokument_herunter(
+    dokument_id: uuid.UUID, db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
+) -> FileResponse:
+    dokument = await db.get(Dokument, dokument_id)
+    if dokument is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Dokument nicht gefunden")
+    pfad = dateipfad(dokument)
+    if not pfad.exists():
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Datei nicht mehr vorhanden")
+    return FileResponse(pfad, media_type=dokument.mime_type, filename=dokument.dateiname)
+
+
+@router.delete("/dokumente/{dokument_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def entferne_dokument(
+    dokument_id: uuid.UUID, db: AsyncSession = Depends(get_db), _=Depends(_materialverantwortliche)
+) -> None:
+    dokument = await db.get(Dokument, dokument_id)
+    if dokument is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Dokument nicht gefunden")
+    await loesche_dokument(db, dokument=dokument)

backend/app/core/app_settings.py

@@ -24,5 +24,12 @@ class Settings(BaseSettings):
     smtp_from: str = "mabea@example.org"
     smtp_use_tls: bool = True
 
+    # Dokumente-Modul (Roadmap Phase 5): lokale Ablage, kein Cloud-Storage-
+    # Zwang (Self-Hosting-Anforderung). Relativer Default reicht für
+    # Entwicklung, Produktion setzt einen absoluten Pfad außerhalb des
+    # Anwendungsverzeichnisses (z.B. /opt/mabea/uploads, siehe deploy/README.md).
+    upload_dir: str = "./uploads"
+    max_upload_size_mb: int = 25
+
 
 settings = Settings()

backend/app/models/dokument.py

@@ -0,0 +1,29 @@
+import uuid
+from datetime import datetime
+
+from sqlalchemy import ForeignKey, Integer, String
+from sqlalchemy.dialects.postgresql import TIMESTAMP, UUID
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.db.base import Base
+
+
+class Dokument(Base):
+    """Roadmap Phase 5 (Modul Dokumente): polymorpher Datei-Anhang an beliebige
+    Ressource (Objekt, Objektposition, Geräteinstanz, Mangel, Fahrzeugdetails,
+    Benutzer, ...) - gleiches entitaet_typ/entitaet_id-Muster wie Historie/
+    Mangel. Datei liegt lokal auf Platte (self-hosted, kein Cloud-Zwang),
+    speicherpfad ist relativ zu settings.upload_dir."""
+
+    __tablename__ = "dokument"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    entitaet_typ: Mapped[str] = mapped_column(String, nullable=False)
+    entitaet_id: Mapped[str] = mapped_column(String, nullable=False)
+    dateiname: Mapped[str] = mapped_column(String, nullable=False)
+    speicherpfad: Mapped[str] = mapped_column(String, nullable=False)
+    mime_type: Mapped[str] = mapped_column(String, nullable=False)
+    groesse_bytes: Mapped[int] = mapped_column(Integer, nullable=False)
+    beschreibung: Mapped[str | None] = mapped_column(String)
+    hochgeladen_von: Mapped[int] = mapped_column(ForeignKey("benutzer.id"), nullable=False)
+    hochgeladen_am: Mapped[datetime] = mapped_column(TIMESTAMP(timezone=True), nullable=False)

backend/app/schemas/dokument.py

@@ -0,0 +1,25 @@
+import uuid
+from datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+# Bewusst geschlossene Liste statt Freitext (Konsistenz mit Mangel.entitaet_typ-
+# Validierung) - jeder Ressourcentyp, an den Dokumente angehängt werden dürfen,
+# muss hier explizit freigeschaltet werden.
+EntitaetTyp = Literal[
+    "objekt", "objektposition", "geraet_instanz", "mangel", "fahrzeugdetails", "benutzer"
+]
+
+
+class DokumentRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    id: uuid.UUID
+    entitaet_typ: str
+    entitaet_id: str
+    dateiname: str
+    mime_type: str
+    groesse_bytes: int
+    beschreibung: str | None
+    hochgeladen_von: int
+    hochgeladen_am: datetime

backend/app/services/dokument.py

@@ -0,0 +1,99 @@
+import os
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.app_settings import settings
+from app.models.dokument import Dokument
+
+# Erlaubte MIME-Types (Nutzer-Vorgabe Modul 10: PDF/Bilder/Prüfprotokolle/
+# Wartungsberichte/Bedienungsanleitungen/Rechnungen/Zulassungsdokumente) -
+# Whitelist statt Blacklist (owasp-Grundsatz: Datei-Upload ist klassischer
+# Angriffsvektor, z.B. .html/.svg mit eingebettetem Skript).
+ERLAUBTE_MIME_TYPES = {
+    "application/pdf",
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+}
+
+
+class DateityperlaubtError(Exception):
+    pass
+
+
+class DateizugrossError(Exception):
+    pass
+
+
+def _upload_pfad() -> Path:
+    pfad = Path(settings.upload_dir)
+    pfad.mkdir(parents=True, exist_ok=True)
+    return pfad
+
+
+async def speichere_dokument(
+    db: AsyncSession,
+    *,
+    entitaet_typ: str,
+    entitaet_id: str,
+    dateiname: str,
+    mime_type: str,
+    inhalt: bytes,
+    beschreibung: str | None,
+    hochgeladen_von: int,
+) -> Dokument:
+    if mime_type not in ERLAUBTE_MIME_TYPES:
+        raise DateityperlaubtError(mime_type)
+    if len(inhalt) > settings.max_upload_size_mb * 1024 * 1024:
+        raise DateizugrossError(len(inhalt))
+
+    # Speichername ist server-generiert (UUID), NIEMALS der Original-Dateiname -
+    # verhindert Path-Traversal (../../etc/passwd) und Namenskollisionen.
+    endung = Path(dateiname).suffix[:10]
+    speichername = f"{uuid.uuid4()}{endung}"
+    ziel = _upload_pfad() / speichername
+    ziel.write_bytes(inhalt)
+
+    dokument = Dokument(
+        entitaet_typ=entitaet_typ,
+        entitaet_id=entitaet_id,
+        dateiname=dateiname,
+        speicherpfad=speichername,
+        mime_type=mime_type,
+        groesse_bytes=len(inhalt),
+        beschreibung=beschreibung,
+        hochgeladen_von=hochgeladen_von,
+        hochgeladen_am=datetime.now(timezone.utc),
+    )
+    db.add(dokument)
+    await db.flush()
+    return dokument
+
+
+async def liste_fuer_entitaet(db: AsyncSession, *, entitaet_typ: str, entitaet_id: str) -> list[Dokument]:
+    result = await db.execute(
+        select(Dokument)
+        .where(Dokument.entitaet_typ == entitaet_typ, Dokument.entitaet_id == entitaet_id)
+        .order_by(Dokument.hochgeladen_am.desc())
+    )
+    return list(result.scalars().all())
+
+
+def dateipfad(dokument: Dokument) -> Path:
+    return _upload_pfad() / dokument.speicherpfad
+
+
+async def loesche_dokument(db: AsyncSession, *, dokument: Dokument) -> None:
+    pfad = dateipfad(dokument)
+    await db.delete(dokument)
+    await db.flush()
+    # Datei erst nach erfolgreichem DB-Commit-Vorbereiten löschen (flush wirft
+    # bei FK-Problemen, bevor die Datei weg ist) - hier gibt es keine
+    # eingehenden FKs auf dokument, daher unkritisch, aber Reihenfolge bewusst
+    # gewählt für den Fall künftiger Referenzen.
+    if pfad.exists():
+        os.remove(pfad)

backend/example.env

@@ -7,3 +7,8 @@ ACCESS_TOKEN_EXPIRE_MINUTES=480
 
 # ID des systemknoten-Datensatzes mit typ='haupt' (Sprintplan E6, siehe alembic/versions/0002_seed_hauptserver.py)
 SYSTEMKNOTEN_ID=1
+
+# Dokumente-Modul: Ablageverzeichnis außerhalb des Anwendungsverzeichnisses
+# (z.B. /opt/mabea/uploads), damit ein Redeploy hochgeladene Dateien nicht löscht.
+UPLOAD_DIR=/opt/mabea/uploads
+MAX_UPLOAD_SIZE_MB=25

backend/tests/test_dokument.py

@@ -0,0 +1,96 @@
+import pytest
+
+from tests.conftest import auth_header, login
+
+
+@pytest.mark.asyncio
+async def test_dokument_hochladen_und_liste(client, objekt_mit_position, mitarbeiter_user):
+    objekt, _material = objekt_mit_position
+    token = await login(client, "mitarbeiter1")
+
+    hochgeladen = await client.post(
+        "/api/v1/dokumente",
+        data={"entitaet_typ": "objekt", "entitaet_id": str(objekt.id), "beschreibung": "Zulassung"},
+        files={"datei": ("zulassung.pdf", b"%PDF-1.4 fake", "application/pdf")},
+        headers=auth_header(token),
+    )
+    assert hochgeladen.status_code == 201
+    body = hochgeladen.json()
+    assert body["dateiname"] == "zulassung.pdf"
+    assert body["groesse_bytes"] > 0
+
+    liste = await client.get(
+        f"/api/v1/dokumente?entitaet_typ=objekt&entitaet_id={objekt.id}", headers=auth_header(token)
+    )
+    assert len(liste.json()) == 1
+
+
+@pytest.mark.asyncio
+async def test_download_liefert_inhalt(client, objekt_mit_position, mitarbeiter_user):
+    objekt, _material = objekt_mit_position
+    token = await login(client, "mitarbeiter1")
+    hochgeladen = await client.post(
+        "/api/v1/dokumente",
+        data={"entitaet_typ": "objekt", "entitaet_id": str(objekt.id)},
+        files={"datei": ("foto.png", b"\x89PNG fake", "image/png")},
+        headers=auth_header(token),
+    )
+    dokument_id = hochgeladen.json()["id"]
+
+    download = await client.get(f"/api/v1/dokumente/{dokument_id}/download", headers=auth_header(token))
+    assert download.status_code == 200
+    assert download.content == b"\x89PNG fake"
+
+
+@pytest.mark.asyncio
+async def test_unerlaubter_dateityp_wird_abgelehnt(client, objekt_mit_position, mitarbeiter_user):
+    objekt, _material = objekt_mit_position
+    token = await login(client, "mitarbeiter1")
+
+    response = await client.post(
+        "/api/v1/dokumente",
+        data={"entitaet_typ": "objekt", "entitaet_id": str(objekt.id)},
+        files={"datei": ("boese.html", b"<script>alert(1)</script>", "text/html")},
+        headers=auth_header(token),
+    )
+    assert response.status_code == 415
+
+
+@pytest.mark.asyncio
+async def test_materialverantwortlicher_kann_dokument_loeschen(
+    client, objekt_mit_position, mitarbeiter_user, materialverantwortlicher_user
+):
+    objekt, _material = objekt_mit_position
+    mitarbeiter_token = await login(client, "mitarbeiter1")
+    hochgeladen = await client.post(
+        "/api/v1/dokumente",
+        data={"entitaet_typ": "objekt", "entitaet_id": str(objekt.id)},
+        files={"datei": ("bericht.pdf", b"%PDF-1.4 x", "application/pdf")},
+        headers=auth_header(mitarbeiter_token),
+    )
+    dokument_id = hochgeladen.json()["id"]
+
+    verantwortlicher_token = await login(client, "materialverantwortlicher1")
+    geloescht = await client.delete(f"/api/v1/dokumente/{dokument_id}", headers=auth_header(verantwortlicher_token))
+    assert geloescht.status_code == 204
+
+    liste = await client.get(
+        f"/api/v1/dokumente?entitaet_typ=objekt&entitaet_id={objekt.id}", headers=auth_header(verantwortlicher_token)
+    )
+    assert liste.json() == []
+
+
+@pytest.mark.asyncio
+async def test_mitarbeiter_darf_dokument_nicht_loeschen(client, objekt_mit_position, mitarbeiter_user):
+    objekt, _material = objekt_mit_position
+    token = await login(client, "mitarbeiter1")
+    hochgeladen = await client.post(
+        "/api/v1/dokumente",
+        data={"entitaet_typ": "objekt", "entitaet_id": str(objekt.id)},
+        files={"datei": ("x.pdf", b"%PDF-1.4 x", "application/pdf")},
+        headers=auth_header(token),
+    )
+    dokument_id = hochgeladen.json()["id"]
+
+    response = await client.delete(f"/api/v1/dokumente/{dokument_id}", headers=auth_header(token))
+    assert response.status_code == 403

frontend/src/api/client.ts

@@ -64,6 +64,48 @@ export async function apiRequest<T>(path: string, options: RequestOptions = {}):
   return (await response.json()) as T;
 }
 
+export async function ladeDokumentHoch(felder: {
+  entitaet_typ: string;
+  entitaet_id: string;
+  beschreibung?: string;
+  datei: File;
+}): Promise<unknown> {
+  const formData = new FormData();
+  formData.append("entitaet_typ", felder.entitaet_typ);
+  formData.append("entitaet_id", felder.entitaet_id);
+  if (felder.beschreibung) formData.append("beschreibung", felder.beschreibung);
+  formData.append("datei", felder.datei);
+
+  const headers: Record<string, string> = {};
+  if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+
+  const response = await fetch(`${BASE_URL}/dokumente`, { method: "POST", headers, body: formData });
+  if (!response.ok) {
+    throw new ApiError(response.status, await response.json().catch(() => null));
+  }
+  return response.json();
+}
+
+// Download braucht den Auth-Header (kein einfacher <a href>-Link möglich, da
+// der Server ohne Bearer-Token 401 liefert) - Blob laden und über einen
+// temporären Objekt-Link im Browser "herunterladen" lassen.
+export async function ladeDokumentHerunter(dokumentId: string, dateiname: string): Promise<void> {
+  const headers: Record<string, string> = {};
+  if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
+
+  const response = await fetch(`${BASE_URL}/dokumente/${dokumentId}/download`, { headers });
+  if (!response.ok) {
+    throw new ApiError(response.status, null);
+  }
+  const blob = await response.blob();
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = dateiname;
+  link.click();
+  URL.revokeObjectURL(url);
+}
+
 export async function login(username: string, password: string): Promise<string> {
   const body = new URLSearchParams({ username, password });
   const response = await fetch(`${BASE_URL}/auth/login`, {

frontend/src/api/types.ts

@@ -73,6 +73,18 @@ export interface Mangel {
   erledigt_am: string | null;
 }
 
+export interface Dokument {
+  id: string;
+  entitaet_typ: string;
+  entitaet_id: string;
+  dateiname: string;
+  mime_type: string;
+  groesse_bytes: number;
+  beschreibung: string | null;
+  hochgeladen_von: number;
+  hochgeladen_am: string;
+}
+
 export interface Lagerbewegung {
   id: string;
   objekt_id: number;

frontend/src/components/DokumentePanel.tsx

@@ -0,0 +1,129 @@
+import { useEffect, useState } from "react";
+
+import { apiRequest, ladeDokumentHerunter, ladeDokumentHoch } from "../api/client";
+import { useAuth } from "../auth/AuthContext";
+import type { Dokument } from "../api/types";
+
+interface Props {
+  entitaetTyp: string;
+  entitaetId: string;
+  onFehler: (text: string) => void;
+}
+
+function formatGroesse(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// Dokumente-Modul (Roadmap Phase 5): wiederverwendbares Panel für beliebige
+// Ressourcen (Objekt, Mangel, Fahrzeugdetails, ...) - gleiche entitaet_typ/
+// entitaet_id-Adressierung wie das Backend.
+export function DokumentePanel({ entitaetTyp, entitaetId, onFehler }: Props) {
+  const { istMaterialverantwortlich, istLeitungsverantwortlich, istAdmin } = useAuth();
+  const darfLoeschen = istMaterialverantwortlich || istLeitungsverantwortlich || istAdmin;
+
+  const [dokumente, setDokumente] = useState<Dokument[]>([]);
+  const [laedt, setLaedt] = useState(true);
+  const [beschreibung, setBeschreibung] = useState("");
+  const [wirdHochgeladen, setWirdHochgeladen] = useState(false);
+
+  async function laden() {
+    setLaedt(true);
+    try {
+      const daten = await apiRequest<Dokument[]>(
+        `/dokumente?entitaet_typ=${entitaetTyp}&entitaet_id=${encodeURIComponent(entitaetId)}`
+      );
+      setDokumente(daten);
+    } catch {
+      onFehler("Dokumente konnten nicht geladen werden.");
+    } finally {
+      setLaedt(false);
+    }
+  }
+
+  useEffect(() => {
+    laden();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [entitaetTyp, entitaetId]);
+
+  async function hochladen(e: { target: HTMLInputElement }) {
+    const datei = e.target.files?.[0];
+    if (!datei) return;
+    setWirdHochgeladen(true);
+    try {
+      await ladeDokumentHoch({ entitaet_typ: entitaetTyp, entitaet_id: entitaetId, beschreibung, datei });
+      setBeschreibung("");
+      e.target.value = "";
+      await laden();
+    } catch {
+      onFehler("Datei konnte nicht hochgeladen werden (Typ erlaubt: PDF/JPEG/PNG/WebP, max. 25 MB).");
+    } finally {
+      setWirdHochgeladen(false);
+    }
+  }
+
+  async function herunterladen(d: Dokument) {
+    try {
+      await ladeDokumentHerunter(d.id, d.dateiname);
+    } catch {
+      onFehler("Download fehlgeschlagen.");
+    }
+  }
+
+  async function loeschen(d: Dokument) {
+    try {
+      await apiRequest(`/dokumente/${d.id}`, { method: "DELETE" });
+      await laden();
+    } catch {
+      onFehler("Dokument konnte nicht gelöscht werden.");
+    }
+  }
+
+  return (
+    <div className="stack">
+      <div className="row" style={{ flexWrap: "wrap" }}>
+        <input
+          className="input"
+          value={beschreibung}
+          onChange={(e) => setBeschreibung(e.target.value)}
+          placeholder="Beschreibung (optional)"
+          style={{ maxWidth: "16rem" }}
+        />
+        <input type="file" accept=".pdf,.jpg,.jpeg,.png,.webp" onChange={hochladen} disabled={wirdHochgeladen} />
+      </div>
+      {laedt && <p className="text-muted">Lade…</p>}
+      {!laedt && dokumente.length === 0 && <p className="text-muted">Keine Dokumente.</p>}
+      {!laedt && dokumente.length > 0 && (
+        <ul className="card-list">
+          {dokumente.map((d) => (
+            <li key={d.id} className="row-between" style={{ padding: "0.3rem 0" }}>
+              <span>
+                <button
+                  onClick={() => herunterladen(d)}
+                  style={{
+                    background: "none",
+                    border: "none",
+                    padding: 0,
+                    color: "var(--color-primary)",
+                    textDecoration: "underline",
+                    cursor: "pointer",
+                  }}
+                >
+                  {d.dateiname}
+                </button>
+                {d.beschreibung && <span className="text-muted"> – {d.beschreibung}</span>}
+                <span className="text-muted"> ({formatGroesse(d.groesse_bytes)})</span>
+              </span>
+              {darfLoeschen && (
+                <button className="btn btn-secondary" onClick={() => loeschen(d)}>
+                  Löschen
+                </button>
+              )}
+            </li>
+          ))}
+        </ul>
+      )}
+    </div>
+  );
+}

frontend/src/pages/MangelListePage.tsx

@@ -2,6 +2,7 @@ import { useEffect, useState } from "react";
 
 import { apiRequest } from "../api/client";
 import { useAuth } from "../auth/AuthContext";
+import { DokumentePanel } from "../components/DokumentePanel";
 import type { Mangel, MangelPrioritaet, MangelStatus, Objekt } from "../api/types";
 
 const STATUS_LABEL: Record<MangelStatus, string> = {
@@ -37,6 +38,7 @@ export function MangelListePage() {
   const [beschreibung, setBeschreibung] = useState("");
   const [prioritaet, setPrioritaet] = useState<MangelPrioritaet>("normal");
   const [wirdGemeldet, setWirdGemeldet] = useState(false);
+  const [fotosOffenId, setFotosOffenId] = useState<string | null>(null);
 
   async function laden() {
     setLaedt(true);
@@ -160,6 +162,18 @@ export function MangelListePage() {
                 ))}
               </select>
             )}
+            <button
+              className="btn btn-secondary"
+              style={{ marginTop: "0.5rem" }}
+              onClick={() => setFotosOffenId(fotosOffenId === m.id ? null : m.id)}
+            >
+              {fotosOffenId === m.id ? "Dokumente schließen" : "Dokumente/Fotos"}
+            </button>
+            {fotosOffenId === m.id && (
+              <div style={{ marginTop: "0.5rem" }}>
+                <DokumentePanel entitaetTyp="mangel" entitaetId={m.id} onFehler={setFehler} />
+              </div>
+            )}
           </li>
         ))}
       </ul>

frontend/src/pages/admin/ObjektSection.tsx

@@ -2,6 +2,7 @@ import { useState } from "react";
 
 import { apiRequest } from "../../api/client";
 import type { Beladungsvorlage, Fahrzeugdetails, Material, Objekt, Objekttyp, Standort } from "../../api/types";
+import { DokumentePanel } from "../../components/DokumentePanel";
 import { ObjektPositionenPanel } from "./ObjektPositionenPanel";
 
 const STATUS_OPTIONEN = [
@@ -44,6 +45,7 @@ export function ObjektSection({
   const [fahrzeugId, setFahrzeugId] = useState<number | "">("");
   const [wirdAngelegt, setWirdAngelegt] = useState(false);
   const [ausgeklapptId, setAusgeklapptId] = useState<number | null>(null);
+  const [dokumenteOffenId, setDokumenteOffenId] = useState<number | null>(null);
   const [duplizierId, setDuplizierId] = useState<number | null>(null);
   const [neuerPraefix, setNeuerPraefix] = useState("");
   const [neuerCode, setNeuerCode] = useState("");
@@ -397,6 +399,12 @@ export function ObjektSection({
                     >
                       {ausgeklapptId === o.id ? "Positionen ausblenden" : "Ablauf/Charge/SN pflegen"}
                     </button>
+                    <button
+                      className="btn btn-secondary"
+                      onClick={() => setDokumenteOffenId(dokumenteOffenId === o.id ? null : o.id)}
+                    >
+                      {dokumenteOffenId === o.id ? "Dokumente schließen" : "Dokumente"}
+                    </button>
                     {!nurPflegen && (
                       <button className="btn btn-secondary" onClick={() => fahrzeugBearbeiten(o)}>
                         {fahrzeugBearbeitenId === o.id ? "Schließen" : "Fahrzeug zuordnen"}
@@ -524,6 +532,11 @@ export function ObjektSection({
                     />
                   </div>
                 )}
+                {dokumenteOffenId === o.id && (
+                  <div style={{ marginTop: "0.5rem" }}>
+                    <DokumentePanel entitaetTyp="objekt" entitaetId={String(o.id)} onFehler={onFehler} />
+                  </div>
+                )}
                 {duplizierId === o.id && (
                   <div className="row" style={{ marginTop: "0.5rem", flexWrap: "wrap" }}>
                     <input