Api routes refactor

folkugat_web/api/routes/__init__.py

@@ -0,0 +1,14 @@
+from folkugat_web.api.router import get_router
+
+from . import auth, index, sessio, sessions, tema, temes
+
+router = get_router()
+
+router.include_router(sessio.router)
+router.include_router(sessions.router)
+router.include_router(tema.router)
+router.include_router(temes.router)
+router.include_router(auth.router)
+router.include_router(index.router)
+
+__all__ = ["router"]

folkugat_web/api/routes/auth.py

@@ -0,0 +1,36 @@
+from typing import Annotated
+
+from fastapi import Cookie, Form, Request
+from folkugat_web.api.router import get_router
+from folkugat_web.config import auth as config
+from folkugat_web.fragments import nota
+from folkugat_web.services import auth as service
+
+router = get_router()
+
+
+@router.get("/api/nota")
+def nota_input(request: Request, value: str | None = None):
+    return nota.input(request, value)
+
+
+@router.post("/api/nota")
+def login(request: Request, value: Annotated[str | None, Form()] = None,
+          nota_folkugat: Annotated[str | None, Cookie()] = None):
+    logged_in = service.logged_in(nota_folkugat)
+    new_login = service.login(value)
+    if new_login and not logged_in:
+        response = nota.nota(request)
+        response.set_cookie(key=config.COOKIE_NAME,
+                            value=service.build_token(),
+                            max_age=config.COOKIE_MAX_AGE)
+    else:
+        response = nota.footer(request, value, logged_in)
+    return response
+
+
+@router.post("/api/logout")
+def logout(request: Request):
+    response = nota.nota(request)
+    response.delete_cookie(key=config.COOKIE_NAME)
+    return response

folkugat_web/api/routes/index.py

@@ -0,0 +1,20 @@
+from fastapi import Request
+from folkugat_web.api.router import get_router
+from folkugat_web.services import auth
+from folkugat_web.templates import templates
+
+router = get_router()
+
+
+@router.get("/")
+def index(request: Request, logged_in: auth.LoggedIn):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "page_title": "Folkugat",
+            "content": "/api/content/sessions",
+            "logged_in": logged_in,
+            "animate": True,
+        }
+    )

folkugat_web/api/routes/sessio/__init__.py

@@ -0,0 +1,10 @@
+from folkugat_web.api.router import get_router
+
+from . import index, live, set_page
+
+router = get_router()
+router.include_router(index.router)
+router.include_router(live.router)
+router.include_router(set_page.router)
+
+__all__ = ["router"]

folkugat_web/api/routes/sessio/index.py

