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

from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.deps import get_current_user, require_roles
from app.db.session import get_db
from app.models.auth import RolleTyp
from app.models.stammdaten import Bereich, Fach, Kategorie, Material, Objekttyp, Standort
from app.schemas.stammdaten import (
    BereichCreate,
    BereichRead,
    BereichUpdate,
    FachCreate,
    FachRead,
    FachUpdate,
    KategorieCreate,
    KategorieRead,
    KategorieUpdate,
    MaterialCreate,
    MaterialRead,
    MaterialUpdate,
    ObjekttypCreate,
    ObjekttypRead,
    ObjekttypUpdate,
    StandortCreate,
    StandortRead,
    StandortUpdate,
)

router = APIRouter()


# -- Bereich ------------------------------------------------------------------

@router.get("/bereiche", response_model=list[BereichRead])
async def liste_bereiche(
    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
) -> list[Bereich]:
    result = await db.execute(select(Bereich))
    return list(result.scalars().all())


@router.post("/bereiche", response_model=BereichRead, status_code=status.HTTP_201_CREATED)
async def erstelle_bereich(
    payload: BereichCreate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Bereich:
    bereich = Bereich(**payload.model_dump())
    db.add(bereich)
    await db.flush()
    return bereich


@router.patch("/bereiche/{bereich_id}", response_model=BereichRead)
async def aendere_bereich(
    bereich_id: int,
    payload: BereichUpdate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Bereich:
    bereich = await db.get(Bereich, bereich_id)
    if bereich is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Bereich nicht gefunden")
    for feld, wert in payload.model_dump(exclude_unset=True).items():
        setattr(bereich, feld, wert)
    await db.flush()
    return bereich


# -- Kategorie ------------------------------------------------------------------

@router.get("/kategorien", response_model=list[KategorieRead])
async def liste_kategorien(
    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
) -> list[Kategorie]:
    result = await db.execute(select(Kategorie))
    return list(result.scalars().all())


@router.post("/kategorien", response_model=KategorieRead, status_code=status.HTTP_201_CREATED)
async def erstelle_kategorie(
    payload: KategorieCreate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Kategorie:
    kategorie = Kategorie(**payload.model_dump())
    db.add(kategorie)
    await db.flush()
    return kategorie


@router.patch("/kategorien/{kategorie_id}", response_model=KategorieRead)
async def aendere_kategorie(
    kategorie_id: int,
    payload: KategorieUpdate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Kategorie:
    kategorie = await db.get(Kategorie, kategorie_id)
    if kategorie is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Kategorie nicht gefunden")
    for feld, wert in payload.model_dump(exclude_unset=True).items():
        setattr(kategorie, feld, wert)
    await db.flush()
    return kategorie


# -- Standort ------------------------------------------------------------------

@router.get("/standorte", response_model=list[StandortRead])
async def liste_standorte(
    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
) -> list[Standort]:
    result = await db.execute(select(Standort))
    return list(result.scalars().all())


@router.post("/standorte", response_model=StandortRead, status_code=status.HTTP_201_CREATED)
async def erstelle_standort(
    payload: StandortCreate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Standort:
    standort = Standort(**payload.model_dump())
    db.add(standort)
    await db.flush()
    return standort


@router.patch("/standorte/{standort_id}", response_model=StandortRead)
async def aendere_standort(
    standort_id: int,
    payload: StandortUpdate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Standort:
    standort = await db.get(Standort, standort_id)
    if standort is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Standort nicht gefunden")
    for feld, wert in payload.model_dump(exclude_unset=True).items():
        setattr(standort, feld, wert)
    await db.flush()
    return standort


# -- Objekttyp ------------------------------------------------------------------

@router.get("/objekttypen", response_model=list[ObjekttypRead])
async def liste_objekttypen(
    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
) -> list[Objekttyp]:
    result = await db.execute(select(Objekttyp))
    return list(result.scalars().all())


@router.post("/objekttypen", response_model=ObjekttypRead, status_code=status.HTTP_201_CREATED)
async def erstelle_objekttyp(
    payload: ObjekttypCreate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Objekttyp:
    objekttyp = Objekttyp(**payload.model_dump())
    db.add(objekttyp)
    await db.flush()
    return objekttyp


@router.patch("/objekttypen/{objekttyp_id}", response_model=ObjekttypRead)
async def aendere_objekttyp(
    objekttyp_id: int,
    payload: ObjekttypUpdate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Objekttyp:
    objekttyp = await db.get(Objekttyp, objekttyp_id)
    if objekttyp is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Objekttyp nicht gefunden")
    for feld, wert in payload.model_dump(exclude_unset=True).items():
        setattr(objekttyp, feld, wert)
    await db.flush()
    return objekttyp


# -- Fach (feste Fächer-Liste je Objekttyp) ----------------------------------

@router.get("/faecher", response_model=list[FachRead])
async def liste_faecher(
    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
) -> list[Fach]:
    result = await db.execute(select(Fach).order_by(Fach.objekttyp_id, Fach.sortierung, Fach.name))
    return list(result.scalars().all())


@router.post("/faecher", response_model=FachRead, status_code=status.HTTP_201_CREATED)
async def erstelle_fach(
    payload: FachCreate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Fach:
    fach = Fach(**payload.model_dump())
    db.add(fach)
    await db.flush()
    return fach


@router.patch("/faecher/{fach_id}", response_model=FachRead)
async def aendere_fach(
    fach_id: int,
    payload: FachUpdate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Fach:
    fach = await db.get(Fach, fach_id)
    if fach is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Fach nicht gefunden")
    for feld, wert in payload.model_dump(exclude_unset=True).items():
        setattr(fach, feld, wert)
    await db.flush()
    return fach


@router.delete("/faecher/{fach_id}", status_code=status.HTTP_204_NO_CONTENT)
async def loesche_fach(
    fach_id: int,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> None:
    fach = await db.get(Fach, fach_id)
    if fach is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Fach nicht gefunden")
    await db.delete(fach)
    await db.flush()


# -- Material (Prompt 07) --------------------------------------------------

@router.get("/materialien", response_model=list[MaterialRead])
async def liste_materialien(
    db: AsyncSession = Depends(get_db), _=Depends(get_current_user)
) -> list[Material]:
    result = await db.execute(select(Material))
    return list(result.scalars().all())


@router.get("/materialien/{material_id}", response_model=MaterialRead)
async def hole_material(
    material_id: int,
    db: AsyncSession = Depends(get_db),
    _=Depends(get_current_user),
) -> Material:
    material = await db.get(Material, material_id)
    if material is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Material nicht gefunden")
    return material


@router.post("/materialien", response_model=MaterialRead, status_code=status.HTTP_201_CREATED)
async def erstelle_material(
    payload: MaterialCreate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Material:
    material = Material(**payload.model_dump())
    db.add(material)
    await db.flush()
    return material


@router.patch("/materialien/{material_id}", response_model=MaterialRead)
async def aendere_material(
    material_id: int,
    payload: MaterialUpdate,
    db: AsyncSession = Depends(get_db),
    _=Depends(require_roles(RolleTyp.administration)),
) -> Material:
    material = await db.get(Material, material_id)
    if material is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Material nicht gefunden")
    for feld, wert in payload.model_dump(exclude_unset=True).items():
        setattr(material, feld, wert)
    await db.flush()
    return material