feat: URLs publiques de l'écosystème par configuration — dev/prod sans noms en dur #223

backend/external_refs.py

@@ -24,7 +24,7 @@ import uuid
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
-from urllib.parse import parse_qs, unquote, urlparse
+from urllib.parse import parse_qs, quote, unquote, urlparse
 
 logger = logging.getLogger("obsigate.external_refs")
 
@@ -64,26 +64,87 @@ def _write_refs(username: str, refs: list[dict[str, Any]]) -> None:
 
 # ------------------------------------------------------------ parseur d'URL
 
+def build_deep_link(target_app: str, target_type: str, target_id: str) -> str | None:
+    """Construit l'URL profonde d'affichage depuis la **configuration**
+    courante (#223), ou ``None`` si la forme est inconnue.
+
+    Les références stockées portent une URL absolue figée au moment du
+    collage (voir ``add_ref``) : elle peut nommer l'autre environnement
+    (un lien collé en prod, lu en dev). L'affichage ne l'utilise donc
+    jamais telle quelle — il reconstruit l'URL depuis
+    ``(target_app, target_type, target_id)`` et les bases publiques
+    configurées (``backend.draco_config``), au moment de la lecture.
+    Aucune donnée stockée n'est migrée ni réécrite.
+    """
+    from backend.draco_config import app_url
+
+    if target_app == "tiktak":
+        if target_type == "task":
+            return f"{app_url('tiktak')}/?task={quote(target_id, safe='')}"
+        if target_type == "list":
+            return f"{app_url('tiktak')}/?list={quote(target_id, safe='')}"
+        return None
+    if target_app == "obsigate" and target_type == "note":
+        return f"{app_url('obsigate')}/#file={quote(target_id, safe=':')}"
+    if target_app == "flowdeck":
+        if target_type == "page":
+            return f"{app_url('flowdeck')}/pages/{quote(target_id, safe='')}"
+        if target_type == "project":
+            return f"{app_url('flowdeck')}/collections/{quote(target_id, safe='')}"
+        return None
+    if target_app == "kanbante" and target_type == "card":
+        m = re.fullmatch(r"([^/]+)/([^/#]+)#(\d+)", target_id or "")
+        if m:
+            owner, repo, num = m.groups()
+            return f"{app_url('gitea')}/{owner}/{repo}/issues/{num}"
+        return None
+    return None
+
+
+def _avec_url_affichee(ref: dict[str, Any]) -> dict[str, Any]:
+    """Copie de la référence dont ``target_url`` est reconstruite
+    depuis la config courante (#223) — le stockage n'est pas touché."""
+    construite = build_deep_link(
+        str(ref.get("target_app") or ""),
+        str(ref.get("target_type") or ""),
+        str(ref.get("target_id") or ""),
+    )
+    if construite is None:
+        return ref
+    copie = dict(ref)
+    copie["target_url"] = construite
+    return copie
+
+
 def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
     """Reconnaît une URL profonde des applications dracodev.
 
     Formes figées par ``dracodev-commons/contrats/liens-profonds.md``.
     Retourne ``(target_app, target_type, target_id, label_par_défaut)``
     ou ``None`` si l'URL ne correspond à aucune forme du contrat.
+
+    Hôtes reconnus (#223) : les hôtes **officiels** et les hôtes
+    **configurés** de chaque application (``backend.draco_config``) —
+    un lien collé depuis l'environnement courant (noms en ``-dev``
+    déclarés dans son ``.env``) comme depuis l'autre environnement
+    est donc reconnu ; aucun nom d'environnement n'est figé ici.
     """
+    from backend.draco_config import hotes_reconnus
+
     try:
         u = urlparse((url or "").strip())
     except ValueError:
         return None
     host = (u.hostname or "").lower()
-    if host == "tiktak.dracodev.net":
+    app = hotes_reconnus().get(host)
+    if app == "tiktak":
         q = parse_qs(u.query)
         if q.get("task"):
             return ("tiktak", "task", q["task"][0], f"TikTak · tâche {q['task'][0]}")
         if q.get("list"):
             return ("tiktak", "list", q["list"][0], f"TikTak · liste {q['list'][0]}")
         return None
-    if host == "og.dracodev.net":
+    if app == "obsigate":
         frag = u.fragment or ""
         if frag.startswith("file="):
             cible = unquote(frag[5:])
@@ -91,7 +152,7 @@ def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
                 nom = cible.rsplit("/", 1)[-1]
                 return ("obsigate", "note", cible, f"ObsiGate · {nom}")
         return None
-    if host == "flowdeck.dracodev.net":
+    if app == "flowdeck":
         m = re.fullmatch(r"/pages/(\d+)", u.path or "")
         if m:
             return ("flowdeck", "page", m.group(1), f"Flowdeck · page {m.group(1)}")
@@ -99,7 +160,7 @@ def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
         if m:
             return ("flowdeck", "project", m.group(1), f"Flowdeck · projet {m.group(1)}")
         return None
-    if host == "git.dracodev.net":
+    if app == "gitea":
         m = re.fullmatch(r"/([^/]+)/([^/]+)/issues/(\d+)", u.path or "")
         if m:
             owner, repo, num = m.groups()
@@ -111,20 +172,25 @@ def parse_deep_link(url: str) -> tuple[str, str, str, str] | None:
 # ------------------------------------------------------------ CRUD
 
 def list_refs(username: str, vault: str, path: str) -> list[dict[str, Any]]:
-    """Références posées sur une note, dans l'ordre de création."""
+    """Références posées sur une note, dans l'ordre de création.
+
+    ``target_url`` de chaque référence retournée est **reconstruite
+    depuis la config courante** (#223, ``_avec_url_affichee``) : la
+    valeur stockée, figée au collage, n'est jamais servie telle quelle.
+    """
     if not username:
         return []
     return [
-        r for r in _read_refs(username)
+        _avec_url_affichee(r) for r in _read_refs(username)
         if r.get("owner_vault") == vault and r.get("owner_path") == path
     ]
 
 
 def get_ref(username: str, ref_id: str) -> dict[str, Any] | None:
-    """Une référence par son identifiant, ou ``None``."""
+    """Une référence par son identifiant, ou ``None`` (URL reconstruite, #223)."""
     for r in _read_refs(username):
         if r.get("id") == ref_id:
-            return r
+            return _avec_url_affichee(r)
     return None
 
 
@@ -169,4 +235,4 @@ def delete_ref(username: str, ref_id: str) -> dict[str, Any] | None:
         return None
     removed = next(r for r in refs if r.get("id") == ref_id)
     _write_refs(username, kept)
-    return removed
+    return _avec_url_affichee(removed)