@@ -0,0 +1,201 @@
+from typing import Annotated
+
+from fastapi import Form, Request
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import live, sessio
+from folkugat_web.services import auth
+from folkugat_web.services.temes import write as temes_service
+from folkugat_web.templates import templates
+
+router = get_router()
+
+
+@router.get("/sessio/{session_id}")
+def page(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    session_id: int,
+):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "page_title": "Folkugat",
+            "content": f"/api/content/sessio/{session_id}",
+            "logged_in": logged_in,
+        }
+    )
+
+
+@router.get("/api/content/sessio/{session_id}")
+def contingut(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    session_id: int,
+):
+    return sessio.pagina(request, session_id, logged_in)
+
+
+@router.put("/api/sessio/{session_id}/live")
+def set_live(
+    request: Request,
+    _: auth.RequireLogin,
+    session_id: int,
+):
+    return live.start_live_session(request=request, session_id=session_id)
+
+
+@router.delete("/api/sessio/{session_id}/live")
+def stop_live(
+    request: Request,
+    _: auth.RequireLogin,
+    session_id: int,
+):
+    return live.stop_live_session(request=request, session_id=session_id)
+
+
+@router.post("/api/sessio/{session_id}/set")
+def add_set(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    session_id: int,
+):
+    return sessio.add_set(request=request, session_id=session_id, logged_in=logged_in)
+
+
+@router.get("/api/sessio/{session_id}/set/{set_id}")
+def get_set(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    session_id: int,
+    set_id: int,
+):
+    return sessio.get_set(request=request, session_id=session_id, set_id=set_id, logged_in=logged_in)
+
+
+@router.delete("/api/sessio/{session_id}/set/{set_id}")
+def delete_set(
+    _: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+):
+    return sessio.delete_set(session_id=session_id, set_id=set_id)
+
+
+@router.post("/api/sessio/{session_id}/set/{set_id}")
+def add_tema(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+):
+    return sessio.add_tema(request=request, session_id=session_id, set_id=set_id, logged_in=logged_in)
+
+
+@router.get("/api/sessio/{session_id}/set/{set_id}/tema/{entry_id}")
+def get_tema(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+    entry_id: int,
+):
+    return sessio.get_tema(
+        request=request, session_id=session_id, set_id=set_id, entry_id=entry_id, logged_in=logged_in)
+
+
+@router.get("/api/sessio/{session_id}/set/{set_id}/tema/{entry_id}/editor")
+def get_tema_editor(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+    entry_id: int,
+):
+    return sessio.get_tema_editor(
+        request=request, session_id=session_id, set_id=set_id, entry_id=entry_id, logged_in=logged_in)
+
+
+@router.delete("/api/sessio/{session_id}/set/{set_id}/tema/{entry_id}")
+def delete_tema(
+    _: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+    entry_id: int,
+):
+    return sessio.delete_tema(session_id=session_id, set_id=set_id, entry_id=entry_id)
+
+
+@router.get("/api/sessio/{session_id}/set/{set_id}/tema/{entry_id}/busca")
+def busca_tema(
+    request: Request,
+    _: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+    entry_id: int,
+    query: str,
+):
+    return sessio.busca_tema(
+        request=request,
+        session_id=session_id,
+        set_id=set_id,
+        entry_id=entry_id,
+        query=query,
+    )
+
+
+@router.put("/api/sessio/{session_id}/set/{set_id}/tema/{entry_id}")
+def set_tema(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+    entry_id: int,
+    tema_id: Annotated[int, Form()],
+):
+    return sessio.set_tema(
+        request=request,
+        logged_in=logged_in,
+        session_id=session_id,
+        set_id=set_id,
+        entry_id=entry_id,
+        tema_id=tema_id,
+    )
+
+
+@router.put("/api/sessio/{session_id}/set/{set_id}/tema/{entry_id}/unknown")
+def set_tema_unknown(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+    entry_id: int,
+):
+    return sessio.set_tema(
+        request=request,
+        logged_in=logged_in,
+        session_id=session_id,
+        set_id=set_id,
+        entry_id=entry_id,
+        tema_id=None,
+    )
+
+
+@router.post("/api/sessio/{session_id}/set/{set_id}/tema/{entry_id}")
+def set_tema_new(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    session_id: int,
+    set_id: int,
+    entry_id: int,
+    title: Annotated[str, Form()],
+):
+    new_tema = temes_service.create_tema(title=title)
+    return sessio.set_tema(
+        request=request,
+        logged_in=logged_in,
+        session_id=session_id,
+        set_id=set_id,
+        entry_id=entry_id,
+        tema_id=new_tema.id,
+    )

folkugat_web/api/routes/sessio/live.py

@@ -0,0 +1,39 @@
+from fastapi import Request
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import set_page
+from folkugat_web.services import auth
+from folkugat_web.templates import templates
+
+router = get_router()
+
+
+@router.get("/live")
+def page(
+    request: Request,
+    logged_in: auth.LoggedIn,
+):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "page_title": "Folkugat",
+            "content": f"/api/content/live",
+            "logged_in": logged_in,
+        }
+    )
+
+
+@router.get("/api/content/live")
+async def contingut(
+    request: Request,
+    logged_in: auth.LoggedIn,
+):
+    return await set_page.live(request, logged_in)
+
+
+@router.get("/api/content/live/set")
+async def get_set_page(
+    request: Request,
+    logged_in: auth.LoggedIn,
+):
+    return await set_page.live_set(request, logged_in)

folkugat_web/api/routes/sessio/set_page.py

