Permanent room urls

server/reflector/db/__init__.py

@@ -8,6 +8,7 @@ metadata = sqlalchemy.MetaData()
 
 # import models
 import reflector.db.meetings  # noqa
+import reflector.db.rooms  # noqa
 import reflector.db.transcripts  # noqa
 
 engine = sqlalchemy.create_engine(

server/reflector/db/meetings.py

@@ -16,6 +16,7 @@ meetings = sqlalchemy.Table(
     sqlalchemy.Column("start_date", sqlalchemy.DateTime),
     sqlalchemy.Column("end_date", sqlalchemy.DateTime),
     sqlalchemy.Column("user_id", sqlalchemy.String),
+    sqlalchemy.Column("room_id", sqlalchemy.String),
 )
 
 
@@ -28,10 +29,11 @@ class Meeting(BaseModel):
     start_date: datetime
     end_date: datetime
     user_id: str
+    room_id: str | None = None
 
 
 class MeetingController:
-    async def add(
+    async def create(
         self,
         id: str,
         room_name: str,
@@ -41,9 +43,10 @@ class MeetingController:
         start_date: datetime,
         end_date: datetime,
         user_id: str,
+        room_id: str = None,
     ):
         """
-        Add a new meeting
+        Create a new meeting
         """
         meeting = Meeting(
             id=id,
@@ -54,6 +57,7 @@ class MeetingController:
             start_date=start_date,
             end_date=end_date,
             user_id=user_id,
+            room_id=room_id,
         )
         query = meetings.insert().values(**meeting.model_dump())
         await database.execute(query)
@@ -73,6 +77,20 @@ class MeetingController:
 
         return Meeting(**result)
 
+    async def get_latest(self, room_id: str) -> Meeting:
+        """
+        Get latest meeting for a room.
+        """
+        start_date = getattr(meetings.c, "start_date").desc()
+        query = (
+            meetings.select().where(meetings.c.room_id == room_id).order_by(start_date)
+        )
+        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.

server/reflector/db/rooms.py

@@ -0,0 +1,139 @@
+from datetime import datetime
+
+import sqlalchemy
+from fastapi import HTTPException
+from pydantic import BaseModel, ConfigDict, Field
+from reflector.db import database, metadata
+from reflector.db.transcripts import generate_uuid4
+from sqlalchemy.sql import false
+
+rooms = sqlalchemy.Table(
+    "room",
+    metadata,
+    sqlalchemy.Column("id", sqlalchemy.String, primary_key=True),
+    sqlalchemy.Column("name", sqlalchemy.String, nullable=False),
+    sqlalchemy.Column("user_id", sqlalchemy.String, nullable=False),
+    sqlalchemy.Column("created_at", sqlalchemy.DateTime, nullable=False),
+    sqlalchemy.Column(
+        "zulip_auto_post", sqlalchemy.Boolean, nullable=False, server_default=false()
+    ),
+    sqlalchemy.Column("zulip_stream", sqlalchemy.String),
+    sqlalchemy.Column("zulip_topic", sqlalchemy.String),
+)
+
+
+class Room(BaseModel):
+    id: str = Field(default_factory=generate_uuid4)
+    name: str
+    user_id: str
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    zulip_auto_post: bool = False
+    zulip_stream: str = ""
+    zulip_topic: str = ""
+
+
+class RoomController:
+    async def get_all(
+        self,
+        user_id: str | None = None,
+        order_by: str | None = None,
+        return_query: bool = False,
+    ) -> list[Room]:
+        """
+        Get all rooms
+
+        If `user_id` is specified, only return rooms that belong to the user.
+        Otherwise, return all rooms.
+
+        Parameters:
+        - `order_by`: field to order by, e.g. "-created_at"
+        """
+        query = rooms.select()
+        if user_id is not None:
+            query = query.where(rooms.c.user_id == user_id)
+
+        if order_by is not None:
+            field = getattr(rooms.c, order_by[1:])
+            if order_by.startswith("-"):
+                field = field.desc()
+            query = query.order_by(field)
+
+        if return_query:
+            return query
+
+        results = await database.fetch_all(query)
+        return results
+
+    async def add(
+        self,
+        name: str,
+        user_id: str,
+    ):
+        """
+        Add a new room
+        """
+        room = Room(
+            name=name,
+            user_id=user_id,
+        )
+        query = rooms.insert().values(**room.model_dump())
+        await database.execute(query)
+        return room
+
+    async def get_by_id(self, room_id: str, **kwargs) -> Room | None:
+        """
+        Get a room by id
+        """
+        query = rooms.select().where(rooms.c.id == room_id)
+        if "user_id" in kwargs:
+            query = query.where(rooms.c.user_id == kwargs["user_id"])
+        result = await database.fetch_one(query)
+        if not result:
+            return None
+        return Room(**result)
+
+    async def get_by_name(self, room_name: str, **kwargs) -> Room | None:
+        """
+        Get a room by name
+        """
+        query = rooms.select().where(rooms.c.name == room_name)
+        if "user_id" in kwargs:
+            query = query.where(rooms.c.user_id == kwargs["user_id"])
+        result = await database.fetch_one(query)
+        if not result:
+            return None
+        return Room(**result)
+
+    async def get_by_id_for_http(self, meeting_id: str, user_id: str | None) -> Room:
+        """
+        Get a room by ID for HTTP request.
+
+        If not found, it will raise a 404 error.
+        """
+        query = rooms.select().where(rooms.c.id == meeting_id)
+        result = await database.fetch_one(query)
+        if not result:
+            raise HTTPException(status_code=404, detail="Room not found")
+
+        room = Room(**result)
+
+        return room
+
+    async def remove_by_id(
+        self,
+        room_id: str,
+        user_id: str | None = None,
+    ) -> None:
+        """
+        Remove a room by id
+        """
+        room = await self.get_by_id(room_id, user_id=user_id)
+        if not room:
+            return
+        if user_id is not None and room.user_id != user_id:
+            return
+        query = rooms.delete().where(rooms.c.id == room_id)
+        await database.execute(query)
+
+
+rooms_controller = RoomController()