bruno
9dfc38706c
v5.11.0 Wiki-links & mentions de page :
- tokens [[fdpage:ID]] / [[fddate:ISO]] dans le texte des blocs,
service app/services/wiki_links.py (labels, rendu HTML, extraction)
- taper [[ ouvre le picker de pages (recherche floue, clavier) ;
le menu @ gagne les sections Pages et Date (today/tomorrow/YYYY-MM-DD)
- chips atomiques contenteditable=false relues en tokens par gtTok()
(autosave/drag/undo preservent les liens) ; renommage propage via
GET /board/api/wiki/titles ; backlinks reconnaissent les tokens ;
page publique rend les chips (echopee)
v5.12.0 Templates & verrouillage :
- template picker global sur + New page : 5 built-in
(app/services/block_templates.py) + templates perso
(table page_global_templates, migration 13)
- POST /board/api/page-templates (save current page) + /{id}/use
(instantiate, id 0 = built-in par cle)
- page lock : POST /api/pages/{id}/lock, garde _ensure_page_editable
-> 423 en ecriture pour les non-privileged, deblocage par
locked_by ou admin seulement (403 sinon), banniere + read-only UI
- full-width / small text par page (pages.full_width/font_small,
POST /api/pages/{id}/options, classes CSS)
- migration 13 : is_locked, locked_by, full_width, font_small,
page_global_templates
Tests : tests/test_v511_v512_wiki_templates.py (15) ; suite complete
538 verte ; ruff OK ; node --check des templates JS OK.
91 lines
3.4 KiB
Python
91 lines
3.4 KiB
Python
"""FlowDeck — Wiki-links & page mentions (v5.11.0).
|
|
|
|
Inline references live inside plain-text block content as tokens::
|
|
|
|
[[fdpage:123]] link to page id 123, label resolved at render time
|
|
[[fddate:2026-10-01]] date chip (static label)
|
|
|
|
The page token stores only the id, so renaming a page propagates everywhere
|
|
(the label is resolved through the DB / the titles endpoint at render time).
|
|
Backlinks keep working because the server renderer emits ``/pages/<id>``
|
|
anchors, and the backlink scanner also matches the raw token.
|
|
|
|
Pure-stdlib helpers shared by the public renderer and the block export.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import html as _html
|
|
import re
|
|
|
|
WIKI_PAGE_RE = re.compile(r"\[\[fdpage:(\d+)\]\]")
|
|
WIKI_DATE_RE = re.compile(r"\[\[fddate:(\d{4}-\d{2}-\d{2})(?:T[0-9:]{5,8})?\]\]")
|
|
_DATE_LABELS = {0: "Mon", 1: "Tue", 2: "Wed", 3: "Thu", 4: "Fri", 5: "Sat", 6: "Sun"}
|
|
_MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
|
|
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
|
|
|
|
|
|
def extract_page_ids(text: str) -> list[int]:
|
|
"""All page ids referenced by wiki tokens in a content string."""
|
|
return sorted({int(m) for m in WIKI_PAGE_RE.findall(text or "")})
|
|
|
|
|
|
def _date_label(iso: str) -> str:
|
|
try:
|
|
parts = iso.split("-")
|
|
y, m, d = int(parts[0]), int(parts[1]), int(parts[2])
|
|
import datetime as _dt
|
|
wd = _dt.date(y, m, d).weekday()
|
|
return f"{_DATE_LABELS[wd]} {d} {_MONTHS[m-1]} {y}"
|
|
except (ValueError, IndexError):
|
|
return iso
|
|
|
|
|
|
def token_labels(conn, content: str) -> dict[str, str]:
|
|
"""Map every token in ``content`` to its display label (page title)."""
|
|
out: dict[str, str] = {}
|
|
ids = extract_page_ids(content)
|
|
if ids:
|
|
placeholders = ",".join("?" * len(ids))
|
|
rows = conn.execute(
|
|
f"SELECT id, title, page_icon FROM pages WHERE id IN ({placeholders})", ids,
|
|
).fetchall()
|
|
by_id = {str(r["id"]): (r["title"] or "Untitled", r["page_icon"] or "") for r in rows}
|
|
for token_id in ids:
|
|
title, icon = by_id.get(str(token_id), ("Deleted page", ""))
|
|
out[f"[[fdpage:{token_id}]]"] = f"{icon + ' ' if icon else ''}{title}"
|
|
for m in WIKI_DATE_RE.finditer(content or ""):
|
|
iso = m.group(1)
|
|
out[f"[[fddate:{iso}]]"] = _date_label(iso)
|
|
return out
|
|
|
|
|
|
def resolve_tokens_html(content: str, titles: dict[str, str]) -> str:
|
|
"""Escape plain-text content then turn wiki tokens into HTML chips/links.
|
|
|
|
``titles`` maps token → label (from :func:`token_labels`). Used by the
|
|
public page renderer and any server-side HTML output of block content.
|
|
"""
|
|
s = _html.escape(content or "")
|
|
|
|
def _page(m: re.Match) -> str:
|
|
pid = m.group(1)
|
|
label = titles.get(m.group(0)) or "Deleted page"
|
|
return (f'<a class="fd-wiki-link" href="/pages/{pid}" '
|
|
f'data-pid="{pid}" title="{_html.escape(label)}">{_html.escape(label)}</a>')
|
|
|
|
def _date(m: re.Match) -> str:
|
|
iso = m.group(1)
|
|
label = titles.get(f"[[fddate:{iso}]]") or iso
|
|
return f'<span class="fd-wiki-date" title="{_html.escape(iso)}">{_html.escape(label)}</span>'
|
|
|
|
s = WIKI_PAGE_RE.sub(_page, s)
|
|
s = WIKI_DATE_RE.sub(_date, s)
|
|
return s
|
|
|
|
|
|
def find_referring(content: str, page_id: int) -> bool:
|
|
"""True when the content references ``page_id`` (anchor or wiki token)."""
|
|
if not content:
|
|
return False
|
|
return (f"/pages/{page_id}" in content) or (f"[[fdpage:{page_id}]]" in content)
|