@@ -0,0 +1,35 @@
+from fastapi import Request
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import set_page
+from folkugat_web.services import auth
+from folkugat_web.templates import templates
+
+router = get_router()
+
+
+@router.get("/sessio/{session_id}/set/{set_id}")
+def page(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    session_id: int,
+    set_id: int,
+):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "page_title": "Folkugat",
+            "content": f"/api/content/sessio/{session_id}/set/{set_id}",
+            "logged_in": logged_in,
+        }
+    )
+
+
+@router.get("/api/content/sessio/{session_id}/set/{set_id}")
+async def contingut(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    session_id: int,
+    set_id: int,
+):
+    return await set_page.pagina(request, session_id, set_id, logged_in)

folkugat_web/api/routes/sessions/__init__.py

@@ -0,0 +1,9 @@
+from folkugat_web.api.router import get_router
+
+from . import editor, index
+
+router = get_router()
+router.include_router(editor.router)
+router.include_router(index.router)
+
+__all__ = ["router"]

folkugat_web/api/routes/sessions/editor.py

@@ -0,0 +1,44 @@
+import datetime
+from typing import Annotated
+
+from fastapi import Form, Request
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import sessions
+from folkugat_web.services import auth
+
+router = get_router()
+
+
+@router.post("/api/sessions/editor/")
+def insert_row(request: Request, _: auth.RequireLogin):
+    return sessions.sessions_editor_insert_row(request)
+
+
+@router.get("/api/sessions/editor/{session_id}/")
+def editor_row(request: Request, session_id: int, _: auth.RequireLogin):
+    return sessions.sessions_editor_row(request, session_id=session_id)
+
+
+@router.put("/api/sessions/editor/{session_id}/")
+def modify_session(
+    request: Request, session_id: int,
+    _: auth.RequireLogin,
+    date: Annotated[datetime.date, Form()],
+    start_time: Annotated[datetime.time, Form()],
+    end_time: Annotated[datetime.time, Form()],
+    venue_name: Annotated[str | None, Form()] = None,
+    venue_url: Annotated[str | None, Form()] = None,
+):
+    session_date = sessions.model.Session(id=session_id, date=date, start_time=start_time, end_time=end_time,
+                                          venue=sessions.model.SessionVenue(name=venue_name, url=venue_url))
+    return sessions.sessions_editor_post_row(request, session_date)
+
+
+@router.delete("/api/sessions/editor/{session_id}/")
+def delete_date(session_id: int, _: auth.RequireLogin):
+    return sessions.sessions_editor_delete_row(session_id)
+
+
+@router.get("/api/sessions/editor/{session_id}/edita")
+def editor_row_editing(request: Request, session_id: int, _: auth.RequireLogin):
+    return sessions.sessions_editor_row_editing(request, session_id)

folkugat_web/api/routes/sessions/index.py

@@ -0,0 +1,50 @@
+from fastapi import Request
+from folkugat_web.api.router import get_router
+from folkugat_web.config import calendari as calendari_conf
+from folkugat_web.fragments import live, sessions
+from folkugat_web.services import auth
+from folkugat_web.templates import templates
+
+router = get_router()
+
+
+@router.get("/sessions")
+def page(request: Request, logged_in: auth.LoggedIn):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "page_title": "Folkugat",
+            "content": "/api/content/sessions",
+            "logged_in": logged_in,
+            "animate": False,
+        }
+    )
+
+
+@router.get("/api/content/sessions")
+def content(request: Request, logged_in: auth.LoggedIn):
+    return sessions.sessions_pagina(request, logged_in)
+
+
+@router.get("/api/sessions/upcoming")
+def calendari(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    limit: int = calendari_conf.CALENDARI_PAGING_CONFIG.initial_items,
+):
+    return sessions.sessions_calendari(request=request, limit=limit, logged_in=logged_in)
+
+
+@router.get("/api/sessions/history")
+def history(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    limit: int = calendari_conf.HISTORY_PAGING_CONFIG.initial_items,
+):
+    return sessions.sessions_historial(request=request, limit=limit, logged_in=logged_in)
+
+
+@router.get("/api/sessions/live")
+def get_live(request: Request):
+    return live.sessio_en_directe(request)

folkugat_web/api/routes/tema/__init__.py

