ovdashboard/api/ovdashboard_api/routers/text.py

"""
Router "text" provides:

- listing text files
- finding text files by name prefix
- getting text file raw content by name prefix
- getting text file HTML content by name prefix (using Markdown)
- getting the "ticker" raw content
- getting the "ticker" HTML content (using Markdown)
"""

import re
from logging import getLogger
from typing import Iterator

from fastapi import APIRouter, Depends
from markdown import markdown

from ..config import Config
from ..dav_common import webdav_ensure_path
from ..dav_file import DavFile
from ._common import FileNameLister, PrefixFinder, PrefixUnique

_logger = getLogger(__name__)

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

text_lister = FileNameLister(
    path_name="text_dir",
    re=re.compile(
        r"\.(txt|md)$",
        flags=re.IGNORECASE,
    ),
)

text_finder = PrefixFinder(text_lister)
text_unique = PrefixUnique(text_finder)


@router.on_event("startup")
async def start_router() -> None:
    _logger.debug(f"{router.prefix} router starting.")

    webdav_ensure_path(await text_lister.remote_path)


async def get_ticker_lines() -> Iterator[str]:
    cfg = await Config.get()
    file_name = await text_unique(cfg.ticker.file_name)

    ticker = await DavFile(
        f"{await text_lister.remote_path}/{file_name}",
    ).as_string

    return (
        line.strip()
        for line in ticker.split("\n")
        if line.strip()
    )


async def get_ticker_content_lines(
    ticker_lines: Iterator[str] = Depends(get_ticker_lines),
) -> Iterator[str]:
    cfg = await Config.get()

    return (
        line
        for line in ticker_lines
        if not line.startswith(cfg.ticker.comment_marker)
    )


async def get_ticker_content(
    ticker_content_lines: Iterator[str] = Depends(get_ticker_content_lines),
) -> str:
    cfg = await Config.get()
    ticker_content = cfg.ticker.separator.join(
        ["", *ticker_content_lines, ""],
    )

    return ticker_content.strip()


@ router.get("/get/html/ticker")
async def get_ticker(
    ticker_content: str = Depends(get_ticker_content),
) -> str:
    return markdown(ticker_content)


@ router.get("/get/raw/ticker")
async def get_raw_ticker(
    ticker_content: str = Depends(get_ticker_content),
) -> str:
    return ticker_content


@router.get(
    "/list",
    response_model=list[str],
    responses=text_lister.responses,
)
async def list_texts(
    names: Iterator[str] = Depends(text_lister),
) -> list[str]:
    return list(names)


@router.get(
    "/find/{prefix}",
    response_model=list[str],
    responses=text_finder.responses,
)
async def find_texts(
    names: Iterator[str] = Depends(text_finder),
) -> list[str]:
    return list(names)


async def get_text_content(
    name: str = Depends(text_unique),
) -> str:
    return await DavFile(
        f"{await text_lister.remote_path}/{name}",
    ).as_string


@router.get(
    "/get/html/{prefix}",
    response_model=str,
    responses=text_unique.responses,
)
async def get_text(
    text: str = Depends(get_text_content),
) -> str:
    return markdown(text)


@router.get(
    "/get/raw/{prefix}",
    response_model=str,
    responses=text_unique.responses,
)
async def get_raw_text(
    text: str = Depends(get_text_content),
) -> str:
    return text