advent22/api/advent22_api/routers/admin.py

from datetime import date

from fastapi import APIRouter, Depends
from pydantic import BaseModel

from advent22_api.core.helpers import EventDates

from ..core.calendar_config import CalendarConfig, DoorsSaved, get_calendar_config
from ..core.config import Config, get_config
from ..core.depends import get_all_event_dates, get_all_image_names, get_all_parts
from ..core.settings import SETTINGS
from ._security import require_admin, user_is_admin

router = APIRouter(prefix="/admin", tags=["admin"])


@router.get("/is_admin")
async def is_admin(
    is_admin: bool = Depends(user_is_admin),
) -> bool:
    return is_admin


class ConfigModel(BaseModel):
    class __Puzzle(BaseModel):
        solution: str
        first: date
        next: date | None
        last: date
        end: date
        seed: str

    class __Calendar(BaseModel):
        config_file: str
        background: str

    class __Image(BaseModel):
        class __Font(BaseModel):
            file: str
            size: int

        size: int
        border: int
        fonts: list[__Font]

    class __WebDAV(BaseModel):
        url: str
        cache_ttl: int
        config_file: str

    puzzle: __Puzzle
    calendar: __Calendar
    image: __Image
    webdav: __WebDAV


@router.get("/config_model")
async def get_config_model(
    _: None = Depends(require_admin),
    cfg: Config = Depends(get_config),
    cal_cfg: CalendarConfig = Depends(get_calendar_config),
    event_dates: EventDates = Depends(get_all_event_dates),
) -> ConfigModel:
    """
    Kombiniert aus privaten `settings`, `config` und `calendar_config`
    """

    return ConfigModel.model_validate(
        {
            "puzzle": {
                "solution": cfg.puzzle.solution,
                "first": event_dates.first,
                "next": event_dates.next,
                "last": event_dates.last,
                "end": event_dates.end,
                "seed": cfg.puzzle.random_seed,
            },
            "calendar": {
                "config_file": cfg.puzzle.calendar,
                "background": cal_cfg.background,
            },
            "image": {
                "size": 500,  # TODO
                "border": 30,  # TODO
                "fonts": [{"file": cfg.server.font, "size": 50}],  # TODO
            },
            "webdav": {
                "url": SETTINGS.webdav.url,
                "cache_ttl": SETTINGS.webdav.cache_ttl,
                "config_file": SETTINGS.webdav.config_filename,
            },
        }
    )


class DayStrModel(BaseModel):
    day: int
    value: str


@router.get("/day_parts")
async def get_day_parts(
    _: None = Depends(require_admin),
    parts: dict[int, str] = Depends(get_all_parts),
) -> list[DayStrModel]:
    """
    Zuordnung der Lösungsteile zu den Tagen
    """

    return [DayStrModel(day=day, value=part) for day, part in sorted(parts.items())]


@router.get("/day_image_names")
async def get_day_image_names(
    _: None = Depends(require_admin),
    image_names: dict[int, str] = Depends(get_all_image_names),
) -> list[DayStrModel]:
    """
    Zuordnung der verwendeten Bilder zu den Tagen
    """

    return [
        DayStrModel(day=day, value=name) for day, name in sorted(image_names.items())
    ]


@router.get("/doors")
async def get_doors(
    _: None = Depends(require_admin),
    cal_cfg: CalendarConfig = Depends(get_calendar_config),
) -> DoorsSaved:
    """
    Türchen lesen
    """

    return cal_cfg.doors


@router.put("/doors")
async def put_doors(
    doors: DoorsSaved,
    _: None = Depends(require_admin),
    cfg: Config = Depends(get_config),
    cal_cfg: CalendarConfig = Depends(get_calendar_config),
) -> None:
    """
    Türchen ändern
    """

    cal_cfg.doors = sorted(
        doors,
        key=lambda door: door.day,
    )
    await cal_cfg.change(cfg)


@router.get("/dav_credentials")
async def get_dav_credentials(
    _: None = Depends(require_admin),
) -> tuple[str, str]:
    """
    Zugangsdaten für WebDAV
    """

    return SETTINGS.webdav.username, SETTINGS.webdav.password


@router.get("/ui_credentials")
async def get_ui_credentials(
    _: None = Depends(require_admin),
    cfg: Config = Depends(get_config),
) -> tuple[str, str]:
    """
    Zugangsdaten für Admin-UI
    """

    return cfg.admin.name, cfg.admin.password