@@ -0,0 +1,13 @@
+from folkugat_web.api.router import get_router
+
+from . import editor, index, links, lyrics, properties, scores
+
+router = get_router()
+router.include_router(editor.router)
+router.include_router(index.router)
+router.include_router(links.router)
+router.include_router(lyrics.router)
+router.include_router(properties.router)
+router.include_router(scores.router)
+
+__all__ = ["router"]

folkugat_web/api/routes/tema/editor.py

@@ -0,0 +1,15 @@
+from fastapi import Request
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import tema
+from folkugat_web.services import auth
+
+router = get_router()
+
+
+@router.get("/api/tema/{tema_id}/editor/title")
+def title_editor(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+):
+    return tema.title_editor(request=request, logged_in=logged_in, tema_id=tema_id)

folkugat_web/api/routes/tema/index.py

@@ -0,0 +1,107 @@
+from typing import Annotated
+
+from fastapi import HTTPException, Request
+from fastapi.params import Form
+from fastapi.responses import HTMLResponse
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import tema, temes
+from folkugat_web.services import auth
+from folkugat_web.services import files as files_service
+from folkugat_web.services.temes import links as links_service
+from folkugat_web.services.temes import lyrics as lyrics_service
+from folkugat_web.services.temes import properties as properties_service
+from folkugat_web.services.temes import query as temes_q
+from folkugat_web.services.temes import scores as scores_service
+from folkugat_web.services.temes import write as temes_w
+from folkugat_web.templates import templates
+from folkugat_web.utils import FnChain
+
+router = get_router()
+
+
+@router.get("/tema/{tema_id}")
+def page(request: Request, logged_in: auth.LoggedIn, tema_id: int):
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "page_title": "Folkugat",
+            "content": f"/api/tema/{tema_id}",
+            "logged_in": logged_in,
+        }
+    )
+
+
+@router.get("/api/tema/{tema_id}")
+def contingut(request: Request, logged_in: auth.LoggedIn, tema_id: int):
+    tema = temes_q.get_tema_by_id(tema_id)
+    if not tema:
+        raise HTTPException(status_code=404, detail="Could not find tune")
+    tema = (
+        FnChain.transform(tema) |
+        temes_q.tema_compute_stats |
+        links_service.add_links_to_tema |
+        lyrics_service.add_lyrics_to_tema |
+        scores_service.add_scores_to_tema |
+        properties_service.add_properties_to_tema
+    ).result()
+    return temes.tema(request, logged_in, tema)
+
+
+@router.delete("/api/tema/{tema_id}")
+def delete_tema(_: auth.RequireLogin, tema_id: int):
+    tema = temes_q.get_tema_by_id(tema_id)
+    if not tema:
+        raise HTTPException(status_code=404, detail="Could not find tune")
+    tema = temes_q.tema_compute_stats(tema=tema)
+    if tema.stats:
+        raise HTTPException(status_code=400, detail="Can't delete a tune that has been played in a set!")
+    temes_w.delete_tema(tema_id=tema_id)
+    files_service.clean_orphan_files()
+    return HTMLResponse(headers={
+        'HX-Redirect': '/temes'
+    })
+
+
+@router.post("/api/tema")
+def create_tema(_: auth.RequireLogin, title: Annotated[str, Form()] = ""):
+    new_tema = temes_w.create_tema(title=title)
+    return HTMLResponse(headers={
+        'HX-Redirect': f'/tema/{new_tema.id}'
+    })
+
+
+@router.get("/api/tema/{tema_id}/title")
+def title(request: Request, logged_in: auth.LoggedIn, tema_id: int):
+    return tema.title(request=request, tema_id=tema_id, logged_in=logged_in)
+
+
+@router.put("/api/tema/{tema_id}/title")
+def set_title(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    title: Annotated[str, Form()],
+):
+    new_tema = temes_w.update_title(tema_id=tema_id, title=title)
+    return tema.title(request=request, tema=new_tema, logged_in=logged_in)
+
+
+@router.put("/api/tema/{tema_id}/visible")
+def set_visible(request: Request, logged_in: auth.RequireLogin, tema_id: int):
+    new_tema = temes_w.set_visibility(tema_id=tema_id, hidden=False)
+    return tema.visibility(
+        request=request,
+        logged_in=logged_in,
+        tema=new_tema,
+    )
+
+
+@router.put("/api/tema/{tema_id}/invisible")
+def set_invisible(request: Request, logged_in: auth.RequireLogin, tema_id: int):
+    new_tema = temes_w.set_visibility(tema_id=tema_id, hidden=True)
+    return tema.visibility(
+        request=request,
+        logged_in=logged_in,
+        tema=new_tema,
+    )

