feat(personal): Personal/Qualifikationen-Modul (Roadmap Phase 1)
Neues Modul für die BOS-Ressourcenplattform-Erweiterung: Einheit (Zug/Gruppe,
self-referenzierend), Qualifikationstyp (Führerschein/Lehrgang/Berechtigung),
BenutzerQualifikation (mit Gültigkeit) und ObjekttypQualifikationsanforderung
(M:N) - beantwortet "wer darf dieses Fahrzeug fahren?" über
GET /objekte/{id}/berechtigung/{benutzer_id}.
Benutzer und Objekt bekommen optionale einheit_id (additiv, analog
fahrzeug_id-Muster). Nebenbei Bugfix: PATCH /benutzer konnte einheit_id nicht
auf null setzen (Feld-vorhanden-Check via model_fields_set statt is not None).
Frontend: neuer Admin-Tab "Personal" (Einheiten, Qualifikationstypen,
Benutzer-Qualifikationszuordnung), Einheit-Auswahl im Benutzer-Formular.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KC8HYvv6UkCVYheYiTw9DD
This commit is contained in:
Claude Sonnet 5
@@ -0,0 +1,86 @@
|
||||
"""Personal/Qualifikationen-Modul (Roadmap-Erweiterung, Phase 1 nach BOS-
|
||||
Ressourcenplattform-Anforderung): Einheit-Hierarchie, Qualifikationstypen
|
||||
(Führerschein/Lehrgang/Berechtigung), Benutzer-Qualifikationszuordnung mit
|
||||
Gültigkeit, sowie welche Qualifikation ein Objekttyp (z.B. Fahrzeug) zum
|
||||
Bedienen voraussetzt - beantwortet "wer darf dieses Fahrzeug fahren?".
|
||||
|
||||
Revision ID: 0012_personal_qualifikationen
|
||||
Revises: 0011_objekttyp_zugfahrzeug
|
||||
Create Date: 2026-09-05
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
|
||||
revision: str = "0012_personal_qualifikationen"
|
||||
down_revision: Union[str, None] = "0011_objekttyp_zugfahrzeug"
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
op.execute("CREATE TYPE qualifikationskategorie AS ENUM ('fuehrerschein', 'lehrgang', 'berechtigung')")
|
||||
|
||||
op.execute(
|
||||
"""
|
||||
CREATE TABLE einheit (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
uebergeordnete_einheit_id INTEGER REFERENCES einheit(id),
|
||||
standort_id INTEGER REFERENCES standort(id),
|
||||
CONSTRAINT einheit_kein_selbstbezug CHECK (uebergeordnete_einheit_id <> id)
|
||||
)
|
||||
"""
|
||||
)
|
||||
op.execute("CREATE INDEX idx_einheit_uebergeordnet ON einheit (uebergeordnete_einheit_id)")
|
||||
|
||||
op.execute("ALTER TABLE benutzer ADD COLUMN einheit_id INTEGER REFERENCES einheit(id)")
|
||||
# Fahrzeuge/Objekte künftig einer Einheit zuordenbar (analog fahrzeug_id-Muster
|
||||
# aus Migration 0010: additiv, NULL = keiner Einheit zugeordnet).
|
||||
op.execute("ALTER TABLE objekt ADD COLUMN einheit_id INTEGER REFERENCES einheit(id)")
|
||||
|
||||
op.execute(
|
||||
"""
|
||||
CREATE TABLE qualifikationstyp (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
kategorie qualifikationskategorie NOT NULL,
|
||||
gueltigkeit_monate INTEGER
|
||||
)
|
||||
"""
|
||||
)
|
||||
|
||||
op.execute(
|
||||
"""
|
||||
CREATE TABLE benutzer_qualifikation (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
benutzer_id INTEGER NOT NULL REFERENCES benutzer(id),
|
||||
qualifikationstyp_id INTEGER NOT NULL REFERENCES qualifikationstyp(id),
|
||||
erworben_am DATE NOT NULL,
|
||||
gueltig_bis DATE,
|
||||
nachweis_nummer TEXT,
|
||||
UNIQUE (benutzer_id, qualifikationstyp_id, erworben_am)
|
||||
)
|
||||
"""
|
||||
)
|
||||
op.execute("CREATE INDEX idx_benutzer_qualifikation_benutzer ON benutzer_qualifikation (benutzer_id)")
|
||||
|
||||
op.execute(
|
||||
"""
|
||||
CREATE TABLE objekttyp_qualifikationsanforderung (
|
||||
objekttyp_id INTEGER NOT NULL REFERENCES objekttyp(id),
|
||||
qualifikationstyp_id INTEGER NOT NULL REFERENCES qualifikationstyp(id),
|
||||
PRIMARY KEY (objekttyp_id, qualifikationstyp_id)
|
||||
)
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.execute("DROP TABLE objekttyp_qualifikationsanforderung")
|
||||
op.execute("DROP TABLE benutzer_qualifikation")
|
||||
op.execute("DROP TABLE qualifikationstyp")
|
||||
op.execute("ALTER TABLE objekt DROP COLUMN einheit_id")
|
||||
op.execute("ALTER TABLE benutzer DROP COLUMN einheit_id")
|
||||
op.execute("DROP TABLE einheit")
|
||||
op.execute("DROP TYPE IF EXISTS qualifikationskategorie")
|
||||
@@ -11,6 +11,7 @@ from app.api.v1.endpoints import (
|
||||
historie,
|
||||
kontrollen,
|
||||
objekte,
|
||||
personal,
|
||||
stammdaten,
|
||||
vorlagen,
|
||||
zustaendigkeit,
|
||||
@@ -30,3 +31,4 @@ api_router.include_router(eskalation.router, tags=["eskalation"])
|
||||
api_router.include_router(historie.router, tags=["historie"])
|
||||
api_router.include_router(geraet_instanz.router, tags=["geraet_instanz"])
|
||||
api_router.include_router(dashboard.router, tags=["dashboard"])
|
||||
api_router.include_router(personal.router, tags=["personal"])
|
||||
|
||||
@@ -37,6 +37,7 @@ async def erstelle_benutzer(
|
||||
email=payload.email,
|
||||
passwort_hash=hash_password(payload.passwort),
|
||||
aktiv=True,
|
||||
einheit_id=payload.einheit_id,
|
||||
)
|
||||
db.add(benutzer)
|
||||
await db.flush()
|
||||
@@ -64,6 +65,11 @@ async def aendere_benutzer(
|
||||
benutzer.email = payload.email
|
||||
if payload.aktiv is not None:
|
||||
benutzer.aktiv = payload.aktiv
|
||||
if "einheit_id" in payload.model_fields_set:
|
||||
# explizit gesetzt (auch null = Einheit lösen) unterscheiden von "nicht
|
||||
# im Request enthalten" - anders als die übrigen Felder hier, da null
|
||||
# ein gültiger, gewollter Zielzustand ist (Bugfix vor Auslieferung).
|
||||
benutzer.einheit_id = payload.einheit_id
|
||||
if payload.rollen is not None:
|
||||
result = await db.execute(select(BenutzerRolle).where(BenutzerRolle.benutzer_id == benutzer_id))
|
||||
for bestehende in result.scalars().all():
|
||||
|
||||
@@ -0,0 +1,213 @@
|
||||
from fastapi import APIRouter, Depends, HTTPException, status
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
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.personal import (
|
||||
BenutzerQualifikation,
|
||||
Einheit,
|
||||
ObjekttypQualifikationsanforderung,
|
||||
Qualifikationstyp,
|
||||
)
|
||||
from app.schemas.personal import (
|
||||
BenutzerQualifikationCreate,
|
||||
BenutzerQualifikationRead,
|
||||
BerechtigungspruefungRead,
|
||||
EinheitCreate,
|
||||
EinheitRead,
|
||||
EinheitUpdate,
|
||||
ObjekttypQualifikationsanforderungCreate,
|
||||
ObjekttypQualifikationsanforderungRead,
|
||||
QualifikationstypCreate,
|
||||
QualifikationstypRead,
|
||||
QualifikationstypUpdate,
|
||||
)
|
||||
from app.services.personal import pruefe_berechtigung
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_admin_only = require_roles(RolleTyp.administration)
|
||||
|
||||
|
||||
# -- Einheit ------------------------------------------------------------------
|
||||
|
||||
@router.get("/einheiten", response_model=list[EinheitRead])
|
||||
async def liste_einheiten(db: AsyncSession = Depends(get_db), _=Depends(get_current_user)) -> list[Einheit]:
|
||||
result = await db.execute(select(Einheit))
|
||||
return list(result.scalars().all())
|
||||
|
||||
|
||||
@router.post("/einheiten", response_model=EinheitRead, status_code=status.HTTP_201_CREATED)
|
||||
async def erstelle_einheit(
|
||||
payload: EinheitCreate, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
|
||||
) -> Einheit:
|
||||
einheit = Einheit(**payload.model_dump())
|
||||
db.add(einheit)
|
||||
try:
|
||||
await db.flush()
|
||||
except IntegrityError as exc:
|
||||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Ungültige Zuordnung") from exc
|
||||
return einheit
|
||||
|
||||
|
||||
@router.patch("/einheiten/{einheit_id}", response_model=EinheitRead)
|
||||
async def aendere_einheit(
|
||||
einheit_id: int, payload: EinheitUpdate, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
|
||||
) -> Einheit:
|
||||
einheit = await db.get(Einheit, einheit_id)
|
||||
if einheit is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Einheit nicht gefunden")
|
||||
for feld, wert in payload.model_dump(exclude_unset=True).items():
|
||||
setattr(einheit, feld, wert)
|
||||
try:
|
||||
await db.flush()
|
||||
except IntegrityError as exc:
|
||||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Ungültige Zuordnung") from exc
|
||||
return einheit
|
||||
|
||||
|
||||
# -- Qualifikationstyp ---------------------------------------------------------
|
||||
|
||||
@router.get("/qualifikationstypen", response_model=list[QualifikationstypRead])
|
||||
async def liste_qualifikationstypen(
|
||||
db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
|
||||
) -> list[Qualifikationstyp]:
|
||||
result = await db.execute(select(Qualifikationstyp))
|
||||
return list(result.scalars().all())
|
||||
|
||||
|
||||
@router.post("/qualifikationstypen", response_model=QualifikationstypRead, status_code=status.HTTP_201_CREATED)
|
||||
async def erstelle_qualifikationstyp(
|
||||
payload: QualifikationstypCreate, db: AsyncSession = Depends(get_db), _=Depends(_admin_only)
|
||||
) -> Qualifikationstyp:
|
||||
qualifikationstyp = Qualifikationstyp(**payload.model_dump())
|
||||
db.add(qualifikationstyp)
|
||||
await db.flush()
|
||||
return qualifikationstyp
|
||||
|
||||
|
||||
@router.patch("/qualifikationstypen/{qualifikationstyp_id}", response_model=QualifikationstypRead)
|
||||
async def aendere_qualifikationstyp(
|
||||
qualifikationstyp_id: int,
|
||||
payload: QualifikationstypUpdate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
_=Depends(_admin_only),
|
||||
) -> Qualifikationstyp:
|
||||
qualifikationstyp = await db.get(Qualifikationstyp, qualifikationstyp_id)
|
||||
if qualifikationstyp is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Qualifikationstyp nicht gefunden")
|
||||
for feld, wert in payload.model_dump(exclude_unset=True).items():
|
||||
setattr(qualifikationstyp, feld, wert)
|
||||
await db.flush()
|
||||
return qualifikationstyp
|
||||
|
||||
|
||||
# -- Benutzer-Qualifikation -----------------------------------------------------
|
||||
|
||||
@router.get("/benutzer/{benutzer_id}/qualifikationen", response_model=list[BenutzerQualifikationRead])
|
||||
async def liste_benutzer_qualifikationen(
|
||||
benutzer_id: int, db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
|
||||
) -> list[BenutzerQualifikation]:
|
||||
result = await db.execute(
|
||||
select(BenutzerQualifikation).where(BenutzerQualifikation.benutzer_id == benutzer_id)
|
||||
)
|
||||
return list(result.scalars().all())
|
||||
|
||||
|
||||
@router.post(
|
||||
"/benutzer/{benutzer_id}/qualifikationen",
|
||||
response_model=BenutzerQualifikationRead,
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
)
|
||||
async def erfasse_benutzer_qualifikation(
|
||||
benutzer_id: int,
|
||||
payload: BenutzerQualifikationCreate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
_=Depends(_admin_only),
|
||||
) -> BenutzerQualifikation:
|
||||
if payload.benutzer_id != benutzer_id:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="benutzer_id im Pfad und Body weichen ab")
|
||||
qualifikation = BenutzerQualifikation(**payload.model_dump())
|
||||
db.add(qualifikation)
|
||||
try:
|
||||
await db.flush()
|
||||
except IntegrityError as exc:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_409_CONFLICT, detail="Qualifikation mit diesem Erwerbsdatum existiert bereits"
|
||||
) from exc
|
||||
return qualifikation
|
||||
|
||||
|
||||
# -- Objekttyp-Qualifikationsanforderung -----------------------------------------
|
||||
|
||||
@router.get(
|
||||
"/objekttypen/{objekttyp_id}/qualifikationsanforderungen",
|
||||
response_model=list[ObjekttypQualifikationsanforderungRead],
|
||||
)
|
||||
async def liste_qualifikationsanforderungen(
|
||||
objekttyp_id: int, db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
|
||||
) -> list[ObjekttypQualifikationsanforderung]:
|
||||
result = await db.execute(
|
||||
select(ObjekttypQualifikationsanforderung).where(
|
||||
ObjekttypQualifikationsanforderung.objekttyp_id == objekttyp_id
|
||||
)
|
||||
)
|
||||
return list(result.scalars().all())
|
||||
|
||||
|
||||
@router.post(
|
||||
"/objekttypen/{objekttyp_id}/qualifikationsanforderungen",
|
||||
response_model=ObjekttypQualifikationsanforderungRead,
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
)
|
||||
async def erstelle_qualifikationsanforderung(
|
||||
objekttyp_id: int,
|
||||
payload: ObjekttypQualifikationsanforderungCreate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
_=Depends(_admin_only),
|
||||
) -> ObjekttypQualifikationsanforderung:
|
||||
if payload.objekttyp_id != objekttyp_id:
|
||||
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="objekttyp_id im Pfad und Body weichen ab")
|
||||
anforderung = ObjekttypQualifikationsanforderung(**payload.model_dump())
|
||||
db.add(anforderung)
|
||||
try:
|
||||
await db.flush()
|
||||
except IntegrityError as exc:
|
||||
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Anforderung existiert bereits") from exc
|
||||
return anforderung
|
||||
|
||||
|
||||
@router.delete(
|
||||
"/objekttypen/{objekttyp_id}/qualifikationsanforderungen/{qualifikationstyp_id}",
|
||||
status_code=status.HTTP_204_NO_CONTENT,
|
||||
)
|
||||
async def loesche_qualifikationsanforderung(
|
||||
objekttyp_id: int,
|
||||
qualifikationstyp_id: int,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
_=Depends(_admin_only),
|
||||
) -> None:
|
||||
anforderung = await db.get(
|
||||
ObjekttypQualifikationsanforderung, {"objekttyp_id": objekttyp_id, "qualifikationstyp_id": qualifikationstyp_id}
|
||||
)
|
||||
if anforderung is None:
|
||||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Anforderung nicht gefunden")
|
||||
await db.delete(anforderung)
|
||||
await db.flush()
|
||||
|
||||
|
||||
# -- Berechtigungsprüfung -------------------------------------------------------
|
||||
|
||||
@router.get("/objekte/{objekt_id}/berechtigung/{benutzer_id}", response_model=BerechtigungspruefungRead)
|
||||
async def pruefe_objekt_berechtigung(
|
||||
objekt_id: int, benutzer_id: int, db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
|
||||
) -> BerechtigungspruefungRead:
|
||||
"""Nutzer-Beispiel Personal-Modul: "wer darf dieses Fahrzeug fahren?"."""
|
||||
fehlende = await pruefe_berechtigung(db, benutzer_id=benutzer_id, objekt_id=objekt_id)
|
||||
return BerechtigungspruefungRead(
|
||||
berechtigt=len(fehlende) == 0,
|
||||
fehlende_qualifikationstypen=list(fehlende),
|
||||
)
|
||||
@@ -44,6 +44,7 @@ class Benutzer(Base):
|
||||
passwort_hash: Mapped[str] = mapped_column(String, nullable=False)
|
||||
aktiv: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
|
||||
email: Mapped[str | None] = mapped_column(String) # Sprint 6 / Karte 05 (Migration 0003)
|
||||
einheit_id: Mapped[int | None] = mapped_column(ForeignKey("einheit.id")) # Personal-Modul (Migration 0012)
|
||||
|
||||
rollen: Mapped[list["BenutzerRolle"]] = relationship(back_populates="benutzer", lazy="selectin")
|
||||
|
||||
|
||||
@@ -40,3 +40,6 @@ class Objekt(Base):
|
||||
fahrzeug_id: Mapped[int | None] = mapped_column(
|
||||
ForeignKey("objekt.id", ondelete="SET NULL")
|
||||
)
|
||||
# Personal-Modul (Migration 0012): Zuordnung zu einer Organisationseinheit
|
||||
# (Zug/Gruppe), additiv/optional wie fahrzeug_id.
|
||||
einheit_id: Mapped[int | None] = mapped_column(ForeignKey("einheit.id"))
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
import enum
|
||||
import uuid
|
||||
from datetime import date
|
||||
|
||||
from sqlalchemy import CheckConstraint, Date, ForeignKey, String, UniqueConstraint
|
||||
from sqlalchemy.dialects.postgresql import ENUM as PgEnum, UUID
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.db.base import Base
|
||||
|
||||
|
||||
class Qualifikationskategorie(str, enum.Enum):
|
||||
fuehrerschein = "fuehrerschein"
|
||||
lehrgang = "lehrgang"
|
||||
berechtigung = "berechtigung"
|
||||
|
||||
|
||||
qualifikationskategorie_pg = PgEnum(
|
||||
Qualifikationskategorie, name="qualifikationskategorie", create_type=False
|
||||
)
|
||||
|
||||
|
||||
class Einheit(Base):
|
||||
"""Roadmap-Erweiterung (Personal-Modul): Organisationseinheit (Zug/Gruppe),
|
||||
self-referenzierend für Hierarchie (analog Kategorie.ueberkategorie_id).
|
||||
Bewusst eigenständig statt an Standort gekoppelt - eine Einheit kann
|
||||
ortsübergreifend sein, ein Standort mehrere Einheiten beherbergen."""
|
||||
|
||||
__tablename__ = "einheit"
|
||||
|
||||
id: Mapped[int] = mapped_column(primary_key=True)
|
||||
name: Mapped[str] = mapped_column(String, nullable=False)
|
||||
uebergeordnete_einheit_id: Mapped[int | None] = mapped_column(ForeignKey("einheit.id"))
|
||||
standort_id: Mapped[int | None] = mapped_column(ForeignKey("standort.id"))
|
||||
|
||||
__table_args__ = (
|
||||
CheckConstraint("uebergeordnete_einheit_id <> id", name="einheit_kein_selbstbezug"),
|
||||
)
|
||||
|
||||
|
||||
class Qualifikationstyp(Base):
|
||||
"""Führerschein/Lehrgang/Berechtigung als ein Stammdaten-Konzept, damit
|
||||
"welche Qualifikation braucht Objekttyp X" generisch bleibt (kein separates
|
||||
Führerschein-Feld am Fahrzeug nötig, Karte-Nachtrag Personal-Modul)."""
|
||||
|
||||
__tablename__ = "qualifikationstyp"
|
||||
|
||||
id: Mapped[int] = mapped_column(primary_key=True)
|
||||
name: Mapped[str] = mapped_column(String, nullable=False)
|
||||
kategorie: Mapped[Qualifikationskategorie] = mapped_column(
|
||||
qualifikationskategorie_pg, nullable=False
|
||||
)
|
||||
# NULL = unbefristet (z.B. manche Berechtigungen), sonst Gültigkeitsdauer in
|
||||
# Monaten ab erworben_am - Ablauf wird nicht hier, sondern je
|
||||
# BenutzerQualifikation über gueltig_bis geführt (individuelles Datum je
|
||||
# Nachweis, nicht rein rechnerisch aus dem Typ abgeleitet).
|
||||
gueltigkeit_monate: Mapped[int | None] = mapped_column()
|
||||
|
||||
|
||||
class BenutzerQualifikation(Base):
|
||||
__tablename__ = "benutzer_qualifikation"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
benutzer_id: Mapped[int] = mapped_column(ForeignKey("benutzer.id"), nullable=False)
|
||||
qualifikationstyp_id: Mapped[int] = mapped_column(ForeignKey("qualifikationstyp.id"), nullable=False)
|
||||
erworben_am: Mapped[date] = mapped_column(Date, nullable=False)
|
||||
gueltig_bis: Mapped[date | None] = mapped_column(Date)
|
||||
nachweis_nummer: Mapped[str | None] = mapped_column(String)
|
||||
|
||||
__table_args__ = (
|
||||
UniqueConstraint(
|
||||
"benutzer_id", "qualifikationstyp_id", "erworben_am", name="uq_benutzer_qualifikation"
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class ObjekttypQualifikationsanforderung(Base):
|
||||
"""M:N: welche Qualifikationstypen braucht man, um Objekte dieses Objekttyps
|
||||
zu bedienen/fahren (Nutzer-Beispiel: "wer darf GW-San 01 fahren?")."""
|
||||
|
||||
__tablename__ = "objekttyp_qualifikationsanforderung"
|
||||
|
||||
objekttyp_id: Mapped[int] = mapped_column(ForeignKey("objekttyp.id"), primary_key=True)
|
||||
qualifikationstyp_id: Mapped[int] = mapped_column(
|
||||
ForeignKey("qualifikationstyp.id"), primary_key=True
|
||||
)
|
||||
@@ -9,6 +9,7 @@ class BenutzerCreate(BaseModel):
|
||||
passwort: str
|
||||
email: str | None = None
|
||||
rollen: list[RolleTyp] = []
|
||||
einheit_id: int | None = None
|
||||
|
||||
|
||||
class BenutzerRead(BaseModel):
|
||||
@@ -19,6 +20,7 @@ class BenutzerRead(BaseModel):
|
||||
email: str | None
|
||||
aktiv: bool
|
||||
rollen: list[str]
|
||||
einheit_id: int | None
|
||||
|
||||
@classmethod
|
||||
def from_orm_benutzer(cls, benutzer) -> "BenutzerRead":
|
||||
@@ -29,6 +31,7 @@ class BenutzerRead(BaseModel):
|
||||
email=benutzer.email,
|
||||
aktiv=benutzer.aktiv,
|
||||
rollen=benutzer.rollen_namen,
|
||||
einheit_id=benutzer.einheit_id,
|
||||
)
|
||||
|
||||
|
||||
@@ -37,3 +40,4 @@ class BenutzerUpdate(BaseModel):
|
||||
email: str | None = None
|
||||
aktiv: bool | None = None
|
||||
rollen: list[RolleTyp] | None = None
|
||||
einheit_id: int | None = None
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
import uuid
|
||||
from datetime import date
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
from app.models.personal import Qualifikationskategorie
|
||||
|
||||
|
||||
class EinheitCreate(BaseModel):
|
||||
name: str
|
||||
uebergeordnete_einheit_id: int | None = None
|
||||
standort_id: int | None = None
|
||||
|
||||
|
||||
class EinheitRead(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
id: int
|
||||
name: str
|
||||
uebergeordnete_einheit_id: int | None
|
||||
standort_id: int | None
|
||||
|
||||
|
||||
class EinheitUpdate(BaseModel):
|
||||
name: str | None = None
|
||||
uebergeordnete_einheit_id: int | None = None
|
||||
standort_id: int | None = None
|
||||
|
||||
|
||||
class QualifikationstypCreate(BaseModel):
|
||||
name: str
|
||||
kategorie: Qualifikationskategorie
|
||||
gueltigkeit_monate: int | None = None
|
||||
|
||||
|
||||
class QualifikationstypRead(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
id: int
|
||||
name: str
|
||||
kategorie: Qualifikationskategorie
|
||||
gueltigkeit_monate: int | None
|
||||
|
||||
|
||||
class QualifikationstypUpdate(BaseModel):
|
||||
name: str | None = None
|
||||
kategorie: Qualifikationskategorie | None = None
|
||||
gueltigkeit_monate: int | None = None
|
||||
|
||||
|
||||
class BenutzerQualifikationCreate(BaseModel):
|
||||
benutzer_id: int
|
||||
qualifikationstyp_id: int
|
||||
erworben_am: date
|
||||
gueltig_bis: date | None = None
|
||||
nachweis_nummer: str | None = None
|
||||
|
||||
|
||||
class BenutzerQualifikationRead(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
id: uuid.UUID
|
||||
benutzer_id: int
|
||||
qualifikationstyp_id: int
|
||||
erworben_am: date
|
||||
gueltig_bis: date | None
|
||||
nachweis_nummer: str | None
|
||||
|
||||
|
||||
class ObjekttypQualifikationsanforderungCreate(BaseModel):
|
||||
objekttyp_id: int
|
||||
qualifikationstyp_id: int
|
||||
|
||||
|
||||
class ObjekttypQualifikationsanforderungRead(BaseModel):
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
objekttyp_id: int
|
||||
qualifikationstyp_id: int
|
||||
|
||||
|
||||
class BerechtigungspruefungRead(BaseModel):
|
||||
"""Antwort auf "darf Benutzer X Objekt Y bedienen/fahren?" (Nutzer-Beispiel)."""
|
||||
|
||||
berechtigt: bool
|
||||
fehlende_qualifikationstypen: list[QualifikationstypRead]
|
||||
@@ -0,0 +1,53 @@
|
||||
from datetime import date
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models.objekt import Objekt
|
||||
from app.models.personal import (
|
||||
BenutzerQualifikation,
|
||||
ObjekttypQualifikationsanforderung,
|
||||
Qualifikationstyp,
|
||||
)
|
||||
|
||||
|
||||
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
|
||||
Benutzer nicht (mehr) gültig nachgewiesen hat - leere Liste = berechtigt."""
|
||||
objekt = await db.get(Objekt, objekt_id)
|
||||
if objekt is None:
|
||||
return []
|
||||
|
||||
erforderlich = (
|
||||
(
|
||||
await db.execute(
|
||||
select(Qualifikationstyp)
|
||||
.join(
|
||||
ObjekttypQualifikationsanforderung,
|
||||
ObjekttypQualifikationsanforderung.qualifikationstyp_id == Qualifikationstyp.id,
|
||||
)
|
||||
.where(ObjekttypQualifikationsanforderung.objekttyp_id == objekt.objekttyp_id)
|
||||
)
|
||||
)
|
||||
.scalars()
|
||||
.all()
|
||||
)
|
||||
if not erforderlich:
|
||||
return []
|
||||
|
||||
heute = date.today()
|
||||
gueltige_ids = set(
|
||||
(
|
||||
await db.execute(
|
||||
select(BenutzerQualifikation.qualifikationstyp_id).where(
|
||||
BenutzerQualifikation.benutzer_id == benutzer_id,
|
||||
(BenutzerQualifikation.gueltig_bis.is_(None))
|
||||
| (BenutzerQualifikation.gueltig_bis >= heute),
|
||||
)
|
||||
)
|
||||
)
|
||||
.scalars()
|
||||
.all()
|
||||
)
|
||||
return [q for q in erforderlich if q.id not in gueltige_ids]
|
||||
@@ -0,0 +1,139 @@
|
||||
from datetime import date, timedelta
|
||||
|
||||
import pytest
|
||||
|
||||
from tests.conftest import auth_header, login
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_einheit_anlegen_und_hierarchie(client, admin_user):
|
||||
token = await login(client, "admin1")
|
||||
zug = await client.post("/api/v1/einheiten", json={"name": "Sanitätszug 1"}, headers=auth_header(token))
|
||||
assert zug.status_code == 201
|
||||
zug_id = zug.json()["id"]
|
||||
|
||||
gruppe = await client.post(
|
||||
"/api/v1/einheiten",
|
||||
json={"name": "Gruppe 1", "uebergeordnete_einheit_id": zug_id},
|
||||
headers=auth_header(token),
|
||||
)
|
||||
assert gruppe.status_code == 201
|
||||
assert gruppe.json()["uebergeordnete_einheit_id"] == zug_id
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_mitarbeiter_darf_einheit_nicht_anlegen(client, mitarbeiter_user):
|
||||
token = await login(client, "mitarbeiter1")
|
||||
response = await client.post("/api/v1/einheiten", json={"name": "X"}, headers=auth_header(token))
|
||||
assert response.status_code == 403
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_qualifikationstyp_anlegen(client, admin_user):
|
||||
token = await login(client, "admin1")
|
||||
response = await client.post(
|
||||
"/api/v1/qualifikationstypen",
|
||||
json={"name": "Führerschein C1", "kategorie": "fuehrerschein"},
|
||||
headers=auth_header(token),
|
||||
)
|
||||
assert response.status_code == 201
|
||||
assert response.json()["gueltigkeit_monate"] is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_wer_darf_fahrzeug_fahren(
|
||||
client, db_session, objekttyp_factory, standort_factory, admin_user, mitarbeiter_user, hauptserver_id
|
||||
):
|
||||
"""Nutzer-Beispiel Personal-Modul: Objekttyp verlangt Führerschein C1,
|
||||
Benutzer ohne gültigen Nachweis darf nicht, mit gültigem Nachweis schon."""
|
||||
from app.services.vorlagen import erstelle_vorlage
|
||||
from app.services.objekte import objekt_aus_vorlage
|
||||
|
||||
objekttyp = await objekttyp_factory("GW-San", ist_zugfahrzeug=True)
|
||||
standort = await standort_factory("Wache-Personal")
|
||||
vorlage = await erstelle_vorlage(db_session, objekttyp_id=objekttyp.id, name="GW-San Standard", positionen=[])
|
||||
fahrzeug = await objekt_aus_vorlage(
|
||||
db_session,
|
||||
code="GW-SAN-01",
|
||||
name="GW-San 01",
|
||||
standort_id=standort.id,
|
||||
vorlage=vorlage,
|
||||
zustaendiger_server_id=hauptserver_id,
|
||||
)
|
||||
|
||||
token = await login(client, "admin1")
|
||||
quali = await client.post(
|
||||
"/api/v1/qualifikationstypen",
|
||||
json={"name": "Führerschein C1", "kategorie": "fuehrerschein"},
|
||||
headers=auth_header(token),
|
||||
)
|
||||
quali_id = quali.json()["id"]
|
||||
|
||||
await client.post(
|
||||
f"/api/v1/objekttypen/{objekttyp.id}/qualifikationsanforderungen",
|
||||
json={"objekttyp_id": objekttyp.id, "qualifikationstyp_id": quali_id},
|
||||
headers=auth_header(token),
|
||||
)
|
||||
|
||||
mitarbeiter_id = mitarbeiter_user.id
|
||||
|
||||
# ohne Nachweis: nicht berechtigt
|
||||
pruefung = await client.get(
|
||||
f"/api/v1/objekte/{fahrzeug.id}/berechtigung/{mitarbeiter_id}", headers=auth_header(token)
|
||||
)
|
||||
assert pruefung.json()["berechtigt"] is False
|
||||
assert len(pruefung.json()["fehlende_qualifikationstypen"]) == 1
|
||||
|
||||
# abgelaufener Nachweis zählt nicht
|
||||
await client.post(
|
||||
f"/api/v1/benutzer/{mitarbeiter_id}/qualifikationen",
|
||||
json={
|
||||
"benutzer_id": mitarbeiter_id,
|
||||
"qualifikationstyp_id": quali_id,
|
||||
"erworben_am": (date.today() - timedelta(days=1000)).isoformat(),
|
||||
"gueltig_bis": (date.today() - timedelta(days=1)).isoformat(),
|
||||
},
|
||||
headers=auth_header(token),
|
||||
)
|
||||
abgelaufen = await client.get(
|
||||
f"/api/v1/objekte/{fahrzeug.id}/berechtigung/{mitarbeiter_id}", headers=auth_header(token)
|
||||
)
|
||||
assert abgelaufen.json()["berechtigt"] is False
|
||||
|
||||
# gültiger Nachweis: berechtigt
|
||||
await client.post(
|
||||
f"/api/v1/benutzer/{mitarbeiter_id}/qualifikationen",
|
||||
json={
|
||||
"benutzer_id": mitarbeiter_id,
|
||||
"qualifikationstyp_id": quali_id,
|
||||
"erworben_am": date.today().isoformat(),
|
||||
"gueltig_bis": None,
|
||||
},
|
||||
headers=auth_header(token),
|
||||
)
|
||||
berechtigt = await client.get(
|
||||
f"/api/v1/objekte/{fahrzeug.id}/berechtigung/{mitarbeiter_id}", headers=auth_header(token)
|
||||
)
|
||||
assert berechtigt.json()["berechtigt"] is True
|
||||
assert berechtigt.json()["fehlende_qualifikationstypen"] == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_benutzer_einheit_zuordnung(client, admin_user):
|
||||
token = await login(client, "admin1")
|
||||
einheit = await client.post("/api/v1/einheiten", json={"name": "Zug 2"}, headers=auth_header(token))
|
||||
einheit_id = einheit.json()["id"]
|
||||
|
||||
benutzer = await client.post(
|
||||
"/api/v1/benutzer",
|
||||
json={"name": "Neuer Helfer", "login": "helfer1", "passwort": "test-passwort-123", "einheit_id": einheit_id},
|
||||
headers=auth_header(token),
|
||||
)
|
||||
assert benutzer.status_code == 201
|
||||
assert benutzer.json()["einheit_id"] == einheit_id
|
||||
|
||||
benutzer_id = benutzer.json()["id"]
|
||||
geloest = await client.patch(
|
||||
f"/api/v1/benutzer/{benutzer_id}", json={"einheit_id": None}, headers=auth_header(token)
|
||||
)
|
||||
assert geloest.json()["einheit_id"] is None
|
||||
@@ -224,3 +224,63 @@ Keine Commits in dieser Session.
|
||||
- frontend/src/pages/LoginPage.tsx | 11 ++++++++++-
|
||||
|
||||
---
|
||||
## 2026-09-05 10:51 – 11:01 (9m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** frontend
|
||||
|
||||
### Commits
|
||||
- c3f141f feat(objekt): letzte abgeschlossene Kontrolle je Objekt anzeigen
|
||||
|
||||
### Geänderte Dateien
|
||||
- DEVLOG.md | 202 +++
|
||||
- backend/app/api/v1/endpoints/objekte.py | 46 +-
|
||||
- backend/app/schemas/objekt.py | 3 +-
|
||||
- backend/app/services/objekte.py | 20 +-
|
||||
- backend/tests/test_objekte.py | 32 +
|
||||
- frontend/DEVLOG.md | 33 +
|
||||
- frontend/package-lock.json | 6264 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- frontend/src/api/types.ts | 1 +
|
||||
- frontend/src/pages/ObjektListPage.tsx | 5 +
|
||||
- frontend/src/pages/admin/ObjektSection.tsx | 7 +
|
||||
|
||||
---
|
||||
## 2026-09-05 11:04 – 11:04 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** frontend
|
||||
|
||||
### Commits
|
||||
Keine Commits in dieser Session.
|
||||
|
||||
### Geänderte Dateien
|
||||
- DEVLOG.md | 202 +++
|
||||
- backend/app/api/v1/endpoints/objekte.py | 46 +-
|
||||
- backend/app/schemas/objekt.py | 3 +-
|
||||
- backend/app/services/objekte.py | 20 +-
|
||||
- backend/tests/test_objekte.py | 32 +
|
||||
- frontend/DEVLOG.md | 33 +
|
||||
- frontend/package-lock.json | 6264 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- frontend/src/api/types.ts | 1 +
|
||||
- frontend/src/pages/ObjektListPage.tsx | 5 +
|
||||
- frontend/src/pages/admin/ObjektSection.tsx | 7 +
|
||||
|
||||
---
|
||||
## 2026-09-05 11:07 – 11:07 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** frontend
|
||||
|
||||
### Commits
|
||||
Keine Commits in dieser Session.
|
||||
|
||||
### Geänderte Dateien
|
||||
- DEVLOG.md | 202 +++
|
||||
- backend/app/api/v1/endpoints/objekte.py | 46 +-
|
||||
- backend/app/schemas/objekt.py | 3 +-
|
||||
- backend/app/services/objekte.py | 20 +-
|
||||
- backend/tests/test_objekte.py | 32 +
|
||||
- frontend/DEVLOG.md | 33 +
|
||||
- frontend/package-lock.json | 6264 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- frontend/src/api/types.ts | 1 +
|
||||
- frontend/src/pages/ObjektListPage.tsx | 5 +
|
||||
- frontend/src/pages/admin/ObjektSection.tsx | 7 +
|
||||
|
||||
---
|
||||
|
||||
@@ -185,4 +185,30 @@ export interface Benutzer {
|
||||
email: string | null;
|
||||
aktiv: boolean;
|
||||
rollen: string[];
|
||||
einheit_id: number | null;
|
||||
}
|
||||
|
||||
export interface Einheit {
|
||||
id: number;
|
||||
name: string;
|
||||
uebergeordnete_einheit_id: number | null;
|
||||
standort_id: number | null;
|
||||
}
|
||||
|
||||
export type Qualifikationskategorie = "fuehrerschein" | "lehrgang" | "berechtigung";
|
||||
|
||||
export interface Qualifikationstyp {
|
||||
id: number;
|
||||
name: string;
|
||||
kategorie: Qualifikationskategorie;
|
||||
gueltigkeit_monate: number | null;
|
||||
}
|
||||
|
||||
export interface BenutzerQualifikation {
|
||||
id: string;
|
||||
benutzer_id: number;
|
||||
qualifikationstyp_id: number;
|
||||
erworben_am: string;
|
||||
gueltig_bis: string | null;
|
||||
nachweis_nummer: string | null;
|
||||
}
|
||||
|
||||
@@ -2,9 +2,10 @@ import { useEffect, useState } from "react";
|
||||
|
||||
import { apiRequest } from "../api/client";
|
||||
import { useAuth } from "../auth/AuthContext";
|
||||
import type { Benutzer, Bereich, Beladungsvorlage, Fach, Kategorie, Material, Objekt, Objekttyp, Standort } from "../api/types";
|
||||
import type { Benutzer, Bereich, Beladungsvorlage, Einheit, Fach, Kategorie, Material, Objekt, Objekttyp, Qualifikationstyp, Standort } from "../api/types";
|
||||
import { BenutzerSection } from "./admin/BenutzerSection";
|
||||
import { BereichSection } from "./admin/BereichSection";
|
||||
import { EinheitSection } from "./admin/EinheitSection";
|
||||
import { EskalationSection } from "./admin/EskalationSection";
|
||||
import { FachSection } from "./admin/FachSection";
|
||||
import { HistorieSection } from "./admin/HistorieSection";
|
||||
@@ -13,6 +14,7 @@ import { KontrollverantwortungSection } from "./admin/KontrollverantwortungSecti
|
||||
import { MaterialSection } from "./admin/MaterialSection";
|
||||
import { ObjektSection } from "./admin/ObjektSection";
|
||||
import { ObjekttypSection } from "./admin/ObjekttypSection";
|
||||
import { QualifikationSection } from "./admin/QualifikationSection";
|
||||
import { StandortSection } from "./admin/StandortSection";
|
||||
import { VorlageSection } from "./admin/VorlageSection";
|
||||
import { ZustaendigkeitSection } from "./admin/ZustaendigkeitSection";
|
||||
@@ -27,7 +29,8 @@ type Tab =
|
||||
| "historie"
|
||||
| "eskalation"
|
||||
| "kontrollverantwortung"
|
||||
| "zustaendigkeit";
|
||||
| "zustaendigkeit"
|
||||
| "personal";
|
||||
|
||||
// Deckt sich mit den require_roles()-Gates der jeweiligen Backend-Endpunkte
|
||||
// (Rollen-Vorgabe: Material-/Leitungsverantwortliche sahen bisher exakt
|
||||
@@ -52,6 +55,7 @@ const TABS: { key: Tab; label: string; rollen: ("administration" | "materialvera
|
||||
rollen: ["administration", "materialverantwortlicher", "leitungsverantwortlicher"],
|
||||
},
|
||||
{ key: "eskalation", label: "Eskalation", rollen: ["administration"] },
|
||||
{ key: "personal", label: "Personal", rollen: ["administration"] },
|
||||
];
|
||||
|
||||
/**
|
||||
@@ -75,6 +79,8 @@ export function AdminPage() {
|
||||
const [materialien, setMaterialien] = useState<Material[]>([]);
|
||||
const [benutzer, setBenutzer] = useState<Benutzer[]>([]);
|
||||
const [faecher, setFaecher] = useState<Fach[]>([]);
|
||||
const [einheiten, setEinheiten] = useState<Einheit[]>([]);
|
||||
const [qualifikationstypen, setQualifikationstypen] = useState<Qualifikationstyp[]>([]);
|
||||
const [fehler, setFehler] = useState<string | null>(null);
|
||||
const [laedt, setLaedt] = useState(true);
|
||||
const [tab, setTab] = useState<Tab | null>(null);
|
||||
@@ -86,7 +92,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] = await Promise.allSettled([
|
||||
const [be, ka, ot, s, v, o, m, b, f, ei, qt] = await Promise.allSettled([
|
||||
apiRequest<Bereich[]>("/bereiche"),
|
||||
apiRequest<Kategorie[]>("/kategorien"),
|
||||
apiRequest<Objekttyp[]>("/objekttypen"),
|
||||
@@ -96,6 +102,8 @@ export function AdminPage() {
|
||||
apiRequest<Material[]>("/materialien"),
|
||||
apiRequest<Benutzer[]>("/benutzer"),
|
||||
apiRequest<Fach[]>("/faecher"),
|
||||
apiRequest<Einheit[]>("/einheiten"),
|
||||
apiRequest<Qualifikationstyp[]>("/qualifikationstypen"),
|
||||
]);
|
||||
const wert = <T,>(r: PromiseSettledResult<T[]>): T[] => (r.status === "fulfilled" ? r.value : []);
|
||||
setBereiche(wert(be));
|
||||
@@ -107,6 +115,8 @@ export function AdminPage() {
|
||||
setMaterialien(wert(m));
|
||||
setBenutzer(wert(b));
|
||||
setFaecher(wert(f));
|
||||
setEinheiten(wert(ei));
|
||||
setQualifikationstypen(wert(qt));
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
@@ -193,7 +203,7 @@ export function AdminPage() {
|
||||
<StandortSection standorte={standorte} onGeaendert={ladeAlles} onFehler={setFehler} />
|
||||
)}
|
||||
{aktiverTab === "benutzer" && (
|
||||
<BenutzerSection benutzer={benutzer} onGeaendert={ladeAlles} onFehler={setFehler} />
|
||||
<BenutzerSection benutzer={benutzer} einheiten={einheiten} onGeaendert={ladeAlles} onFehler={setFehler} />
|
||||
)}
|
||||
{aktiverTab === "zustaendigkeit" && (
|
||||
<ZustaendigkeitSection standorte={standorte} objekte={objekte} benutzer={benutzer} onFehler={setFehler} />
|
||||
@@ -203,6 +213,17 @@ export function AdminPage() {
|
||||
)}
|
||||
{aktiverTab === "historie" && <HistorieSection onFehler={setFehler} />}
|
||||
{aktiverTab === "eskalation" && <EskalationSection onFehler={setFehler} />}
|
||||
{aktiverTab === "personal" && (
|
||||
<>
|
||||
<EinheitSection einheiten={einheiten} standorte={standorte} onGeaendert={ladeAlles} onFehler={setFehler} />
|
||||
<QualifikationSection
|
||||
qualifikationstypen={qualifikationstypen}
|
||||
benutzer={benutzer}
|
||||
onGeaendert={ladeAlles}
|
||||
onFehler={setFehler}
|
||||
/>
|
||||
</>
|
||||
)}
|
||||
{aktiverTab === null && <p className="text-muted">Keine Bereiche für deine Rolle verfügbar.</p>}
|
||||
</main>
|
||||
);
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
import { useState } from "react";
|
||||
|
||||
import { apiRequest } from "../../api/client";
|
||||
import type { Benutzer, Rolle } from "../../api/types";
|
||||
import type { Benutzer, Einheit, Rolle } from "../../api/types";
|
||||
|
||||
interface Props {
|
||||
benutzer: Benutzer[];
|
||||
einheiten: Einheit[];
|
||||
onGeaendert: () => Promise<void>;
|
||||
onFehler: (text: string) => void;
|
||||
}
|
||||
@@ -16,18 +17,26 @@ const ALLE_ROLLEN: Rolle[] = [
|
||||
"administration",
|
||||
];
|
||||
|
||||
export function BenutzerSection({ benutzer, onGeaendert, onFehler }: Props) {
|
||||
export function BenutzerSection({ benutzer, einheiten, 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 [rollen, setRollen] = useState<Rolle[]>(["mitarbeiter"]);
|
||||
const [wirdAngelegt, setWirdAngelegt] = useState(false);
|
||||
const [bearbeiteteId, setBearbeiteteId] = useState<number | null>(null);
|
||||
const [bearbeitungsName, setBearbeitungsName] = useState("");
|
||||
const [bearbeitungsEmail, setBearbeitungsEmail] = useState("");
|
||||
const [bearbeitungsEinheitId, setBearbeitungsEinheitId] = useState<number | "">("");
|
||||
const [bearbeitungsRollen, setBearbeitungsRollen] = useState<Rolle[]>([]);
|
||||
|
||||
function einheitName(id: number | null): string {
|
||||
if (id === null) return "";
|
||||
const e = einheiten.find((x) => x.id === id);
|
||||
return e ? e.name : `#${id}`;
|
||||
}
|
||||
|
||||
function rolleUmschalten(rolle: Rolle) {
|
||||
setRollen((bisherige) =>
|
||||
bisherige.includes(rolle) ? bisherige.filter((r) => r !== rolle) : [...bisherige, rolle]
|
||||
@@ -39,12 +48,13 @@ export function BenutzerSection({ benutzer, onGeaendert, onFehler }: Props) {
|
||||
try {
|
||||
await apiRequest("/benutzer", {
|
||||
method: "POST",
|
||||
body: { name, login, passwort, email: email || null, rollen },
|
||||
body: { name, login, passwort, email: email || null, einheit_id: einheitId === "" ? null : einheitId, rollen },
|
||||
});
|
||||
setName("");
|
||||
setLogin("");
|
||||
setPasswort("");
|
||||
setEmail("");
|
||||
setEinheitId("");
|
||||
setRollen(["mitarbeiter"]);
|
||||
await onGeaendert();
|
||||
} catch {
|
||||
@@ -67,6 +77,7 @@ export function BenutzerSection({ benutzer, onGeaendert, onFehler }: Props) {
|
||||
setBearbeiteteId(b.id);
|
||||
setBearbeitungsName(b.name);
|
||||
setBearbeitungsEmail(b.email ?? "");
|
||||
setBearbeitungsEinheitId(b.einheit_id ?? "");
|
||||
setBearbeitungsRollen(b.rollen as Rolle[]);
|
||||
}
|
||||
|
||||
@@ -80,7 +91,12 @@ export function BenutzerSection({ benutzer, onGeaendert, onFehler }: Props) {
|
||||
try {
|
||||
await apiRequest(`/benutzer/${id}`, {
|
||||
method: "PATCH",
|
||||
body: { name: bearbeitungsName, email: bearbeitungsEmail || null, rollen: bearbeitungsRollen },
|
||||
body: {
|
||||
name: bearbeitungsName,
|
||||
email: bearbeitungsEmail || null,
|
||||
einheit_id: bearbeitungsEinheitId === "" ? null : bearbeitungsEinheitId,
|
||||
rollen: bearbeitungsRollen,
|
||||
},
|
||||
});
|
||||
setBearbeiteteId(null);
|
||||
await onGeaendert();
|
||||
@@ -109,6 +125,14 @@ export function BenutzerSection({ benutzer, onGeaendert, onFehler }: Props) {
|
||||
onChange={(e) => setEmail(e.target.value)}
|
||||
placeholder="E-Mail (optional)"
|
||||
/>
|
||||
<select className="input" value={einheitId} onChange={(e) => setEinheitId(Number(e.target.value) || "")}>
|
||||
<option value="">Keine Einheit</option>
|
||||
{einheiten.map((e) => (
|
||||
<option key={e.id} value={e.id}>
|
||||
{e.name}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</div>
|
||||
<div className="row" style={{ flexWrap: "wrap", gap: "0.5rem", marginBottom: "0.75rem" }}>
|
||||
{ALLE_ROLLEN.map((r) => (
|
||||
@@ -145,6 +169,18 @@ export function BenutzerSection({ benutzer, onGeaendert, onFehler }: Props) {
|
||||
onChange={(e) => setBearbeitungsEmail(e.target.value)}
|
||||
placeholder="E-Mail"
|
||||
/>
|
||||
<select
|
||||
className="input"
|
||||
value={bearbeitungsEinheitId}
|
||||
onChange={(e) => setBearbeitungsEinheitId(Number(e.target.value) || "")}
|
||||
>
|
||||
<option value="">Keine Einheit</option>
|
||||
{einheiten.map((e) => (
|
||||
<option key={e.id} value={e.id}>
|
||||
{e.name}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</div>
|
||||
<div className="row" style={{ flexWrap: "wrap", gap: "0.5rem" }}>
|
||||
{ALLE_ROLLEN.map((r) => (
|
||||
@@ -171,6 +207,7 @@ export function BenutzerSection({ benutzer, onGeaendert, onFehler }: Props) {
|
||||
<div className="row-between">
|
||||
<span>
|
||||
<strong>{b.name}</strong> ({b.login}) – {b.rollen.join(", ")}
|
||||
{b.einheit_id !== null && ` – ${einheitName(b.einheit_id)}`}
|
||||
{!b.aktiv && " – deaktiviert"}
|
||||
</span>
|
||||
<div className="row">
|
||||
|
||||
@@ -0,0 +1,136 @@
|
||||
import { useState } from "react";
|
||||
|
||||
import { apiRequest } from "../../api/client";
|
||||
import type { Einheit, Standort } from "../../api/types";
|
||||
|
||||
interface Props {
|
||||
einheiten: Einheit[];
|
||||
standorte: Standort[];
|
||||
onGeaendert: () => Promise<void>;
|
||||
onFehler: (text: string) => void;
|
||||
}
|
||||
|
||||
// Personal-Modul (Karte-Nachtrag): Organisationseinheit (Zug/Gruppe),
|
||||
// self-referenzierend für Hierarchie (analog Kategorie/Objekttyp-Muster).
|
||||
export function EinheitSection({ einheiten, standorte, onGeaendert, onFehler }: Props) {
|
||||
const [name, setName] = useState("");
|
||||
const [uebergeordneteId, setUebergeordneteId] = useState<number | "">("");
|
||||
const [standortId, setStandortId] = useState<number | "">("");
|
||||
const [wirdAngelegt, setWirdAngelegt] = useState(false);
|
||||
const [bearbeiteteId, setBearbeiteteId] = useState<number | null>(null);
|
||||
const [bearbeitungsName, setBearbeitungsName] = useState("");
|
||||
|
||||
function einheitName(id: number | null): string {
|
||||
if (id === null) return "–";
|
||||
const e = einheiten.find((x) => x.id === id);
|
||||
return e ? e.name : `#${id}`;
|
||||
}
|
||||
|
||||
async function anlegen() {
|
||||
setWirdAngelegt(true);
|
||||
try {
|
||||
await apiRequest("/einheiten", {
|
||||
method: "POST",
|
||||
body: {
|
||||
name,
|
||||
uebergeordnete_einheit_id: uebergeordneteId === "" ? null : uebergeordneteId,
|
||||
standort_id: standortId === "" ? null : standortId,
|
||||
},
|
||||
});
|
||||
setName("");
|
||||
setUebergeordneteId("");
|
||||
setStandortId("");
|
||||
await onGeaendert();
|
||||
} catch {
|
||||
onFehler("Einheit konnte nicht angelegt werden.");
|
||||
} finally {
|
||||
setWirdAngelegt(false);
|
||||
}
|
||||
}
|
||||
|
||||
function bearbeiten(e: Einheit) {
|
||||
setBearbeiteteId(e.id);
|
||||
setBearbeitungsName(e.name);
|
||||
}
|
||||
|
||||
async function speichern(id: number) {
|
||||
try {
|
||||
await apiRequest(`/einheiten/${id}`, { method: "PATCH", body: { name: bearbeitungsName } });
|
||||
setBearbeiteteId(null);
|
||||
await onGeaendert();
|
||||
} catch {
|
||||
onFehler("Einheit konnte nicht geändert werden.");
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<section className="section">
|
||||
<h2>Einheit anlegen</h2>
|
||||
<div className="card">
|
||||
<div className="stack" style={{ marginBottom: einheiten.length ? "1rem" : 0 }}>
|
||||
<div className="row">
|
||||
<input className="input" value={name} onChange={(e) => setName(e.target.value)} placeholder="Name (z.B. Sanitätszug 1)" />
|
||||
<select
|
||||
className="input"
|
||||
value={uebergeordneteId}
|
||||
onChange={(e) => setUebergeordneteId(Number(e.target.value) || "")}
|
||||
>
|
||||
<option value="">Keine übergeordnete Einheit</option>
|
||||
{einheiten.map((e) => (
|
||||
<option key={e.id} value={e.id}>
|
||||
{e.name}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
<select className="input" value={standortId} onChange={(e) => setStandortId(Number(e.target.value) || "")}>
|
||||
<option value="">Kein Standort</option>
|
||||
{standorte.map((s) => (
|
||||
<option key={s.id} value={s.id}>
|
||||
{s.name}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
<button className="btn btn-primary" onClick={anlegen} disabled={!name || wirdAngelegt}>
|
||||
Anlegen
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
{einheiten.length > 0 && (
|
||||
<ul className="card-list">
|
||||
{einheiten.map((e) => (
|
||||
<li key={e.id} className="row-between" style={{ padding: "0.4rem 0" }}>
|
||||
{bearbeiteteId === e.id ? (
|
||||
<div className="row" style={{ flex: 1 }}>
|
||||
<input
|
||||
className="input"
|
||||
value={bearbeitungsName}
|
||||
onChange={(ev) => setBearbeitungsName(ev.target.value)}
|
||||
/>
|
||||
<button className="btn btn-primary" onClick={() => speichern(e.id)}>
|
||||
Speichern
|
||||
</button>
|
||||
<button className="btn btn-secondary" onClick={() => setBearbeiteteId(null)}>
|
||||
Abbrechen
|
||||
</button>
|
||||
</div>
|
||||
) : (
|
||||
<>
|
||||
<span>
|
||||
{e.name}
|
||||
{e.uebergeordnete_einheit_id !== null && (
|
||||
<span className="text-muted"> – Teil von {einheitName(e.uebergeordnete_einheit_id)}</span>
|
||||
)}
|
||||
</span>
|
||||
<button className="btn btn-secondary" onClick={() => bearbeiten(e)}>
|
||||
Bearbeiten
|
||||
</button>
|
||||
</>
|
||||
)}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
</div>
|
||||
</section>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,204 @@
|
||||
import { useEffect, useState } from "react";
|
||||
|
||||
import { apiRequest } from "../../api/client";
|
||||
import type { Benutzer, BenutzerQualifikation, Qualifikationskategorie, Qualifikationstyp } from "../../api/types";
|
||||
|
||||
interface Props {
|
||||
qualifikationstypen: Qualifikationstyp[];
|
||||
benutzer: Benutzer[];
|
||||
onGeaendert: () => Promise<void>;
|
||||
onFehler: (text: string) => void;
|
||||
}
|
||||
|
||||
const KATEGORIE_LABEL: Record<Qualifikationskategorie, string> = {
|
||||
fuehrerschein: "Führerschein",
|
||||
lehrgang: "Lehrgang",
|
||||
berechtigung: "Berechtigung",
|
||||
};
|
||||
|
||||
// Personal-Modul (Karte-Nachtrag): Qualifikationstypen (Stammdaten) + Zuordnung
|
||||
// zu einzelnen Benutzern mit Gültigkeit ("wer darf was fahren/bedienen").
|
||||
export function QualifikationSection({ qualifikationstypen, benutzer, onGeaendert, onFehler }: Props) {
|
||||
const [name, setName] = useState("");
|
||||
const [kategorie, setKategorie] = useState<Qualifikationskategorie>("lehrgang");
|
||||
const [gueltigkeitMonate, setGueltigkeitMonate] = useState("");
|
||||
const [wirdAngelegt, setWirdAngelegt] = useState(false);
|
||||
|
||||
const [ausgewaehlterBenutzer, setAusgewaehlterBenutzer] = useState<number | "">("");
|
||||
const [qualifikationen, setQualifikationen] = useState<BenutzerQualifikation[]>([]);
|
||||
const [neueQualifikationstypId, setNeueQualifikationstypId] = useState<number | "">("");
|
||||
const [erworbenAm, setErworbenAm] = useState("");
|
||||
const [gueltigBis, setGueltigBis] = useState("");
|
||||
|
||||
async function anlegen() {
|
||||
setWirdAngelegt(true);
|
||||
try {
|
||||
await apiRequest("/qualifikationstypen", {
|
||||
method: "POST",
|
||||
body: { name, kategorie, gueltigkeit_monate: gueltigkeitMonate ? Number(gueltigkeitMonate) : null },
|
||||
});
|
||||
setName("");
|
||||
setGueltigkeitMonate("");
|
||||
await onGeaendert();
|
||||
} catch {
|
||||
onFehler("Qualifikationstyp konnte nicht angelegt werden.");
|
||||
} finally {
|
||||
setWirdAngelegt(false);
|
||||
}
|
||||
}
|
||||
|
||||
async function ladeQualifikationen(benutzerId: number) {
|
||||
try {
|
||||
const daten = await apiRequest<BenutzerQualifikation[]>(`/benutzer/${benutzerId}/qualifikationen`);
|
||||
setQualifikationen(daten);
|
||||
} catch {
|
||||
onFehler("Qualifikationen konnten nicht geladen werden.");
|
||||
}
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
if (ausgewaehlterBenutzer !== "") {
|
||||
ladeQualifikationen(ausgewaehlterBenutzer);
|
||||
} else {
|
||||
setQualifikationen([]);
|
||||
}
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, [ausgewaehlterBenutzer]);
|
||||
|
||||
function qualifikationstypName(id: number): string {
|
||||
const q = qualifikationstypen.find((x) => x.id === id);
|
||||
return q ? `${q.name} (${KATEGORIE_LABEL[q.kategorie]})` : `#${id}`;
|
||||
}
|
||||
|
||||
function istGueltig(q: BenutzerQualifikation): boolean {
|
||||
return q.gueltig_bis === null || q.gueltig_bis >= new Date().toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
async function qualifikationErfassen() {
|
||||
if (ausgewaehlterBenutzer === "" || neueQualifikationstypId === "" || !erworbenAm) {
|
||||
onFehler("Benutzer, Qualifikationstyp und Erwerbsdatum angeben.");
|
||||
return;
|
||||
}
|
||||
try {
|
||||
await apiRequest(`/benutzer/${ausgewaehlterBenutzer}/qualifikationen`, {
|
||||
method: "POST",
|
||||
body: {
|
||||
benutzer_id: ausgewaehlterBenutzer,
|
||||
qualifikationstyp_id: neueQualifikationstypId,
|
||||
erworben_am: erworbenAm,
|
||||
gueltig_bis: gueltigBis || null,
|
||||
},
|
||||
});
|
||||
setNeueQualifikationstypId("");
|
||||
setErworbenAm("");
|
||||
setGueltigBis("");
|
||||
await ladeQualifikationen(ausgewaehlterBenutzer);
|
||||
} catch {
|
||||
onFehler("Qualifikation konnte nicht erfasst werden.");
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<>
|
||||
<section className="section">
|
||||
<h2>Qualifikationstyp anlegen</h2>
|
||||
<div className="card">
|
||||
<div className="row" style={{ marginBottom: qualifikationstypen.length ? "1rem" : 0, flexWrap: "wrap" }}>
|
||||
<input className="input" value={name} onChange={(e) => setName(e.target.value)} placeholder="Name (z.B. Führerschein C1)" />
|
||||
<select
|
||||
className="input"
|
||||
value={kategorie}
|
||||
onChange={(e) => setKategorie(e.target.value as Qualifikationskategorie)}
|
||||
>
|
||||
<option value="fuehrerschein">Führerschein</option>
|
||||
<option value="lehrgang">Lehrgang</option>
|
||||
<option value="berechtigung">Berechtigung</option>
|
||||
</select>
|
||||
<input
|
||||
className="input"
|
||||
style={{ maxWidth: "10rem" }}
|
||||
value={gueltigkeitMonate}
|
||||
onChange={(e) => setGueltigkeitMonate(e.target.value)}
|
||||
placeholder="Gültig (Monate, optional)"
|
||||
/>
|
||||
<button className="btn btn-primary" onClick={anlegen} disabled={!name || wirdAngelegt}>
|
||||
Anlegen
|
||||
</button>
|
||||
</div>
|
||||
{qualifikationstypen.length > 0 && (
|
||||
<ul className="card-list">
|
||||
{qualifikationstypen.map((q) => (
|
||||
<li key={q.id} style={{ padding: "0.3rem 0" }}>
|
||||
{q.name} <span className="text-muted">({KATEGORIE_LABEL[q.kategorie]})</span>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
</div>
|
||||
</section>
|
||||
|
||||
<section className="section">
|
||||
<h2>Qualifikationen je Benutzer</h2>
|
||||
<div className="card">
|
||||
<select
|
||||
className="input"
|
||||
style={{ marginBottom: "1rem" }}
|
||||
value={ausgewaehlterBenutzer}
|
||||
onChange={(e) => setAusgewaehlterBenutzer(Number(e.target.value) || "")}
|
||||
>
|
||||
<option value="">Benutzer wählen…</option>
|
||||
{benutzer.map((b) => (
|
||||
<option key={b.id} value={b.id}>
|
||||
{b.name} ({b.login})
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
|
||||
{ausgewaehlterBenutzer !== "" && (
|
||||
<>
|
||||
<ul className="card-list" style={{ marginBottom: "1rem" }}>
|
||||
{qualifikationen.length === 0 && <li className="text-muted">Keine Qualifikationen erfasst.</li>}
|
||||
{qualifikationen.map((q) => (
|
||||
<li key={q.id} className="row-between" style={{ padding: "0.3rem 0" }}>
|
||||
<span>{qualifikationstypName(q.qualifikationstyp_id)}</span>
|
||||
<span className={istGueltig(q) ? "text-muted" : "text-muted"} style={{ color: istGueltig(q) ? undefined : "#b00020" }}>
|
||||
seit {q.erworben_am}
|
||||
{q.gueltig_bis ? `, gültig bis ${q.gueltig_bis}` : ", unbefristet"}
|
||||
{!istGueltig(q) && " (abgelaufen)"}
|
||||
</span>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
|
||||
<div className="row" style={{ flexWrap: "wrap" }}>
|
||||
<select
|
||||
className="input"
|
||||
value={neueQualifikationstypId}
|
||||
onChange={(e) => setNeueQualifikationstypId(Number(e.target.value) || "")}
|
||||
>
|
||||
<option value="">Qualifikationstyp wählen…</option>
|
||||
{qualifikationstypen.map((q) => (
|
||||
<option key={q.id} value={q.id}>
|
||||
{q.name}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
<input className="input" type="date" value={erworbenAm} onChange={(e) => setErworbenAm(e.target.value)} />
|
||||
<input
|
||||
className="input"
|
||||
type="date"
|
||||
value={gueltigBis}
|
||||
onChange={(e) => setGueltigBis(e.target.value)}
|
||||
placeholder="Gültig bis (optional)"
|
||||
/>
|
||||
<button className="btn btn-primary" onClick={qualifikationErfassen}>
|
||||
Erfassen
|
||||
</button>
|
||||
</div>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
</section>
|
||||
</>
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user