Kanbante 0.47.0 : connexions personnelles — chaque utilisateur connecte sa forge #97

Merged
bruno merged 6 commits from connexions-personnelles-0-47-0 into main 2026-11-18 10:26:52 -05:00
Showing only changes of commit 3975019b7d - Show all commits
+231 -10
View File
@@ -30,7 +30,7 @@ from pathlib import Path
from urllib.parse import quote
import httpx
from fastapi import FastAPI, File, Form, Request, UploadFile
from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
from fastapi.responses import (
HTMLResponse,
JSONResponse,
@@ -1418,7 +1418,7 @@ async def _archive_target(request: Request, conn_id: int, repo_full_name: str):
parts = _split_full_name(repo_full_name)
if workspace is None or parts is None:
return None
if conn_id not in models.workspace_connection_ids(workspace["id"]):
if conn_id not in _visible_connection_ids(request, workspace["id"]):
return None
client = _forge_client(conn_id)
return client, workspace, parts[0], parts[1]
@@ -1469,7 +1469,7 @@ async def archives_local_bulk(request: Request, csrf_token: str = Form("")):
cid = int(cid_raw)
except ValueError:
continue
if cid not in models.workspace_connection_ids(workspace["id"]):
if cid not in _visible_connection_ids(request, workspace["id"]):
continue
models.set_local_archived(workspace["id"], cid, full_name, True)
count += 1
@@ -1669,6 +1669,105 @@ def _current_workspace(request: Request):
return workspaces[0], None
# ── Connexions personnelles (0.47.0) ─────────────────────
# Demande de Bruno (2026-11-18) : chaque utilisateur connecte
# SON gestionnaire de sources (Gitea, GitHub) et agit avec SON
# accès — plus question que tous les comptes partagent la
# connexion Gitea historique de l'instance.
def _connection_visible_to(row: dict | None, user: dict | None) -> bool:
"""Cette connexion est-elle utilisable par cet utilisateur
dans les vues interactives ?
- opérateur d'environnement (aucun compte en base) : tout,
comme avant ;
- connexion personnelle (owner_user_id) : son seul
propriétaire ;
- connexion globale (sans propriétaire, ex. la connexion
héritée n° 1) : les administrateurs seulement — un membre
ordinaire ne doit plus voir ni manipuler les dépôts d'un
autre accès forge. Les rituels d'arrière-plan (briefing,
digest, MCP, instantanés) ne passent pas par ce filtre :
ils relèvent du service, pas d'un utilisateur.
"""
if row is None:
return False
if user is None or user.get("id") is None:
return True
owner = row.get("owner_user_id")
if owner is not None:
return owner == user["id"]
return user.get("role") == "admin"
def _visible_connection_ids(request: Request, workspace_id: int) -> list[int]:
"""Connexions de l'espace que l'utilisateur courant peut
réellement utiliser (voir _connection_visible_to)."""
user = _current_user(request)
return [
cid
for cid in models.workspace_connection_ids(workspace_id)
if _connection_visible_to(models.get_connection(cid), user)
]
def _personal_connections(user: dict | None) -> list[dict]:
if user is None or user.get("id") is None:
return []
return [
row
for row in models.list_connections()
if row.get("owner_user_id") == user["id"]
]
def _needs_connection_onboarding(request: Request) -> bool:
"""Vrai pour un membre ordinaire sans aucune connexion
personnelle active : ses vues seraient vides, l'écran
d'aide à la connexion doit le prendre en charge."""
user = _current_user(request)
if user is None or user.get("id") is None:
return False
if user.get("role") == "admin":
return False
return not any(
row.get("enabled") for row in _personal_connections(user)
)
def _attach_connection_for_user(
request: Request, conn_id: int
) -> None:
"""Attache une connexion personnelle à l'espace courant de
son propriétaire : elle devient utilisable immédiatement,
sans passage par l'administration des espaces."""
workspace, _role = _current_workspace(request)
if workspace is None:
return
ids = models.workspace_connection_ids(workspace["id"])
if conn_id not in ids:
models.set_workspace_connections(
workspace["id"], ids + [conn_id]
)
def _ensure_personal_attached(request: Request, workspace: dict) -> None:
"""Auto-réparation : les connexions personnelles créées
avant la 0.47.0 n'étaient attachées à aucun espace — on les
rattache à l'espace courant de leur propriétaire."""
user = _current_user(request)
mine = [
row["id"] for row in _personal_connections(user) if row.get("enabled")
]
if not mine:
return
ids = models.workspace_connection_ids(workspace["id"])
missing = [cid for cid in mine if cid not in ids]
if missing:
models.set_workspace_connections(workspace["id"], ids + missing)
@app.post("/workspace/switch")
async def workspace_switch(
request: Request,
@@ -2709,6 +2808,7 @@ def _render_profile(request: Request, user: dict, msg: str = "", err: str = "",
return render(
request, "profile.html",
profile_user=user,
gitea_base=get_settings().gitea_url,
memberships=(
models.user_workspaces(user["id"])
if user.get("id") is not None
@@ -2863,7 +2963,7 @@ async def profile_create_connection(
slug = _unique_slug(
_slugify(f"{user['username']}-{name}"), "connections"
)
models.create_connection(
conn_id = models.create_connection(
slug=slug,
kind="github" if kind == "github" else "gitea",
name=name,
@@ -2871,6 +2971,7 @@ async def profile_create_connection(
token_encrypted=forge_crypto.encrypt_token(token) if token else "",
owner_user_id=user["id"],
)
_attach_connection_for_user(request, conn_id)
models.log_admin(user["id"], "connection.personal.create", slug)
return RedirectResponse(
"/profile?msg=Connexion+personnelle+ajout%C3%A9e", status_code=303
@@ -2913,6 +3014,107 @@ async def profile_test_connection(
return RedirectResponse(f"/profile?{key}={_q(message)}", status_code=303)
# ── Aide à la première connexion (0.47.0) ────────────────
def _render_onboarding(
request: Request, msg: str = "", err: str = "", form: dict | None = None
):
"""Écran d'accueil d'un membre sans connexion personnelle :
il explique, donne les liens directs de création de jeton
et propose le formulaire de première connexion."""
settings = get_settings()
return render(
request, "onboarding.html",
gitea_base=settings.gitea_url,
form=form or {},
msg=msg, err=err,
)
@app.post("/onboarding/connect")
async def onboarding_connect(
request: Request,
kind: str = Form("gitea"),
name: str = Form(""),
base_url: str = Form(""),
token: str = Form(""),
csrf_token: str = Form(""),
):
"""Première connexion d'un utilisateur : le jeton est
TESTÉ contre la forge avant tout enregistrement — en cas
d'échec, rien n'est créé et l'écran d'aide se réaffiche
avec l'erreur. En cas de succès, la connexion personnelle
est créée (compte détecté renseigné) et attachée à
l'espace courant : l'utilisateur voit ses dépôts tout de
suite."""
user = _current_user(request)
if user is None or user.get("id") is None:
return RedirectResponse("/", status_code=303)
if not _csrf_valid(request, csrf_token):
return _csrf_error()
from app import forge_crypto
kind = "github" if kind == "github" else "gitea"
name = name.strip() or ("Mon GitHub" if kind == "github" else "Mon Gitea")
base_url = base_url.strip().rstrip("/")
token = token.strip()
form = {"kind": kind, "name": name, "base_url": base_url}
if not base_url or not token:
return _render_onboarding(
request, err="URL de la forge et jeton d'accès requis",
form=form,
)
# Ligne synthétique complète : build_client lit aussi le
# slug (une première version sans slug donnait un 500 en
# conditions réelles — les tests patchaient build_client).
probe = {
"id": 0,
"slug": "sonde",
"kind": kind,
"base_url": base_url,
"token_encrypted": forge_crypto.encrypt_token(token),
"account_login": "",
}
client = connections_service.build_client(probe)
try:
forge_user = await client.get_user()
login = (
forge_user.get("login") or forge_user.get("username") or ""
)
except Exception as exc:
return _render_onboarding(
request,
err=(
"Connexion impossible avec ce jeton : "
f"{exc} — vérifie l'URL, le jeton et ses portées."
),
form=form,
)
finally:
await client.aclose()
slug = _unique_slug(
_slugify(f"{user['username']}-{name}"), "connections"
)
conn_id = models.create_connection(
slug=slug,
kind=kind,
name=name,
base_url=base_url,
token_encrypted=probe["token_encrypted"],
account_login=login,
owner_user_id=user["id"],
)
_attach_connection_for_user(request, conn_id)
models.log_admin(user["id"], "connection.personal.create", slug)
from urllib.parse import quote as _q
return RedirectResponse(
f"/?msg={_q(f'Connexion établie : {login or name} — bienvenue !')}",
status_code=303,
)
# ── Live updates (SSE hub) ─────────────────────────────────
class LiveHub:
@@ -3347,7 +3549,7 @@ async def _resolve_board_scope(request: Request, owner: str, repo: str):
ws_id = workspace["id"] if workspace else 1
full_name = f"{owner}/{repo}"
if workspace:
conn_ids = models.workspace_connection_ids(ws_id)
conn_ids = _visible_connection_ids(request, ws_id)
if len(conn_ids) == 1:
cid = conn_ids[0]
return _forge_client(cid), cid, ws_id
@@ -3361,7 +3563,17 @@ async def _resolve_board_scope(request: Request, owner: str, repo: str):
continue
if full_name in names:
return client, cid, ws_id
return gitea, registry.default_id, ws_id
# Repli historique : le client hérité n'est servi qu'aux
# utilisateurs autorisés sur la connexion par défaut —
# jamais à un membre qui n'a pas accès à cette forge.
if _connection_visible_to(
models.get_connection(registry.default_id), _current_user(request)
):
return gitea, registry.default_id, ws_id
raise HTTPException(
status_code=404,
detail="Projet introuvable pour vos connexions",
)
async def _workspace_repos(
@@ -3377,6 +3589,7 @@ async def _workspace_repos(
workspace, _role = _current_workspace(request)
if workspace is None:
return [], None
_ensure_personal_attached(request, workspace)
ws_id = workspace["id"]
selection = set(models.workspace_project_selection(ws_id))
locally_archived = {
@@ -3384,7 +3597,7 @@ async def _workspace_repos(
for r in models.list_local_archived(ws_id)
}
repos: list[dict] = []
conn_ids = models.workspace_connection_ids(ws_id)
conn_ids = _visible_connection_ids(request, ws_id)
for cid in conn_ids:
client = _forge_client(cid)
row = models.get_connection(cid)
@@ -3503,19 +3716,26 @@ def _health_dot(health: dict) -> dict:
@app.get("/", response_class=HTMLResponse)
async def dashboard(request: Request):
async def dashboard(request: Request, msg: str = "", err: str = ""):
"""Main dashboard — all projects at a glance.
Since 0.24.0 the projects are those of the CURRENT
WORKSPACE (its connections, its selection, its local
archives excluded); each card carries its connection badge.
"""
# 0.47.0 : un membre sans connexion personnelle est pris
# en charge par l'écran d'aide à la connexion plutôt que
# par un tableau de bord vide (ou pire, alimenté par
# l'accès forge d'un autre).
if _needs_connection_onboarding(request):
return _render_onboarding(request, msg=msg, err=err)
repos, workspace = await _workspace_repos(request)
active, inactive, archived = classify_repos(repos)
ws_id = workspace["id"] if workspace else 1
visible_ids = _visible_connection_ids(request, ws_id)
starred_keys: set[tuple[int, str]] = set()
if workspace:
for cid in models.workspace_connection_ids(ws_id):
for cid in visible_ids:
try:
client = _forge_client(cid)
for r in await client.list_starred():
@@ -3591,7 +3811,8 @@ async def dashboard(request: Request):
column_keys=bcols.keys(ws_id),
active_window_days=get_settings().active_window_days,
metrics=get_metrics(window_days=30),
multi_conn=len(models.workspace_connection_ids(ws_id)) > 1,
multi_conn=len(visible_ids) > 1,
msg=msg, err=err,
)