folkugat_web/api/routes/tema/links.py

@@ -0,0 +1,169 @@
+from typing import Annotated
+
+from fastapi import HTTPException, Request, UploadFile
+from fastapi.params import File, Form, Param
+from fastapi.responses import HTMLResponse
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments.tema import links as links_fragments
+from folkugat_web.model import temes as model
+from folkugat_web.services import auth
+from folkugat_web.services import files as files_service
+from folkugat_web.services.temes import links as links_service
+from folkugat_web.services.temes import query as temes_q
+
+router = get_router()
+
+
+@router.get("/api/tema/{tema_id}/link/{link_id}")
+def link(request: Request, logged_in: auth.LoggedIn, tema_id: int, link_id: int):
+    link = links_service.get_link_by_id(link_id=link_id, tema_id=tema_id)
+    if not link:
+        raise HTTPException(status_code=404, detail="Could not find link!")
+    return links_fragments.link(request=request, logged_in=logged_in, link=link)
+
+
+@router.put("/api/tema/{tema_id}/link/{link_id}")
+async def set_link(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    link_id: int,
+    content_type: Annotated[model.ContentType, Form()],
+    title: Annotated[str | None, Form()] = None,
+    url: Annotated[str | None, Form()] = None,
+    upload_file: Annotated[UploadFile | None, File()] = None,
+):
+    if upload_file:
+        url = await files_service.store_file(tema_id=tema_id, upload_file=upload_file)
+
+    link_type = links_service.guess_link_type(url or '')
+    new_link = model.Link(
+        id=link_id,
+        tema_id=tema_id,
+        content_type=content_type,
+        link_type=link_type,
+        url=(url or '').strip(),
+        title=(title or '').strip(),
+    )
+    links_service.update_link(link=new_link)
+    return links_fragments.link(request=request, logged_in=logged_in, link=new_link)
+
+
+@router.post("/api/tema/{tema_id}/link")
+def create_link(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+):
+    link = links_service.create_link(tema_id=tema_id)
+    return links_fragments.link_editor(
+        request=request,
+        logged_in=logged_in,
+        link=link,
+    )
+
+
+@router.delete("/api/tema/{tema_id}/link/{link_id}")
+def delete_link(
+    _logged_in: auth.RequireLogin,
+    tema_id: int,
+    link_id: int,
+):
+    links_service.delete_link(link_id=link_id, tema_id=tema_id)
+    files_service.clean_orphan_files()
+    return HTMLResponse(
+        headers={
+            "HX-Trigger": f"reload-tema-{tema_id}-score"
+        }
+    )
+
+
+@router.get("/api/tema/{tema_id}/link/{link_id}/icon")
+def link_icon(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    tema_id: int,
+    link_id: int,
+    content_type: Annotated[model.ContentType, Param()],
+    url: Annotated[str, Param()],
+):
+    link = model.Link(
+        id=link_id,
+        tema_id=tema_id,
+        content_type=content_type,
+        link_type=links_service.guess_link_type(url),
+        url=url,
+    )
+    return links_fragments.link_icon(
+        request=request,
+        logged_in=logged_in,
+        link=link,
+    )
+
+
+@router.get("/api/tema/{tema_id}/score")
+def get_score(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    tema_id: int,
+):
+    tema = temes_q.get_tema_by_id(tema_id)
+    if not tema:
+        raise HTTPException(status_code=404, detail="Could not find tune")
+    tema = links_service.add_links_to_tema(tema)
+    return links_fragments.score(
+        request=request,
+        logged_in=logged_in,
+        tema=tema,
+    )
+
+
+@router.get("/api/tema/{tema_id}/editor/link/{link_id}")
+def link_editor(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    link_id: int,
+):
+    link = links_service.get_link_by_id(link_id=link_id, tema_id=tema_id)
+    if not link:
+        raise HTTPException(status_code=404, detail="Could not find link!")
+    return links_fragments.link_editor(
+        request=request,
+        logged_in=logged_in,
+        link=link,
+    )
+
+
+@router.get("/api/tema/{tema_id}/editor/link/{link_id}/url")
+def link_editor_url_input(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    link_id: int,
+):
+    link = links_service.get_link_by_id(link_id=link_id, tema_id=tema_id)
+    if not link:
+        raise HTTPException(status_code=404, detail="Could not find link!")
+    return links_fragments.link_editor_url(
+        request=request,
+        logged_in=logged_in,
+        link=link,
+    )
+
+
+@router.get("/api/tema/{tema_id}/editor/link/{link_id}/file")
+def link_editor_file_input(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    link_id: int,
+):
+    link = links_service.get_link_by_id(link_id=link_id, tema_id=tema_id)
+    if not link:
+        raise HTTPException(status_code=404, detail="Could not find link!")
+    return links_fragments.link_editor_file(
+        request=request,
+        logged_in=logged_in,
+        link=link,
+    )

