feat(connexions): connexions personnelles par utilisateur — filtrage des vues et des boards, attache automatique, aide a la premiere connexion (app/main.py)

This commit is contained in:
Spark
2026-11-18 10:26:38 -05:00
parent 4d038da130
commit 3975019b7d
+231 -10
View File
@@ -30,7 +30,7 @@ from pathlib import Path
from urllib.parse import quote from urllib.parse import quote
import httpx import httpx
from fastapi import FastAPI, File, Form, Request, UploadFile from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
from fastapi.responses import ( from fastapi.responses import (
HTMLResponse, HTMLResponse,
JSONResponse, 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) parts = _split_full_name(repo_full_name)
if workspace is None or parts is None: if workspace is None or parts is None:
return 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 return None
client = _forge_client(conn_id) client = _forge_client(conn_id)
return client, workspace, parts[0], parts[1] 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) cid = int(cid_raw)
except ValueError: except ValueError:
continue continue
if cid not in models.workspace_connection_ids(workspace["id"]): if cid not in _visible_connection_ids(request, workspace["id"]):
continue continue
models.set_local_archived(workspace["id"], cid, full_name, True) models.set_local_archived(workspace["id"], cid, full_name, True)
count += 1 count += 1
@@ -1669,6 +1669,105 @@ def _current_workspace(request: Request):
return workspaces[0], None 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") @app.post("/workspace/switch")
async def workspace_switch( async def workspace_switch(
request: Request, request: Request,
@@ -2709,6 +2808,7 @@ def _render_profile(request: Request, user: dict, msg: str = "", err: str = "",
return render( return render(
request, "profile.html", request, "profile.html",
profile_user=user, profile_user=user,
gitea_base=get_settings().gitea_url,
memberships=( memberships=(
models.user_workspaces(user["id"]) models.user_workspaces(user["id"])
if user.get("id") is not None if user.get("id") is not None
@@ -2863,7 +2963,7 @@ async def profile_create_connection(
slug = _unique_slug( slug = _unique_slug(
_slugify(f"{user['username']}-{name}"), "connections" _slugify(f"{user['username']}-{name}"), "connections"
) )
models.create_connection( conn_id = models.create_connection(
slug=slug, slug=slug,
kind="github" if kind == "github" else "gitea", kind="github" if kind == "github" else "gitea",
name=name, name=name,
@@ -2871,6 +2971,7 @@ async def profile_create_connection(
token_encrypted=forge_crypto.encrypt_token(token) if token else "", token_encrypted=forge_crypto.encrypt_token(token) if token else "",
owner_user_id=user["id"], owner_user_id=user["id"],
) )
_attach_connection_for_user(request, conn_id)
models.log_admin(user["id"], "connection.personal.create", slug) models.log_admin(user["id"], "connection.personal.create", slug)
return RedirectResponse( return RedirectResponse(
"/profile?msg=Connexion+personnelle+ajout%C3%A9e", status_code=303 "/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) 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) ───────────────────────────────── # ── Live updates (SSE hub) ─────────────────────────────────
class LiveHub: 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 ws_id = workspace["id"] if workspace else 1
full_name = f"{owner}/{repo}" full_name = f"{owner}/{repo}"
if workspace: if workspace:
conn_ids = models.workspace_connection_ids(ws_id) conn_ids = _visible_connection_ids(request, ws_id)
if len(conn_ids) == 1: if len(conn_ids) == 1:
cid = conn_ids[0] cid = conn_ids[0]
return _forge_client(cid), cid, ws_id return _forge_client(cid), cid, ws_id
@@ -3361,7 +3563,17 @@ async def _resolve_board_scope(request: Request, owner: str, repo: str):
continue continue
if full_name in names: if full_name in names:
return client, cid, ws_id 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( async def _workspace_repos(
@@ -3377,6 +3589,7 @@ async def _workspace_repos(
workspace, _role = _current_workspace(request) workspace, _role = _current_workspace(request)
if workspace is None: if workspace is None:
return [], None return [], None
_ensure_personal_attached(request, workspace)
ws_id = workspace["id"] ws_id = workspace["id"]
selection = set(models.workspace_project_selection(ws_id)) selection = set(models.workspace_project_selection(ws_id))
locally_archived = { locally_archived = {
@@ -3384,7 +3597,7 @@ async def _workspace_repos(
for r in models.list_local_archived(ws_id) for r in models.list_local_archived(ws_id)
} }
repos: list[dict] = [] repos: list[dict] = []
conn_ids = models.workspace_connection_ids(ws_id) conn_ids = _visible_connection_ids(request, ws_id)
for cid in conn_ids: for cid in conn_ids:
client = _forge_client(cid) client = _forge_client(cid)
row = models.get_connection(cid) row = models.get_connection(cid)
@@ -3503,19 +3716,26 @@ def _health_dot(health: dict) -> dict:
@app.get("/", response_class=HTMLResponse) @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. """Main dashboard — all projects at a glance.
Since 0.24.0 the projects are those of the CURRENT Since 0.24.0 the projects are those of the CURRENT
WORKSPACE (its connections, its selection, its local WORKSPACE (its connections, its selection, its local
archives excluded); each card carries its connection badge. 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) repos, workspace = await _workspace_repos(request)
active, inactive, archived = classify_repos(repos) active, inactive, archived = classify_repos(repos)
ws_id = workspace["id"] if workspace else 1 ws_id = workspace["id"] if workspace else 1
visible_ids = _visible_connection_ids(request, ws_id)
starred_keys: set[tuple[int, str]] = set() starred_keys: set[tuple[int, str]] = set()
if workspace: if workspace:
for cid in models.workspace_connection_ids(ws_id): for cid in visible_ids:
try: try:
client = _forge_client(cid) client = _forge_client(cid)
for r in await client.list_starred(): for r in await client.list_starred():
@@ -3591,7 +3811,8 @@ async def dashboard(request: Request):
column_keys=bcols.keys(ws_id), column_keys=bcols.keys(ws_id),
active_window_days=get_settings().active_window_days, active_window_days=get_settings().active_window_days,
metrics=get_metrics(window_days=30), 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,
) )