feat: protocol and template API endpoints, auto-pipeline on upload

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-03 22:25:52 +05:00
parent 5c009bc368
commit 29e3047792
5 changed files with 216 additions and 0 deletions
@@ -0,0 +1,103 @@
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.api.deps import get_current_user
+from app.database import get_db
+from app.models.protocol import Protocol
+from app.models.user import User
+from app.schemas.protocol import ProtocolList, ProtocolRegenerate, ProtocolResponse
+from app.tasks.protocol import generate_protocol
+
+router = APIRouter(prefix="/api/protocols", tags=["protocols"])
+
+
+@router.get("", response_model=ProtocolList)
+async def list_protocols(
+    skip: int = 0,
+    limit: int = 50,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    total = (await db.execute(select(func.count(Protocol.id)))).scalar()
+    result = await db.execute(
+        select(Protocol)
+        .order_by(Protocol.created_at.desc())
+        .offset(skip)
+        .limit(limit)
+    )
+    items = list(result.scalars().all())
+    return ProtocolList(items=items, total=total)
+
+
+@router.get("/{protocol_id}", response_model=ProtocolResponse)
+async def get_protocol(
+    protocol_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(Protocol).where(Protocol.id == protocol_id)
+    )
+    protocol = result.scalar_one_or_none()
+    if not protocol:
+        raise HTTPException(404, "Protocol not found")
+    return protocol
+
+
+@router.post("/{protocol_id}/regenerate", status_code=202)
+async def regenerate_protocol(
+    protocol_id: uuid.UUID,
+    data: ProtocolRegenerate,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(Protocol).where(Protocol.id == protocol_id)
+    )
+    protocol = result.scalar_one_or_none()
+    if not protocol:
+        raise HTTPException(404, "Protocol not found")
+
+    template_id = str(data.template_id) if data.template_id else None
+    generate_protocol.delay(str(protocol.transcription_id), template_id)
+    return {"message": "Regeneration started"}
+
+
+@router.put("/{protocol_id}", response_model=ProtocolResponse)
+async def update_protocol_content(
+    protocol_id: uuid.UUID,
+    content: dict,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(Protocol).where(Protocol.id == protocol_id)
+    )
+    protocol = result.scalar_one_or_none()
+    if not protocol:
+        raise HTTPException(404, "Protocol not found")
+
+    protocol.content = content
+    await db.commit()
+    await db.refresh(protocol)
+    return protocol
+
+
+@router.delete("/{protocol_id}", status_code=204)
+async def delete_protocol(
+    protocol_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(Protocol).where(Protocol.id == protocol_id)
+    )
+    protocol = result.scalar_one_or_none()
+    if not protocol:
+        raise HTTPException(404, "Protocol not found")
+    await db.delete(protocol)
+    await db.commit()
@@ -19,6 +19,7 @@ from app.services.recording import (
    get_recordings,
    get_upload_path,
 )
+from app.tasks.transcription import transcribe_recording

 router = APIRouter(prefix="/api/recordings", tags=["recordings"])

@@ -57,6 +58,7 @@ async def upload_recording(
        source=RecordingSource.web,
        duration=duration,
    )
+    transcribe_recording.delay(str(recording.id))
    return recording


@@ -0,0 +1,89 @@
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_current_user
+from app.database import get_db
+from app.models.prompt_template import PromptTemplate
+from app.models.user import User
+from app.schemas.prompt_template import TemplateCreate, TemplateResponse, TemplateUpdate
+
+router = APIRouter(prefix="/api/templates", tags=["templates"])
+
+
+@router.get("", response_model=list[TemplateResponse])
+async def list_templates(
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(PromptTemplate).order_by(PromptTemplate.created_at)
+    )
+    return list(result.scalars().all())
+
+
+@router.post("", response_model=TemplateResponse, status_code=201)
+async def create_template(
+    data: TemplateCreate,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    template = PromptTemplate(**data.model_dump())
+    db.add(template)
+    await db.commit()
+    await db.refresh(template)
+    return template
+
+
+@router.get("/{template_id}", response_model=TemplateResponse)
+async def get_template(
+    template_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(PromptTemplate).where(PromptTemplate.id == template_id)
+    )
+    template = result.scalar_one_or_none()
+    if not template:
+        raise HTTPException(404, "Template not found")
+    return template
+
+
+@router.put("/{template_id}", response_model=TemplateResponse)
+async def update_template(
+    template_id: uuid.UUID,
+    data: TemplateUpdate,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(PromptTemplate).where(PromptTemplate.id == template_id)
+    )
+    template = result.scalar_one_or_none()
+    if not template:
+        raise HTTPException(404, "Template not found")
+
+    for field, value in data.model_dump(exclude_unset=True).items():
+        setattr(template, field, value)
+    await db.commit()
+    await db.refresh(template)
+    return template
+
+
+@router.delete("/{template_id}", status_code=204)
+async def delete_template(
+    template_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    result = await db.execute(
+        select(PromptTemplate).where(PromptTemplate.id == template_id)
+    )
+    template = result.scalar_one_or_none()
+    if not template:
+        raise HTTPException(404, "Template not found")
+    await db.delete(template)
+    await db.commit()