folkugat_web/api/routes/tema/lyrics.py

@@ -0,0 +1,81 @@
+import dataclasses
+from typing import Annotated
+
+from fastapi import HTTPException, Request
+from fastapi.params import Form
+from fastapi.responses import HTMLResponse
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments.tema import lyrics as lyrics_fragments
+from folkugat_web.services import auth
+from folkugat_web.services.temes import lyrics as lyrics_service
+
+router = get_router()
+
+
+@router.get("/api/tema/{tema_id}/lyric/{lyric_id}")
+def lyric(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    tema_id: int,
+    lyric_id: int,
+):
+    lyric = lyrics_service.get_lyric_by_id(lyric_id=lyric_id, tema_id=tema_id)
+    if not lyric:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    return lyrics_fragments.lyric(request=request, logged_in=logged_in, lyric=lyric)
+
+
+@router.put("/api/tema/{tema_id}/lyric/{lyric_id}")
+def set_lyric(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    lyric_id: int,
+    title: Annotated[str, Form()],
+    content: Annotated[str, Form()],
+):
+    lyric = lyrics_service.get_lyric_by_id(lyric_id=lyric_id, tema_id=tema_id)
+    if not lyric:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    new_lyric = lyrics_service.update_lyric(lyric=lyric, title=title, content=content)
+    return lyrics_fragments.lyric(request=request, logged_in=logged_in, lyric=new_lyric)
+
+
+@router.post("/api/tema/{tema_id}/lyric")
+def add_lyric(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+):
+    lyric = lyrics_service.create_lyric(tema_id=tema_id)
+    return lyrics_fragments.lyric_editor(
+        request=request,
+        logged_in=logged_in,
+        lyric=lyric,
+    )
+
+
+@router.delete("/api/tema/{tema_id}/lyric/{lyric_id}")
+def delete_lyric(
+    tema_id: int,
+    lyric_id: int,
+):
+    lyrics_service.delete_lyric(lyric_id=lyric_id, tema_id=tema_id)
+    return HTMLResponse()
+
+
+@router.get("/api/tema/{tema_id}/editor/lyric/{lyric_id}")
+def lyric_editor(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    lyric_id: int,
+):
+    lyric = lyrics_service.get_lyric_by_id(lyric_id=lyric_id, tema_id=tema_id)
+    if not lyric:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    return lyrics_fragments.lyric_editor(
+        request=request,
+        logged_in=logged_in,
+        lyric=lyric,
+    )

folkugat_web/api/routes/tema/properties.py

