theo-agent-dashboard

topics.py (5334B)

---

 """Topic CRUD routes with session assignment."""
 from __future__ import annotations
 
 import time
 import uuid
 from typing import Any
 
 from fastapi import APIRouter, HTTPException
 
 from app.db import Database
 from app.models import TopicCreate, TopicResponse, TopicUpdate
 
 router = APIRouter(prefix="/api/topics", tags=["topics"])
 
 _db: Database | None = None
 
 
 def get_db() -> Database:  # pragma: no mutate: block
     """Return the module-level database instance."""
     if _db is None:
         raise RuntimeError("Database not initialized")
     return _db
 
 
 def set_db(db: Database) -> None:  # pragma: no mutate: block
     """Inject the database instance (called from lifespan)."""
     global _db  # noqa: PLW0603
     _db = db
 
 
 async def _fetch_topic(topic_id: str) -> dict[str, Any] | None:  # pragma: no mutate: block
     """Fetch a single topic by id."""
     rows = await get_db().fetch_all(
         "SELECT id, name, color, sort_order, created_at FROM topics WHERE id = ?",
         (topic_id,),
     )
     return rows[0] if rows else None
 
 
 async def _count_sessions(topic_id: str) -> int:  # pragma: no mutate: block
     """Count sessions assigned to a topic."""
     rows = await get_db().fetch_all(
         "SELECT COUNT(*) as cnt FROM topic_sessions WHERE topic_id = ?",
         (topic_id,),
     )
     return rows[0]["cnt"] if rows else 0
 
 
 async def _topic_response(row: dict[str, Any]) -> TopicResponse:  # pragma: no mutate: block
     """Build a TopicResponse with session_count."""
     count = await _count_sessions(row["id"])
     return TopicResponse(
         id=row["id"],
         name=row["name"],
         color=row["color"],
         sort_order=row["sort_order"],
         created_at=row["created_at"],
         session_count=count,
     )
 
 
 @router.post("", response_model=TopicResponse)
 async def create_topic(payload: TopicCreate) -> TopicResponse:  # pragma: no mutate: block
     """Create a new topic."""
     topic_id = uuid.uuid4().hex[:12]
     now = int(time.time())
     await get_db().execute(
         "INSERT INTO topics (id, name, color, sort_order, created_at) VALUES (?, ?, ?, 0, ?)",
         (topic_id, payload.name, payload.color or "#6366f1", now),
     )
     row = await _fetch_topic(topic_id)
     assert row is not None
     return await _topic_response(row)
 
 
 @router.get("", response_model=list[TopicResponse])
 async def list_topics() -> list[TopicResponse]:  # pragma: no mutate: block
     """List all topics ordered by sort_order."""
     rows = await get_db().fetch_all(
         "SELECT id, name, color, sort_order, created_at FROM topics ORDER BY sort_order"
     )
     return [await _topic_response(r) for r in rows]
 
 
 @router.patch("/{topic_id}", response_model=TopicResponse)
 async def update_topic(topic_id: str, payload: TopicUpdate) -> TopicResponse:  # pragma: no mutate: block
     """Update a topic's name, color, or sort_order."""
     existing = await _fetch_topic(topic_id)
     if existing is None:
         raise HTTPException(status_code=404, detail="Topic not found")
     updates: list[str] = []
     params: list[Any] = []
     if payload.name is not None:
         updates.append("name = ?")
         params.append(payload.name)
     if payload.color is not None:
         updates.append("color = ?")
         params.append(payload.color)
     if payload.sort_order is not None:
         updates.append("sort_order = ?")
         params.append(payload.sort_order)
     if updates:
         params.append(topic_id)
         await get_db().execute(
             f"UPDATE topics SET {', '.join(updates)} WHERE id = ?",
             tuple(params),
         )
     row = await _fetch_topic(topic_id)
     assert row is not None
     return await _topic_response(row)
 
 
 @router.delete("/{topic_id}")
 async def delete_topic(topic_id: str) -> dict[str, str]:  # pragma: no mutate: block
     """Delete a topic; associated sessions become unsorted."""
     existing = await _fetch_topic(topic_id)
     if existing is None:
         raise HTTPException(status_code=404, detail="Topic not found")
     await get_db().execute(
         "DELETE FROM topic_sessions WHERE topic_id = ?", (topic_id,)
     )
     await get_db().execute(
         "DELETE FROM topics WHERE id = ?", (topic_id,)
     )
     return {"ok": "deleted"}
 
 
 @router.post("/{topic_id}/sessions")
 async def assign_session(topic_id: str, payload: dict) -> dict[str, str]:  # pragma: no mutate: block
     """Assign a session to a topic."""
     existing = await _fetch_topic(topic_id)
     if existing is None:
         raise HTTPException(status_code=404, detail="Topic not found")
     session_id = payload["session_id"]
     now = int(time.time())
     await get_db().execute(
         "INSERT OR REPLACE INTO topic_sessions (topic_id, session_id, assigned_at) VALUES (?, ?, ?)",
         (topic_id, session_id, now),
     )
     return {"ok": "assigned"}
 
 
 @router.delete("/{topic_id}/sessions/{session_id}")
 async def unassign_session(topic_id: str, session_id: str) -> dict[str, str]:  # pragma: no mutate: block
     """Remove a session from a topic."""
     existing = await _fetch_topic(topic_id)
     if existing is None:
         raise HTTPException(status_code=404, detail="Topic not found")
     await get_db().execute(
         "DELETE FROM topic_sessions WHERE topic_id = ? AND session_id = ?",
         (topic_id, session_id),
     )
     return {"ok": "unassigned"}