294 lines
10 KiB
Python
294 lines
10 KiB
Python
"""Transcription sessions router — CRUD endpoints for transcription sessions and segments."""
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from typing import Optional, List
|
|
from datetime import datetime
|
|
|
|
from modules.auth.supabase_bearer import SupabaseBearer
|
|
from modules.transcription.models import (
|
|
TranscriptionSessionCreate,
|
|
TranscriptionSessionUpdate,
|
|
TranscriptionSessionResponse,
|
|
SessionListResponse,
|
|
TranscriptionSegmentCreate,
|
|
TranscriptionSegmentResponse,
|
|
SummaryGenerateRequest,
|
|
SummaryResponse,
|
|
ExportFormat,
|
|
)
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def get_supabase_client():
|
|
"""Get Supabase service role client."""
|
|
from modules.database.supabase.utils.client import SupabaseServiceRoleClient
|
|
return SupabaseServiceRoleClient()
|
|
|
|
|
|
def get_user_id(credentials=Depends(SupabaseBearer())) -> str:
|
|
"""Extract user_id from Supabase JWT token."""
|
|
return credentials.get("sub", credentials.get("user_id", ""))
|
|
|
|
|
|
@router.post("/sessions", response_model=TranscriptionSessionResponse)
|
|
async def create_session(
|
|
session_data: TranscriptionSessionCreate,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""Create a new transcription session."""
|
|
supabase = get_supabase_client()
|
|
|
|
data = {
|
|
"user_id": user_id,
|
|
"title": session_data.title,
|
|
"canvas_type": session_data.canvas_type,
|
|
}
|
|
|
|
result = supabase.supabase.table("transcription_sessions").insert(data).execute()
|
|
|
|
if not result.data:
|
|
raise HTTPException(status_code=500, detail="Failed to create session")
|
|
|
|
return result.data[0]
|
|
|
|
|
|
@router.patch("/sessions/{session_id}", response_model=TranscriptionSessionResponse)
|
|
async def update_session(
|
|
session_id: str,
|
|
update_data: TranscriptionSessionUpdate,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""Update a transcription session (end, tag, title)."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Verify ownership
|
|
existing = supabase.supabase.table("transcription_sessions").select("*").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not existing.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
# Build update dict (only non-None fields)
|
|
updates = {k: v for k, v in update_data.model_dump().items() if v is not None}
|
|
updates["updated_at"] = datetime.utcnow().isoformat()
|
|
|
|
result = supabase.supabase.table("transcription_sessions").update(updates).eq("id", session_id).execute()
|
|
|
|
if not result.data:
|
|
raise HTTPException(status_code=500, detail="Failed to update session")
|
|
|
|
return result.data[0]
|
|
|
|
|
|
@router.get("/sessions", response_model=SessionListResponse)
|
|
async def list_sessions(
|
|
user_id: str = Depends(get_user_id),
|
|
page: int = Query(1, ge=1),
|
|
page_size: int = Query(20, ge=1, le=100),
|
|
timetable_period_id: Optional[str] = None,
|
|
):
|
|
"""List transcription sessions for the current user (paginated)."""
|
|
supabase = get_supabase_client()
|
|
|
|
query = supabase.supabase.table("transcription_sessions").select("*", count="exact").eq("user_id", user_id)
|
|
|
|
if timetable_period_id:
|
|
query = query.eq("timetable_period_id", timetable_period_id)
|
|
|
|
query = query.order("started_at", desc=True).range((page - 1) * page_size, page * page_size - 1)
|
|
|
|
result = query.execute()
|
|
|
|
return SessionListResponse(
|
|
sessions=result.data,
|
|
total=result.count or 0,
|
|
page=page,
|
|
page_size=page_size,
|
|
)
|
|
|
|
|
|
@router.get("/sessions/{session_id}", response_model=dict)
|
|
async def get_session(
|
|
session_id: str,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""Get a session with its segments and summaries."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Get session
|
|
session_result = supabase.supabase.table("transcription_sessions").select("*").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not session_result.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
# Get segments
|
|
segments_result = supabase.supabase.table("transcription_segments").select("*").eq("session_id", session_id).order("sequence_index").execute()
|
|
|
|
# Get summaries
|
|
summaries_result = supabase.supabase.table("transcription_summaries").select("*").eq("session_id", session_id).execute()
|
|
|
|
return {
|
|
"session": session_result.data[0],
|
|
"segments": segments_result.data,
|
|
"summaries": summaries_result.data,
|
|
}
|
|
|
|
|
|
@router.delete("/sessions/{session_id}")
|
|
async def delete_session(
|
|
session_id: str,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""Soft delete a transcription session."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Verify ownership
|
|
existing = supabase.supabase.table("transcription_sessions").select("*").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not existing.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
# Soft delete: set ended_at and mark metadata
|
|
result = supabase.supabase.table("transcription_sessions").update({
|
|
"ended_at": datetime.utcnow().isoformat(),
|
|
"metadata": {"deleted": True},
|
|
}).eq("id", session_id).execute()
|
|
|
|
return {"message": "Session deleted"}
|
|
|
|
|
|
@router.post("/sessions/{session_id}/segments")
|
|
async def upsert_segments(
|
|
session_id: str,
|
|
segments: List[TranscriptionSegmentCreate],
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""Batch upsert segments for a session."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Verify session exists and user owns it
|
|
session_check = supabase.supabase.table("transcription_sessions").select("id").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not session_check.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
# Batch insert segments
|
|
segment_data = [s.model_dump() for s in segments]
|
|
|
|
if segment_data:
|
|
result = supabase.supabase.table("transcription_segments").insert(segment_data).execute()
|
|
|
|
# Update segment count on session
|
|
supabase.supabase.table("transcription_sessions").update({
|
|
"segment_count": len(segment_data),
|
|
}).eq("id", session_id).execute()
|
|
|
|
return {"message": f"Upserted {len(segment_data)} segments", "count": len(segment_data)}
|
|
|
|
|
|
@router.get("/sessions/{session_id}/segments", response_model=List[TranscriptionSegmentResponse])
|
|
async def list_segments(
|
|
session_id: str,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""List all segments for a session."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Verify ownership
|
|
session_check = supabase.supabase.table("transcription_sessions").select("id").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not session_check.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
result = supabase.supabase.table("transcription_segments").select("*").eq("session_id", session_id).order("sequence_index").execute()
|
|
|
|
return result.data
|
|
|
|
|
|
@router.post("/sessions/{session_id}/summaries", response_model=SummaryResponse)
|
|
async def generate_summary(
|
|
session_id: str,
|
|
summary_request: SummaryGenerateRequest,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""Generate a summary for a session (Phase 1 stub)."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Verify session exists and user owns it
|
|
session_check = supabase.supabase.table("transcription_sessions").select("id").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not session_check.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
# Phase 1 stub: TODO implement LLM call in Phase 3
|
|
content = "[TODO: Generate summary via LLM — provider={}, model={}]".format(
|
|
summary_request.provider, summary_request.model
|
|
)
|
|
|
|
# Save summary to database
|
|
summary_data = {
|
|
"session_id": session_id,
|
|
"user_id": user_id,
|
|
"summary_type": summary_request.summary_type,
|
|
"content": content,
|
|
"llm_provider": summary_request.provider,
|
|
"llm_model": summary_request.model,
|
|
}
|
|
|
|
result = supabase.supabase.table("transcription_summaries").insert(summary_data).execute()
|
|
|
|
if not result.data:
|
|
raise HTTPException(status_code=500, detail="Failed to save summary")
|
|
|
|
return result.data[0]
|
|
|
|
|
|
@router.get("/sessions/{session_id}/summaries", response_model=List[SummaryResponse])
|
|
async def list_summaries(
|
|
session_id: str,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""List summaries for a session."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Verify ownership
|
|
session_check = supabase.supabase.table("transcription_sessions").select("id").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not session_check.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
result = supabase.supabase.table("transcription_summaries").select("*").eq("session_id", session_id).execute()
|
|
|
|
return result.data
|
|
|
|
|
|
@router.post("/sessions/{session_id}/export")
|
|
async def export_session(
|
|
session_id: str,
|
|
export_format: ExportFormat,
|
|
user_id: str = Depends(get_user_id),
|
|
):
|
|
"""Export session as SRT, TXT, or JSON (Phase 1 stub)."""
|
|
supabase = get_supabase_client()
|
|
|
|
# Verify ownership
|
|
session_check = supabase.supabase.table("transcription_sessions").select("id").eq("id", session_id).eq("user_id", user_id).execute()
|
|
|
|
if not session_check.data:
|
|
raise HTTPException(status_code=404, detail="Session not found")
|
|
|
|
# Get segments
|
|
segments_result = supabase.supabase.table("transcription_segments").select("*").eq("session_id", session_id).order("sequence_index").execute()
|
|
segments = segments_result.data
|
|
|
|
if export_format.format == "srt":
|
|
# Phase 1 stub — implement in Phase 3
|
|
return {"format": "srt", "content": "[TODO: Generate SRT from segments]"}
|
|
elif export_format.format == "txt":
|
|
text = "\n".join(s["text"] for s in segments)
|
|
return {"format": "txt", "content": text}
|
|
elif export_format.format == "json":
|
|
return {"format": "json", "content": {"segments": segments}}
|
|
else:
|
|
raise HTTPException(status_code=400, detail=f"Unsupported format: {export_format.format}")
|