bruno
1d1cdbd618
- Panneau peek: les bindings Alpine (x-data absent du conteneur) rendaient loovverture et le redimensionnement inoperants -> cblage direct sur le document. - Helper unique window.fdWirePeekResize (app.js): pointer capture, 300px-90vw, clic=fermer, largeur persiste fd_peek_width partagee entre les 4 peeks. - database-table-container margin:0 (tableau colle a gauche, marge Library). - .lib-container remonte dans app.css (trash etait pleine largeur), .db-index 1100px. - ObsiGate verifie sans code: creation .xlsx OK (openpyxl, #186).
267 lines
11 KiB
Python
267 lines
11 KiB
Python
"""FlowDeck — Calendar links + Meetings API (v7.1.0).
|
|
|
|
``/api/v2/calendar-links*`` — Google/CalDAV link CRUD (session or Bearer
|
|
``write``), manual sync trigger. ``GET /db/{id}/calendar/freebusy`` —
|
|
weekday availability. ``/api/v2/meetings/*`` — audio upload, manual
|
|
transcript, AI summary (fires ``meeting.summarized``).
|
|
|
|
See ``docs/V71_Calendar_Meetings.md``.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import secrets
|
|
from datetime import UTC, date, datetime, timedelta
|
|
|
|
from fastapi import APIRouter, Body, HTTPException, Request
|
|
from fastapi.responses import JSONResponse
|
|
|
|
from app.auth.session import SessionManager
|
|
from app.db import get_conn
|
|
from app.services import calendar_sync as cal
|
|
from app.services import meetings as meet
|
|
from app.services.api_v2_helpers import (
|
|
audit_log,
|
|
has_scope,
|
|
resolve_bearer_token,
|
|
row_to_dict,
|
|
)
|
|
|
|
router = APIRouter(tags=["calendar-meetings"])
|
|
|
|
|
|
def _auth_user(request: Request, *, require_write: bool = False) -> dict:
|
|
sess = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
|
|
if sess:
|
|
return sess
|
|
auth = request.headers.get("authorization") or request.headers.get("Authorization") or ""
|
|
if auth.lower().startswith("bearer "):
|
|
user = resolve_bearer_token(auth[7:].strip())
|
|
if not user:
|
|
raise HTTPException(401, "Invalid or expired API token")
|
|
if require_write and not has_scope(user.get("_token_scopes") or "read", "write"):
|
|
raise HTTPException(403, "Insufficient scope. Required: write")
|
|
return user
|
|
raise HTTPException(401, "Authentication required")
|
|
|
|
|
|
# ── calendar links ─────────────────────────────────────────────────────────
|
|
|
|
@router.post("/api/v2/calendar-links")
|
|
def create_link(request: Request, body: dict = Body(default={})):
|
|
user = _auth_user(request, require_write=True)
|
|
provider = (body.get("provider") or "").lower()
|
|
if provider not in cal.PROVIDERS:
|
|
raise HTTPException(400, "provider must be google|caldav")
|
|
try:
|
|
collection_id = int(body.get("collection_id", 0))
|
|
except (TypeError, ValueError):
|
|
raise HTTPException(400, "collection_id required") from None
|
|
creds = body.get("credentials") or {}
|
|
if provider == "google" and not creds.get("access_token"):
|
|
raise HTTPException(400, "google needs credentials.access_token")
|
|
if provider == "caldav" and not creds.get("url"):
|
|
raise HTTPException(400, "caldav needs credentials.url")
|
|
try:
|
|
out = cal.save_link(user["id"], provider, collection_id, creds,
|
|
body.get("calendar_id") or "primary",
|
|
body.get("date_property") or "")
|
|
except ValueError as exc:
|
|
raise HTTPException(400, str(exc)) from None
|
|
audit_log(user, "calendar.link", "collection", collection_id, provider, request)
|
|
return JSONResponse(status_code=201, content=out)
|
|
|
|
|
|
@router.get("/api/v2/calendar-links")
|
|
def get_links(request: Request):
|
|
user = _auth_user(request)
|
|
return {"links": cal.list_links(user["id"])}
|
|
|
|
|
|
@router.delete("/api/v2/calendar-links/{link_id}")
|
|
def remove_link(link_id: int, request: Request):
|
|
user = _auth_user(request, require_write=True)
|
|
if not cal.delete_link(user["id"], link_id):
|
|
raise HTTPException(404, "Link not found")
|
|
audit_log(user, "calendar.unlink", "calendar_link", link_id, "", request)
|
|
return {"status": "deleted", "id": link_id}
|
|
|
|
|
|
@router.post("/api/v2/calendar-links/{link_id}/sync")
|
|
async def sync_now(link_id: int, request: Request):
|
|
user = _auth_user(request, require_write=True)
|
|
with get_conn() as conn:
|
|
row = conn.execute("SELECT * FROM calendar_links WHERE id=?", (link_id,)).fetchone()
|
|
if not row or (row["user_id"] != user["id"] and not user.get("is_admin")):
|
|
raise HTTPException(404, "Link not found")
|
|
try:
|
|
stats = await cal.sync_link(link_id)
|
|
except (cal.SyncError, ValueError) as exc:
|
|
raise HTTPException(502 if isinstance(exc, cal.SyncError) else 400,
|
|
str(exc)) from None
|
|
audit_log(user, "calendar.sync", "calendar_link", link_id, str(stats), request)
|
|
return {"link_id": link_id, **stats}
|
|
|
|
|
|
# ── free/busy ──────────────────────────────────────────────────────────────
|
|
|
|
@router.get("/db/{collection_id}/calendar/freebusy")
|
|
def freebusy(collection_id: int, request: Request):
|
|
_auth_user(request)
|
|
qp = request.query_params
|
|
try:
|
|
out = cal.freebusy(collection_id, qp.get("from", ""), qp.get("to", ""),
|
|
qp.get("date_property", ""))
|
|
except ValueError as exc:
|
|
raise HTTPException(400, str(exc)) from None
|
|
return out
|
|
|
|
|
|
# ── upcoming (sidebar "Meeting" tab) ────────────────────────────────────────
|
|
|
|
@router.get("/api/v2/meetings/upcoming")
|
|
def upcoming_meetings(request: Request, days: int = 30):
|
|
"""Upcoming calendar events for the sidebar Meeting tab.
|
|
|
|
Reads every calendar collection linked to the current user, extracts the
|
|
date property of each linked row and returns the ones falling in the next
|
|
``days`` days (today included), sorted chronologically. Rows imported from
|
|
Google/CalDAV carry an ``external_event_id`` and are flagged ``synced``.
|
|
"""
|
|
user = _auth_user(request)
|
|
horizon = max(1, min(days, 365))
|
|
today = datetime.now(UTC).date()
|
|
end = today + timedelta(days=horizon)
|
|
events: list[dict] = []
|
|
with get_conn() as conn:
|
|
links = conn.execute(
|
|
"SELECT id, collection_id, date_property, calendar_id, provider "
|
|
"FROM calendar_links WHERE user_id=? ORDER BY id",
|
|
(user["id"],),
|
|
).fetchall()
|
|
for link in links:
|
|
collection_id = link["collection_id"]
|
|
if not collection_id:
|
|
continue
|
|
date_prop = cal.date_prop_id(conn, collection_id,
|
|
link["date_property"] or "")
|
|
if not date_prop:
|
|
continue
|
|
prop_id, prop_name = date_prop
|
|
rows = conn.execute(
|
|
"SELECT id, title, property_values_json, external_event_id "
|
|
"FROM collection_pages WHERE collection_id=?",
|
|
(collection_id,),
|
|
).fetchall()
|
|
for row in rows:
|
|
try:
|
|
values = json.loads(row["property_values_json"] or "{}")
|
|
except (TypeError, ValueError):
|
|
continue
|
|
raw = cal.row_date(values, prop_id, prop_name)[:10]
|
|
if len(raw) != 10:
|
|
continue
|
|
try:
|
|
day = date.fromisoformat(raw)
|
|
except ValueError:
|
|
continue
|
|
if not (today <= day <= end):
|
|
continue
|
|
events.append({
|
|
"id": row["id"],
|
|
"title": row["title"] or "Untitled",
|
|
"date": raw,
|
|
"today": day == today,
|
|
"collection_id": collection_id,
|
|
"calendar_id": link["calendar_id"] or "primary",
|
|
"provider": link["provider"],
|
|
"synced": bool(row["external_event_id"]),
|
|
"url": f"/db/{collection_id}",
|
|
})
|
|
events.sort(key=lambda e: (e["date"], e["title"].lower()))
|
|
return {"today": today.isoformat(), "days": horizon,
|
|
"events": events[:200], "count": len(events)}
|
|
|
|
|
|
# ── meetings ───────────────────────────────────────────────────────────────
|
|
|
|
@router.post("/api/v2/meetings/transcribe")
|
|
async def upload_and_transcribe(request: Request):
|
|
user = _auth_user(request, require_write=True)
|
|
try:
|
|
form = await request.form()
|
|
except Exception:
|
|
raise HTTPException(400, "multipart upload required") from None
|
|
upload = form.get("audio")
|
|
try:
|
|
page_id = int(form.get("page_id", 0))
|
|
except (TypeError, ValueError):
|
|
raise HTTPException(400, "page_id required") from None
|
|
language = (form.get("language") or "fr")[:10]
|
|
manual = (form.get("transcript") or "").strip()
|
|
if upload is None and not manual:
|
|
raise HTTPException(400, "audio file or transcript required")
|
|
audio_path = ""
|
|
if upload is not None:
|
|
filename = (upload.filename or "").lower()
|
|
ext = filename.rsplit(".", 1)[-1] if "." in filename else ""
|
|
if ext not in meet.AUDIO_EXTENSIONS:
|
|
raise HTTPException(400, f"audio must be one of {sorted(meet.AUDIO_EXTENSIONS)}")
|
|
data = await upload.read()
|
|
if len(data) > meet.MAX_AUDIO_BYTES:
|
|
raise HTTPException(413, "audio exceeds 100 MB")
|
|
if not data:
|
|
raise HTTPException(400, "empty audio file")
|
|
audio_path = str(meet.meetings_dir()
|
|
/ f"{page_id}_{secrets.token_hex(8)}.{ext}")
|
|
with open(audio_path, "wb") as fh:
|
|
fh.write(data)
|
|
transcript = manual
|
|
if not transcript and audio_path:
|
|
try:
|
|
transcript = meet.transcribe_audio(audio_path, language)
|
|
except meet.TranscriptionUnavailable as exc:
|
|
transcript = "" # stored; client transcribes or posts manual text later
|
|
_ = exc
|
|
try:
|
|
tid = meet.save_transcript(page_id, transcript, language, audio_path)
|
|
except ValueError as exc:
|
|
raise HTTPException(404, str(exc)) from None
|
|
with get_conn() as conn:
|
|
row = conn.execute("SELECT * FROM meeting_transcripts WHERE id=?", (tid,)).fetchone()
|
|
audit_log(user, "meeting.transcribe", "page", page_id, f"transcript={tid}", request)
|
|
return JSONResponse(status_code=201, content={
|
|
**row_to_dict(row), "transcribed": bool(transcript)})
|
|
|
|
|
|
@router.post("/api/v2/meetings/transcripts/{transcript_id}/text")
|
|
def set_transcript_text(transcript_id: int, request: Request, body: dict = Body(default={})):
|
|
"""Store a client-side (manual) transcript on an existing row."""
|
|
_auth_user(request, require_write=True)
|
|
text = (body.get("transcript") or "").strip()
|
|
if not text:
|
|
raise HTTPException(400, "transcript required")
|
|
with get_conn() as conn:
|
|
if not conn.execute("SELECT id FROM meeting_transcripts WHERE id=?",
|
|
(transcript_id,)).fetchone():
|
|
raise HTTPException(404, "Transcript not found")
|
|
conn.execute("UPDATE meeting_transcripts SET transcript=? WHERE id=?",
|
|
(text, transcript_id))
|
|
conn.commit()
|
|
row = conn.execute("SELECT * FROM meeting_transcripts WHERE id=?",
|
|
(transcript_id,)).fetchone()
|
|
return row_to_dict(row)
|
|
|
|
|
|
@router.post("/api/v2/meetings/transcripts/{transcript_id}/summarize")
|
|
async def summarize(transcript_id: int, request: Request):
|
|
user = _auth_user(request, require_write=True)
|
|
try:
|
|
out = await meet.summarize_transcript(transcript_id, user.get("id"))
|
|
except ValueError as exc:
|
|
raise HTTPException(400, str(exc)) from None
|
|
except RuntimeError as exc:
|
|
raise HTTPException(502, str(exc)) from None
|
|
audit_log(user, "meeting.summarize", "transcript", transcript_id, "", request)
|
|
return out
|