@@ -0,0 +1,75 @@
+import dataclasses
+from typing import Annotated
+
+from fastapi import HTTPException, Request
+from fastapi.params import Form
+from fastapi.responses import HTMLResponse
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments.tema import properties as properties_fragments
+from folkugat_web.model import temes as model
+from folkugat_web.services import auth
+from folkugat_web.services.temes import properties as properties_service
+
+router = get_router()
+
+
+@router.get("/api/tema/{tema_id}/property/{property_id}")
+def property_(request: Request, logged_in: auth.LoggedIn, tema_id: int, property_id: int):
+    property = properties_service.get_property_by_id(property_id=property_id, tema_id=tema_id)
+    if not property:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    return properties_fragments.property_(request=request, logged_in=logged_in, property=property)
+
+
+@router.put("/api/tema/{tema_id}/property/{property_id}")
+def set_property(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    property_id: int,
+    field: Annotated[model.PropertyField, Form()],
+    value: Annotated[str, Form()],
+):
+    property = properties_service.get_property_by_id(property_id=property_id, tema_id=tema_id)
+    if not property:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    new_property = dataclasses.replace(property, field=field, value=value.strip())
+    properties_service.update_property(property=new_property)
+    return properties_fragments.property_(request=request, logged_in=logged_in, property=new_property)
+
+
+@router.post("/api/tema/{tema_id}/property")
+def add_property(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+):
+    property = properties_service.create_property(tema_id=tema_id)
+    return properties_fragments.property_editor(
+        request=request,
+        logged_in=logged_in,
+        property=property,
+    )
+
+
+@router.delete("/api/tema/{tema_id}/property/{property_id}")
+def delete_property(_: auth.RequireLogin, tema_id: int, property_id: int):
+    properties_service.delete_property(property_id=property_id, tema_id=tema_id)
+    return HTMLResponse()
+
+
+@router.get("/api/tema/{tema_id}/editor/property/{property_id}")
+def property_editor(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    property_id: int,
+):
+    property = properties_service.get_property_by_id(property_id=property_id, tema_id=tema_id)
+    if not property:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    return properties_fragments.property_editor(
+        request=request,
+        logged_in=logged_in,
+        property=property,
+    )

folkugat_web/api/routes/tema/scores.py

