bruno
45e59009c3
4 passes (283 → 93 routes async sur 667 = 86 % hors loop, avant 61 %) :
A. RACINE AUTH — `get_current_user` (auth/session.py) était `async def`
SANS aucun await (cookie decode = synchrone) ; idem ses clones :
`agent._current_user_id/_workspace_id/_current_admin` (34 sites) et
`sso._require_admin` (corps 0 await, 6 sites) → `def` +
47 `await` supprimés. Piège : 3 call sites passaient par l'alias `gcu`
(grep littéral aveugle) — 8 tests en échec → corrigés.
B. Re-scan : 19 routes devenues SANS await → `def` (agent 8, sso 5,
web_clipper 3, projects 2, auth 1…).
C/D. 155 routes dont les seuls awaits = `request.json()` / événements :
- try/except `body = {}` → `Body(default={})` (même tolérance)
- try/except `raise HTTPException(400)` → `Body(...)` REQUIS
(422 FastAPI — aucun test ne couvrait le 400)
- forme conditionnelle `request.json() if content-type else {}`
(54 sites) → défaut `{}` (sans corps = `{}` dans les 2 cas)
- `await fire_*` → `run_event_sync(...)` ; imports `Body` /
`run_event_sync` ajoutés aux routers convertis
Reste async (93, justifié) : form/upload/file (22), réseau gitea/llm/oidc,
`_json_body` (9), 2 JSON inline en argument, 1 fallback logique
(capture_frontend_error), 1 lecture conditionnelle (web_clipper), mixtes.
suite **1089/1089** · ruff OK · docs à jour
327 lines
13 KiB
Python
327 lines
13 KiB
Python
"""FlowDeck — Gitea integration API routes."""
|
|
from fastapi import APIRouter, Body, HTTPException, Request
|
|
from fastapi.responses import JSONResponse
|
|
|
|
router = APIRouter(tags=["gitea"], prefix="/api/gitea")
|
|
|
|
|
|
def _require_gitea(request: Request):
|
|
"""Return a per-user GiteaClient or raise 401.
|
|
|
|
Only returns a client if the user has personally connected their Gitea
|
|
account (OAuth token). No fallback to admin token — each user must link
|
|
their own Gitea account to see Gitea projects.
|
|
"""
|
|
from app.services.gitea_client import get_user_gitea_client
|
|
client = get_user_gitea_client(request)
|
|
if not client:
|
|
raise HTTPException(status_code=401, detail="Gitea account not linked. Go to Settings → Integrations to connect.")
|
|
return client
|
|
|
|
|
|
|
|
|
|
@router.get("/orgs")
|
|
async def list_orgs(request: Request):
|
|
"""List organizations the user belongs to."""
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
orgs = await gitea.get_user_orgs()
|
|
return {"orgs": orgs}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Projects (repos) ──
|
|
@router.get("/projects")
|
|
async def list_projects(request: Request, org: str = ""):
|
|
"""List Gitea repos: user repos (org='') or org repos."""
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
if org:
|
|
repos = await gitea.get_org_repos(org)
|
|
else:
|
|
repos = await gitea.get_user_repos(limit=100)
|
|
return {"projects": repos}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Repo tree ──
|
|
@router.get("/projects/{owner}/{repo}/tree")
|
|
async def repo_tree(request: Request, owner: str, repo: str, path: str = ""):
|
|
"""Get contents of a repo directory (one level)."""
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
items = await gitea.get_repo_contents(owner, repo, path)
|
|
tree = []
|
|
for item in items:
|
|
tree.append({
|
|
"name": item.get("name"),
|
|
"path": item.get("path"),
|
|
"type": "folder" if item.get("type") == "dir" else "file",
|
|
"size": item.get("size", 0),
|
|
"sha": item.get("sha"),
|
|
})
|
|
return {"tree": tree}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── File content ──
|
|
@router.get("/projects/{owner}/{repo}/file")
|
|
async def get_file(request: Request, owner: str, repo: str, path: str):
|
|
"""Get file content (decoded)."""
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
content = await gitea.get_file_content(owner, repo, path)
|
|
return {"content": content, "path": path}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Save file (create or update) ──
|
|
@router.put("/projects/{owner}/{repo}/file")
|
|
async def save_file(request: Request, owner: str, repo: str):
|
|
"""Create or update a file in the repo."""
|
|
gitea = _require_gitea(request) # admin token can write too
|
|
try:
|
|
body = await request.json()
|
|
except Exception:
|
|
body = {}
|
|
path = body.get("path", "").strip("/")
|
|
content = body.get("content", "")
|
|
message = body.get("message", "Update via FlowDeck")
|
|
sha = body.get("sha")
|
|
if not path:
|
|
return JSONResponse({"error": "Path required"}, status_code=400)
|
|
try:
|
|
result = await gitea.create_or_update_file(owner, repo, path, content, message, sha)
|
|
return {"status": "ok", "commit": result.get("commit", {})}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Upload file (binary) ──
|
|
@router.post("/projects/{owner}/{repo}/upload")
|
|
async def upload_file(request: Request, owner: str, repo: str):
|
|
"""Upload a binary file to the repo."""
|
|
import base64
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
form = await request.form()
|
|
except Exception:
|
|
return JSONResponse({"error": "Invalid form data"}, status_code=400)
|
|
file = form.get("file")
|
|
folder = form.get("folder", "")
|
|
message = form.get("message", "Upload via FlowDeck")
|
|
if not file:
|
|
return JSONResponse({"error": "No file provided"}, status_code=400)
|
|
try:
|
|
content = await file.read()
|
|
encoded = base64.b64encode(content).decode("utf-8")
|
|
path = f"{folder.strip('/')}/{file.filename}".strip("/") if folder.strip("/") else file.filename
|
|
result = await gitea.create_or_update_file(owner, repo, path, encoded, message, sha=None)
|
|
return {"status": "ok", "path": path, "commit": result.get("commit", {})}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Delete file ──
|
|
@router.delete("/projects/{owner}/{repo}/file")
|
|
async def delete_file(request: Request, owner: str, repo: str):
|
|
"""Delete a file from the repo."""
|
|
gitea = _require_gitea(request) # admin token can write too
|
|
path = request.query_params.get("path", "")
|
|
sha = request.query_params.get("sha", "")
|
|
message = request.query_params.get("message", "Delete via FlowDeck")
|
|
if not path or not sha:
|
|
return JSONResponse({"error": "Path and SHA required"}, status_code=400)
|
|
try:
|
|
await gitea.delete_file(owner, repo, path, sha, message)
|
|
return {"status": "ok"}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Labels ──
|
|
@router.get("/projects/{owner}/{repo}/labels")
|
|
async def get_labels(request: Request, owner: str, repo: str):
|
|
"""Get labels for a repo (mapped to tags)."""
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
labels = await gitea.get_labels(owner, repo)
|
|
return {"labels": [
|
|
{"id": lbl["id"], "name": lbl["name"], "color": lbl.get("color", "#787774")}
|
|
for lbl in labels
|
|
]}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Account linking ──
|
|
|
|
@router.get("/status")
|
|
def gitea_status(request: Request):
|
|
"""Check if the current user has Gitea linked."""
|
|
from app.services.gitea_client import get_user_gitea_client
|
|
client = get_user_gitea_client(request)
|
|
return {"linked": client is not None}
|
|
|
|
|
|
@router.delete("/disconnect")
|
|
def disconnect_gitea(request: Request):
|
|
"""Remove all Gitea OAuth tokens for the current user."""
|
|
from app.auth.session import SessionManager
|
|
from app.db import get_conn
|
|
user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
|
|
if not user:
|
|
return JSONResponse({"error": "Not authenticated"}, status_code=401)
|
|
with get_conn() as conn:
|
|
conn.execute("DELETE FROM user_oauth_tokens WHERE user_id=? AND provider='gitea'", (user["id"],))
|
|
conn.commit()
|
|
return {"status": "ok"}
|
|
|
|
|
|
# ── Private Pages (local FlowDeck pages linked to Gitea project) ──
|
|
|
|
@router.get("/projects/{owner}/{repo}/private-pages")
|
|
def list_private_pages(owner: str, repo: str, request: Request):
|
|
"""List private pages for this Gitea project."""
|
|
from app.auth.session import SessionManager
|
|
from app.db import get_conn
|
|
user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
|
|
if not user:
|
|
return JSONResponse({"pages": []})
|
|
with get_conn() as conn:
|
|
rows = conn.execute(
|
|
"SELECT id, title, updated_at FROM gitea_private_pages WHERE user_id=? AND gitea_owner=? AND gitea_repo=? ORDER BY updated_at DESC",
|
|
(user["id"], owner, repo),
|
|
).fetchall()
|
|
return {"pages": [{"id": r["id"], "title": r["title"], "updated_at": r["updated_at"]} for r in rows]}
|
|
|
|
|
|
@router.post("/projects/{owner}/{repo}/private-pages")
|
|
def create_private_page(owner: str, repo: str, request: Request, body: dict = Body(default={})):
|
|
"""Create a new private page for this Gitea project."""
|
|
|
|
from app.auth.session import SessionManager
|
|
from app.db import get_conn
|
|
user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
|
|
if not user:
|
|
return JSONResponse({"error": "Not authenticated"}, status_code=401)
|
|
title = body.get("title", "Untitled").strip() or "Untitled"
|
|
with get_conn() as conn:
|
|
cursor = conn.execute(
|
|
"INSERT INTO gitea_private_pages (user_id, gitea_owner, gitea_repo, title) VALUES (?,?,?,?)",
|
|
(user["id"], owner, repo, title),
|
|
)
|
|
conn.commit()
|
|
return {"status": "ok", "page": {"id": cursor.lastrowid, "title": title}}
|
|
|
|
|
|
@router.get("/projects/{owner}/{repo}/private-pages/{page_id}")
|
|
def get_private_page(owner: str, repo: str, page_id: int, request: Request):
|
|
"""Get a single private page."""
|
|
from app.auth.session import SessionManager
|
|
from app.db import get_conn
|
|
user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
|
|
if not user:
|
|
return JSONResponse({"error": "Not authenticated"}, status_code=401)
|
|
with get_conn() as conn:
|
|
row = conn.execute(
|
|
"SELECT * FROM gitea_private_pages WHERE id=? AND user_id=? AND gitea_owner=? AND gitea_repo=?",
|
|
(page_id, user["id"], owner, repo),
|
|
).fetchone()
|
|
if not row:
|
|
return JSONResponse({"error": "Not found"}, status_code=404)
|
|
return {"page": {"id": row["id"], "title": row["title"], "content": row["content"], "updated_at": row["updated_at"]}}
|
|
|
|
|
|
@router.put("/projects/{owner}/{repo}/private-pages/{page_id}")
|
|
def update_private_page(owner: str, repo: str, page_id: int, request: Request, body: dict = Body(default={})):
|
|
"""Update a private page."""
|
|
|
|
from app.auth.session import SessionManager
|
|
from app.db import get_conn
|
|
user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
|
|
if not user:
|
|
return JSONResponse({"error": "Not authenticated"}, status_code=401)
|
|
title = body.get("title", "").strip()
|
|
content = body.get("content", "")
|
|
with get_conn() as conn:
|
|
if title:
|
|
conn.execute(
|
|
"UPDATE gitea_private_pages SET title=?, updated_at=CURRENT_TIMESTAMP WHERE id=? AND user_id=? AND gitea_owner=? AND gitea_repo=?",
|
|
(title, page_id, user["id"], owner, repo),
|
|
)
|
|
conn.execute(
|
|
"UPDATE gitea_private_pages SET content=?, updated_at=CURRENT_TIMESTAMP WHERE id=? AND user_id=? AND gitea_owner=? AND gitea_repo=?",
|
|
(content, page_id, user["id"], owner, repo),
|
|
)
|
|
conn.commit()
|
|
return {"status": "ok"}
|
|
|
|
|
|
@router.delete("/projects/{owner}/{repo}/private-pages/{page_id}")
|
|
def delete_private_page(owner: str, repo: str, page_id: int, request: Request):
|
|
"""Delete a private page."""
|
|
from app.auth.session import SessionManager
|
|
from app.db import get_conn
|
|
user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
|
|
if not user:
|
|
return JSONResponse({"error": "Not authenticated"}, status_code=401)
|
|
with get_conn() as conn:
|
|
conn.execute(
|
|
"DELETE FROM gitea_private_pages WHERE id=? AND user_id=? AND gitea_owner=? AND gitea_repo=?",
|
|
(page_id, user["id"], owner, repo),
|
|
)
|
|
conn.commit()
|
|
return {"status": "ok"}
|
|
|
|
|
|
# ── Commit history for a file ──
|
|
@router.get("/projects/{owner}/{repo}/commits")
|
|
async def file_commits(request: Request, owner: str, repo: str, path: str = ""):
|
|
"""Get recent commits for a specific file."""
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
commits = await gitea.get_file_commits(owner, repo, path)
|
|
return {"commits": commits}
|
|
except Exception as e:
|
|
return JSONResponse({"error": str(e)}, status_code=502)
|
|
|
|
|
|
# ── Sync labels to tags ──
|
|
@router.post("/projects/{owner}/{repo}/sync-labels")
|
|
async def sync_labels(request: Request, owner: str, repo: str):
|
|
"""Sync Gitea labels to FlowDeck tags for the current user."""
|
|
from app.auth.session import get_current_user as gcu
|
|
from app.db import get_conn
|
|
user = gcu(request)
|
|
if not user:
|
|
return JSONResponse({"error": "Not authenticated"}, status_code=401)
|
|
gitea = _require_gitea(request)
|
|
try:
|
|
labels = await gitea.get_labels(owner, repo)
|
|
except Exception:
|
|
labels = []
|
|
imported = 0
|
|
with get_conn() as conn:
|
|
for label in labels:
|
|
name = label.get("name", "")
|
|
color = label.get("color", "#787774")
|
|
if not name:
|
|
continue
|
|
existing = conn.execute(
|
|
"SELECT id FROM tags WHERE name=? AND user_id=?", (name, user["id"])
|
|
).fetchone()
|
|
if not existing:
|
|
conn.execute(
|
|
"INSERT INTO tags (name, color, user_id) VALUES (?, ?, ?)",
|
|
(name, f"#{color}", user["id"]),
|
|
)
|
|
imported += 1
|
|
conn.commit()
|
|
return {"status": "ok", "imported": imported, "total": len(labels)}
|