Link recorded meeting to a transcript

server/reflector/db/__init__.py

@@ -7,6 +7,7 @@ database = databases.Database(settings.DATABASE_URL)
 metadata = sqlalchemy.MetaData()
 
 # import models
+import reflector.db.meetings  # noqa
 import reflector.db.transcripts  # noqa
 
 engine = sqlalchemy.create_engine(

server/reflector/db/meetings.py

@@ -0,0 +1,94 @@
+from datetime import datetime
+
+import sqlalchemy
+from fastapi import HTTPException
+from pydantic import BaseModel
+from reflector.db import database, metadata
+
+meetings = sqlalchemy.Table(
+    "meeting",
+    metadata,
+    sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
+    sqlalchemy.Column("room_name", sqlalchemy.String),
+    sqlalchemy.Column("room_url", sqlalchemy.String),
+    sqlalchemy.Column("host_room_url", sqlalchemy.String),
+    sqlalchemy.Column("viewer_room_url", sqlalchemy.String),
+    sqlalchemy.Column("start_date", sqlalchemy.DateTime),
+    sqlalchemy.Column("end_date", sqlalchemy.DateTime),
+    sqlalchemy.Column("user_id", sqlalchemy.String),
+)
+
+
+class Meeting(BaseModel):
+    id: str
+    room_name: str
+    room_url: str
+    host_room_url: str
+    viewer_room_url: str
+    start_date: datetime
+    end_date: datetime
+    user_id: str
+
+
+class MeetingController:
+    async def add(
+        self,
+        id: str,
+        room_name: str,
+        room_url: str,
+        host_room_url: str,
+        viewer_room_url: str,
+        start_date: datetime,
+        end_date: datetime,
+        user_id: str,
+    ):
+        """
+        Add a new meeting
+        """
+        meeting = Meeting(
+            id=id,
+            room_name=room_name,
+            room_url=room_url,
+            host_room_url=host_room_url,
+            viewer_room_url=viewer_room_url,
+            start_date=start_date,
+            end_date=end_date,
+            user_id=user_id,
+        )
+        query = meetings.insert().values(**meeting.model_dump())
+        await database.execute(query)
+        return meeting
+
+    async def get_by_room_name(
+        self,
+        room_name: str,
+    ) -> Meeting:
+        """
+        Get a meeting by room name.
+        """
+        query = meetings.select().where(meetings.c.room_name == room_name)
+        result = await database.fetch_one(query)
+        if not result:
+            return None
+
+        return Meeting(**result)
+
+    async def get_by_id_for_http(self, meeting_id: str, user_id: str | None) -> Meeting:
+        """
+        Get a meeting by ID for HTTP request.
+
+        If not found, it will raise a 404 error.
+        """
+        query = meetings.select().where(meetings.c.id == meeting_id)
+        result = await database.fetch_one(query)
+        if not result:
+            raise HTTPException(status_code=404, detail="Meeting not found")
+
+        meeting = Meeting(**result)
+        if result["user_id"] != user_id:
+            meeting.host_room_url = ""
+
+        return meeting
+
+
+meetings_controller = MeetingController()

server/reflector/db/transcripts.py

@@ -50,6 +50,10 @@ transcripts = sqlalchemy.Table(
         nullable=False,
         server_default="private",
     ),
+    sqlalchemy.Column(
+        "meeting_id",
+        sqlalchemy.String,
+    ),
 )
 
 
@@ -145,6 +149,7 @@ class Transcript(BaseModel):
     share_mode: Literal["private", "semi-private", "public"] = "private"
     audio_location: str = "local"
     reviewed: bool = False
+    meeting_id: str | None = None
 
     def add_event(self, event: str, data: BaseModel) -> TranscriptEvent:
         ev = TranscriptEvent(event=event, data=data.model_dump())
@@ -329,6 +334,18 @@ class TranscriptController:
             return None
         return Transcript(**result)
 
+    async def get_by_meeting_id(self, meeting_id: str, **kwargs) -> Transcript | None:
+        """
+        Get a transcript by meeting_id
+        """
+        query = transcripts.select().where(transcripts.c.meeting_id == meeting_id)
+        if "user_id" in kwargs:
+            query = query.where(transcripts.c.user_id == kwargs["user_id"])
+        result = await database.fetch_one(query)
+        if not result:
+            return None
+        return Transcript(**result)
+
     async def get_by_id_for_http(
         self,
         transcript_id: str,
@@ -376,6 +393,8 @@ class TranscriptController:
         source_language: str = "en",
         target_language: str = "en",
         user_id: str | None = None,
+        meeting_id: str | None = None,
+        share_mode: str = "private",
     ):
         """
         Add a new transcript
@@ -385,6 +404,8 @@ class TranscriptController:
             source_language=source_language,
             target_language=target_language,
             user_id=user_id,
+            meeting_id=meeting_id,
+            share_mode=share_mode,
         )
         query = transcripts.insert().values(**transcript.model_dump())
         await database.execute(query)