@@ -0,0 +1,132 @@
+import dataclasses
+from typing import Annotated
+
+from fastapi import HTTPException, Request
+from fastapi.params import Form
+from fastapi.responses import HTMLResponse
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import temes
+from folkugat_web.fragments.tema import scores as scores_fragments
+from folkugat_web.services import auth, files
+from folkugat_web.services.lilypond import build as lilypond_build
+from folkugat_web.services.lilypond import render as lilypond_render
+from folkugat_web.services.lilypond import source as lilypond_source
+from folkugat_web.services.temes import scores as scores_service
+
+router = get_router()
+
+
+@router.get("/api/tema/{tema_id}/score/{score_id}")
+def score(request: Request, logged_in: auth.LoggedIn, tema_id: int, score_id: int):
+    score = scores_service.get_score_by_id(score_id=score_id, tema_id=tema_id)
+    if not score:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    return scores_fragments.score(request=request, logged_in=logged_in, score=score)
+
+
+@router.put("/api/tema/{tema_id}/score/{score_id}")
+async def set_score(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    score_id: int,
+    title: Annotated[str, Form()],
+    source: Annotated[str, Form()],
+):
+    source = source.strip()
+    score = scores_service.get_score_by_id(score_id=score_id, tema_id=tema_id)
+    if not score:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    new_score = await scores_service.render_score(score=score, title=title, source=source)
+    scores_service.update_score(score=new_score)
+    files.clean_orphan_files()
+    return scores_fragments.score(request=request, logged_in=logged_in, score=new_score)
+
+
+@router.post("/api/tema/{tema_id}/score")
+def add_score(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+):
+    score = scores_service.create_score(tema_id=tema_id)
+    return scores_fragments.score_editor(
+        request=request,
+        logged_in=logged_in,
+        score=score,
+    )
+
+
+@router.delete("/api/tema/{tema_id}/score/{score_id}")
+def delete_score(request: Request, logged_in: auth.RequireLogin, tema_id: int, score_id: int):
+    scores_service.delete_score(score_id=score_id, tema_id=tema_id)
+    files.clean_orphan_files()
+    return HTMLResponse()
+
+
+@router.get("/api/tema/{tema_id}/editor/score/{score_id}")
+def score_editor(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    score_id: int,
+):
+    score = scores_service.get_score_by_id(score_id=score_id, tema_id=tema_id)
+    if not score:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    return scores_fragments.score_editor(
+        request=request,
+        logged_in=logged_in,
+        score=score,
+    )
+
+
+@router.post("/api/tema/{tema_id}/editor/score/{score_id}/render")
+async def render(
+    request: Request,
+    _: auth.RequireLogin,
+    tema_id: int,
+    score_id: int,
+    source: Annotated[str, Form()],
+):
+    tune = lilypond_build.tune_from_tema_id(tema_id=tema_id, score_source=source)
+    full_source = lilypond_source.tune_source(tune=tune)
+    png_result = await lilypond_render.render(
+        source=full_source,
+        output=lilypond_render.RenderOutput.PNG_CROPPED,
+    )
+    if output_filename := png_result.result:
+        score_render_url = files.get_db_file_path(output_filename)
+        return temes.score_render(request=request, score_id=score_id, score_render_url=score_render_url)
+    else:
+        return temes.score_render(request=request, score_id=score_id, errors=png_result.error)
+
+
+@router.put("/api/tema/{tema_id}/score/{score_id}/show")
+async def show_score(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    score_id: int,
+):
+    score = scores_service.get_score_by_id(score_id=score_id, tema_id=tema_id)
+    if not score:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    new_score = dataclasses.replace(score, hidden=False)
+    scores_service.update_score(score=new_score)
+    return scores_fragments.score(request=request, logged_in=logged_in, score=new_score)
+
+
+@router.put("/api/tema/{tema_id}/score/{score_id}/hide")
+async def hide_score(
+    request: Request,
+    logged_in: auth.RequireLogin,
+    tema_id: int,
+    score_id: int,
+):
+    score = scores_service.get_score_by_id(score_id=score_id, tema_id=tema_id)
+    if not score:
+        raise HTTPException(status_code=404, detail="Could not find lyric!")
+    new_score = dataclasses.replace(score, hidden=True)
+    scores_service.update_score(score=new_score)
+    return scores_fragments.score(request=request, logged_in=logged_in, score=new_score)

folkugat_web/api/routes/temes/__init__.py

@@ -0,0 +1,8 @@
+from folkugat_web.api.router import get_router
+
+from . import index
+
+router = get_router()
+router.include_router(index.router)
+
+__all__ = ["router"]

folkugat_web/api/routes/temes/index.py

@@ -0,0 +1,67 @@
+import urllib.parse
+from typing import Annotated
+
+from fastapi import Request
+from fastapi.params import Param
+from folkugat_web.api.router import get_router
+from folkugat_web.fragments import temes
+from folkugat_web.services import auth
+from folkugat_web.templates import templates
+
+router = get_router()
+
+
+@router.get("/temes")
+def page(
+        request: Request,
+        logged_in: auth.LoggedIn,
+        query: Annotated[str, Param()] = "",
+        properties: Annotated[list[str] | None, Param()] = None,
+):
+    properties = properties or []
+    content_url = f"/api/content/temes?{temes.build_temes_params(query=query, properties=properties)}"
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "page_title": "Folkugat",
+            "content": content_url,
+            "logged_in": logged_in,
+            "animate": False,
+        }
+    )
+
+
+@router.get("/api/content/temes")
+def content(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    query: Annotated[str, Param()] = "",
+    properties: Annotated[list[str] | None, Param()] = None,
+):
+    properties = properties or []
+    return temes.temes_pagina(
+        request=request,
+        logged_in=logged_in,
+        query=query,
+        properties=properties,
+    )
+
+
+@router.get("/api/temes/busca")
+def busca(
+    request: Request,
+    logged_in: auth.LoggedIn,
+    query: Annotated[str, Param()],
+    properties: Annotated[list[str] | None, Param()] = None,
+    limit: int = 10,
+    offset: int = 0,
+):
+    return temes.temes_busca(
+        request=request,
+        query=query,
+        properties=properties or [],
+        limit=limit,
+        offset=offset,
+        logged_in=logged_in,
+    )