advent22/api/advent22_api/core/config.py

import re
import tomllib
from enum import Enum
from random import Random

from markdown import markdown
from pydantic import BaseModel, ConfigDict, field_validator

from .dav.webdav import WebDAV
from .settings import SETTINGS


class User(BaseModel):
    name: str
    password: str


class TransformedString(BaseModel):
    class __Whitespace(str, Enum):
        # unverändert
        KEEP = "KEEP"

        # Leerzeichen an Anfang und Ende entfernen
        STRIP = "STRIP"

        # whitespace durch Leerzeichen ersetzen
        SPACE = "SPACE"

        # whitespace entfernen
        REMOVE = "REMOVE"

    class __SpecialChars(str, Enum):
        # unverändert
        KEEP = "KEEP"

        # Sonderzeichen entfernen
        REMOVE = "REMOVE"

    class __Case(str, Enum):
        # unverändert
        KEEP = "KEEP"

        # GROSSBUCHSTABEN
        UPPER = "UPPER"

        # kleinbuchstaben
        LOWER = "LOWER"

        # ZuFÄllIg
        RANDOM = "RANDOM"

    value: str

    whitespace: __Whitespace = __Whitespace.REMOVE
    special_chars: __SpecialChars = __SpecialChars.REMOVE
    case: __Case = __Case.UPPER

    @field_validator("whitespace", "case", mode="before")
    def transform_from_str(cls, v) -> str:
        return str(v).upper()

    @property
    def clean(self) -> str:
        result = self.value

        # Whitespace verarbeiten
        if self.whitespace is TransformedString.__Whitespace.STRIP:
            result = result.strip()

        elif self.whitespace is TransformedString.__Whitespace.SPACE:
            result = re.sub(string=result, pattern=r"\s+", repl=" ")

        elif self.whitespace is TransformedString.__Whitespace.REMOVE:
            result = re.sub(string=result, pattern=r"\s+", repl="")

        # Sonderzeichen verarbeiten
        if self.special_chars is TransformedString.__SpecialChars.REMOVE:
            result = re.sub(string=result, pattern=r"[^a-zA-Z0-9\s]+", repl="")

        # Groß-/Kleinschreibung verarbeiten
        if self.case is TransformedString.__Case.UPPER:
            result = result.upper()

        elif self.case is TransformedString.__Case.LOWER:
            result = result.lower()

        elif self.case is TransformedString.__Case.RANDOM:
            rnd = Random(self.value)

            def randomcase(c: str) -> str:
                if rnd.choice((True, False)):
                    return c.upper()
                return c.lower()

            result = "".join(randomcase(c) for c in result)

        return result


class Site(BaseModel):
    model_config = ConfigDict(validate_default=True)

    # Titel
    title: str

    # Untertitel
    subtitle: str

    # Inhalt der Seite
    content: str

    # Fußzeile der Seite
    footer: str = "**Advent22** by [Lenaisten e.V.](//www.lenaisten.de)"

    @field_validator("content", "footer", mode="after")
    def parse_md(cls, v) -> str:
        return markdown(v)


class Puzzle(BaseModel):
    # Tag, an dem der Kalender startet
    begin_day: int = 1

    # Monat, in dem der Kalender startet
    begin_month: int = 12

    # Kalender so viele Tage nach der letzten Türöffnung schließen
    close_after: int = 90


class Image(BaseModel):
    # Quadrat, Seitenlänge in px
    size: int = 1000

    # Rand in px, wo keine Buchstaben untergebracht werden
    border: int = 60


class Config(BaseModel):
    # Login-Daten für Admin-Modus
    admin: User

    # Lösungswort
    solution: TransformedString

    # Weitere Einstellungen
    site: Site
    puzzle: Puzzle
    image: Image

    # Kalenderdefinition
    calendar: str = "default.toml"

    # Serverseitiger zusätzlicher "random" seed
    random_seed: str = ""


async def get_config() -> Config:
    """
    Globale Konfiguration lesen
    """

    txt = await WebDAV.read_str(path=SETTINGS.webdav.config_filename)
    return Config.model_validate(tomllib.loads(txt))