feat: structured user templates

Author: aydin-utting

alembic/versions/9d080ca9fe6c_add_template_question_table.py

@@ -0,0 +1,57 @@
+"""Add template_question table
+
+Revision ID: 9d080ca9fe6c
+Revises: fe0e69c8d4db
+Create Date: 2025-10-03 16:38:42.892342
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+import sqlmodel
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "9d080ca9fe6c"
+down_revision: str | None = "fe0e69c8d4db"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+templatetype = sa.Enum("DOCUMENT", "FORM", name="templatetype")
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "template_question",
+        sa.Column("id", sa.Uuid(), server_default=sa.text("gen_random_uuid()"), nullable=False),
+        sa.Column("position", sa.Integer(), nullable=False),
+        sa.Column("title", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("user_template_id", sa.Uuid(), nullable=False),
+        sa.ForeignKeyConstraint(["user_template_id"], ["user_template.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    templatetype.create(op.get_bind())
+    op.add_column("user_template", sa.Column("type", templatetype, nullable=False, server_default="DOCUMENT"))
+    op.alter_column(
+        "user_template", "description", existing_type=sa.VARCHAR(), server_default=None, existing_nullable=False
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column(
+        "user_template",
+        "description",
+        existing_type=sa.VARCHAR(),
+        server_default=sa.text("''::character varying"),
+        existing_nullable=False,
+    )
+    op.drop_column("user_template", "type")
+    op.drop_table("template_question")
+    templatetype.drop(op.get_bind())
+    # ### end Alembic commands ###

backend/api/routes/templates.py

@@ -1,19 +1,21 @@
 import datetime
-from collections.abc import Sequence
 from uuid import UUID
 
 from fastapi import APIRouter, HTTPException
+from sqlalchemy.orm import selectinload
 from sqlmodel import col, select
 
 from backend.api.dependencies import UserDep
 from backend.api.dependencies.get_session import SQLSessionDep
-from common.database.postgres_models import UserTemplate
+from common.database.postgres_models import TemplateQuestion, TemplateType, UserTemplate
 from common.services.template_manager import TemplateManager
 from common.settings import get_settings
 from common.types import (
     CreateUserTemplateRequest,
     PatchUserTemplateRequest,
+    Question,
     TemplateMetadata,
+    TemplateResponse,
 )
 
 templates_router = APIRouter(tags=["Templates"])
@@ -34,45 +36,84 @@ def get_templates(user: UserDep) -> list[TemplateMetadata]:  # noqa: ARG001
 
 
 @templates_router.get("/user-templates")
-async def get_user_templates(user: UserDep, session: SQLSessionDep) -> Sequence[UserTemplate]:
-    return (
+async def get_user_templates(user: UserDep, session: SQLSessionDep) -> list[TemplateResponse]:
+    templates = (
         await session.exec(
             select(UserTemplate)
             .where(UserTemplate.user_id == user.id)
             .order_by(col(UserTemplate.updated_datetime).desc())
         )
     ).all()
 
+    return [
+        TemplateResponse(
+            id=template.id,
+            updated_datetime=template.updated_datetime,
+            name=template.name,
+            content=template.content,
+            description=template.description,
+            type=template.type,
+            questions=None,
+        )
+        for template in templates
+    ]
+
 
 @templates_router.get("/user-templates/{template_id}")
-async def get_user_template(user: UserDep, session: SQLSessionDep, template_id: UUID) -> UserTemplate:
+async def get_user_template(user: UserDep, session: SQLSessionDep, template_id: UUID) -> TemplateResponse:
     template = (
-        await session.exec(select(UserTemplate).where(UserTemplate.id == template_id, UserTemplate.user_id == user.id))
+        await session.exec(
+            select(UserTemplate)
+            .where(UserTemplate.id == template_id, UserTemplate.user_id == user.id)
+            .options(selectinload(UserTemplate.questions))
+        )
     ).first()
 
     if not template:
         raise HTTPException(404)
 
-    return template
+    return TemplateResponse(
+        id=template.id,
+        name=template.name,
+        updated_datetime=template.updated_datetime,
+        content=template.content,
+        description=template.description,
+        type=template.type,
+        questions=None
+        if template.type == TemplateType.DOCUMENT
+        else [
+            Question(id=question.id, title=question.title, description=question.description, position=question.position)
+            for question in template.questions
+        ],
+    )
 
 
 @templates_router.post("/user-templates")
-async def create_user_template(
-    user: UserDep, session: SQLSessionDep, request: CreateUserTemplateRequest
-) -> UserTemplate:
+async def create_user_template(user: UserDep, session: SQLSessionDep, request: CreateUserTemplateRequest):
     template = UserTemplate(
-        name=request.name, content=request.content, description=request.description, user_id=user.id
+        name=request.name,
+        content=request.content,
+        description=request.description,
+        user_id=user.id,
+        type=request.type,
+        questions=[
+            TemplateQuestion(
+                position=question.position,
+                title=question.title,
+                description=question.description,
+            )  # type: ignore  # noqa: PGH003
+            for question in (request.questions or [])
+        ],
     )
+
     session.add(template)
     await session.commit()
-    await session.refresh(template)
-    return template
 
 
 @templates_router.patch("/user-templates/{template_id}")
 async def edit_user_template(
     user: UserDep, session: SQLSessionDep, template_id: UUID, request: PatchUserTemplateRequest
-) -> UserTemplate:
+) -> TemplateResponse:
     template = (
         await session.exec(select(UserTemplate).where(UserTemplate.id == template_id, UserTemplate.user_id == user.id))
     ).first()
@@ -86,12 +127,44 @@ async def edit_user_template(
         template.content = request.content
     if request.description is not None:
         template.description = request.description
+    if request.questions is not None:
+        questions = list(
+            (await session.exec(select(TemplateQuestion).where(TemplateQuestion.user_template_id == template_id))).all()
+        )
+        for question in request.questions:
+            if isinstance(question, Question):
+                existing_idx = next((i for i, q in enumerate(questions) if q.id == question.id), None)
+                if existing_idx:
+                    existing = questions.pop(existing_idx)
+                    existing.title = question.title
+                    existing.description = question.description
+                    existing.position = question.position
+                    continue
+
+            session.add(
+                TemplateQuestion(
+                    user_template_id=template_id,
+                    position=question.position,
+                    title=question.title,
+                    description=question.description,
+                )
+            )
+        for remaining_question in questions:
+            await session.delete(remaining_question)
 
     template.updated_datetime = datetime.datetime.now(tz=datetime.UTC)
 
     await session.commit()
 
-    return template
+    return TemplateResponse(
+        id=template.id,
+        name=template.name,
+        updated_datetime=template.updated_datetime,
+        content=template.content,
+        description=template.description,
+        type=template.type,
+        questions=None,
+    )
 
 
 @templates_router.delete("/user-templates/{template_id}")
@@ -108,20 +181,44 @@ async def delete_user_template(user: UserDep, session: SQLSessionDep, template_i
 
 
 @templates_router.post("/user-templates/{template_id}/duplicate")
-async def duplicate_user_template(user: UserDep, session: SQLSessionDep, template_id: UUID) -> UserTemplate:
-    template = (
-        await session.exec(select(UserTemplate).where(UserTemplate.id == template_id, UserTemplate.user_id == user.id))
+async def duplicate_user_template(user: UserDep, session: SQLSessionDep, template_id: UUID) -> TemplateResponse:
+    original_template = (
+        await session.exec(
+            select(UserTemplate)
+            .where(UserTemplate.id == template_id, UserTemplate.user_id == user.id)
+            .options(selectinload(UserTemplate.questions))
+        )
     ).first()
 
-    if not template:
+    if not original_template:
         raise HTTPException(404)
 
-    new_template = UserTemplate(
-        user_id=user.id, name=template.name + " (Copy)", description=template.description, content=template.content
+    template = UserTemplate(
+        user_id=user.id,
+        name=original_template.name + " (Copy)",
+        description=original_template.description,
+        content=original_template.content,
+        type=original_template.type,
+        questions=[
+            TemplateQuestion(
+                position=question.position,
+                title=question.title,
+                description=question.description,
+            )  # type: ignore  # noqa: PGH003
+            for question in original_template.questions
+        ],
     )
 
-    session.add(new_template)
+    session.add(template)
     await session.commit()
-    await session.refresh(new_template)
+    await session.refresh(template)
 
-    return new_template
+    return TemplateResponse(
+        id=template.id,
+        updated_datetime=template.updated_datetime,
+        name=template.name,
+        content=template.content,
+        description=template.description,
+        type=template.type,
+        questions=None,
+    )

common/database/postgres_models.py

@@ -185,6 +185,22 @@ class Transcription(BaseTableMixin, table=True):
     )
 
 
+class TemplateType(StrEnum):
+    DOCUMENT = auto()
+    FORM = auto()
+
+
+class TemplateQuestion(BaseTableMixin, table=True):
+    __tablename__ = "template_question"
+
+    position: int
+    title: str
+    description: str
+
+    user_template_id: UUID = Field(foreign_key="user_template.id", ondelete="CASCADE")
+    user_template: "UserTemplate" = Relationship(back_populates="questions")
+
+
 class UserTemplate(BaseTableMixin, table=True):
     __tablename__ = "user_template"
     created_datetime: datetime = Field(sa_column=created_datetime_column(), default=None)
@@ -194,6 +210,14 @@ class UserTemplate(BaseTableMixin, table=True):
     content: str
     description: str = ""
 
+    type: TemplateType = TemplateType.DOCUMENT
+
     user_id: UUID | None = Field(default=None, foreign_key="user.id")
 
     minutes: list[Minute] = Relationship(back_populates="user_template")
+
+    questions: list[TemplateQuestion] = Relationship(
+        back_populates="user_template",
+        passive_deletes="all",
+        sa_relationship_kwargs={"order_by": TemplateQuestion.position},
+    )

common/services/minute_handler_service.py

@@ -17,7 +17,7 @@
 )
 from common.services.template_manager import TemplateManager
 from common.settings import get_settings
-from common.templates.user_template import UserMarkdownTemplate
+from common.templates.user_template import generate_user_template
 from common.types import (
     LLMHallucination,
     MeetingType,
@@ -166,18 +166,13 @@ async def process_minute_edit_message(cls, source_minute_version_id: UUID, targe
     @classmethod
     async def generate_minute_from_user_template(cls, minute: Minute):
         with SessionLocal() as session:
-            template = session.get(UserTemplate, minute.user_template_id)
+            template = session.get(
+                UserTemplate, minute.user_template_id, options=[selectinload(UserTemplate.questions)]
+            )
         if not template:
             msg = f"No template with id {minute.user_template_id}"
             raise RuntimeError(msg)
-
-        chatbot = create_default_chatbot(FastOrBestLLM.BEST)
-        minutes = await chatbot.chat(
-            UserMarkdownTemplate.prompt(
-                template.content, minute.transcription.dialogue_entries or [], transcription=minute.transcription
-            )
-        )
-        hallucinations = await chatbot.hallucination_check()
+        minutes, hallucinations = await generate_user_template(template=template, transcription=minute.transcription)
         return minutes, hallucinations
 
     @classmethod