feat(multiplayer): partital support for multiplayer rooms' filtering

app/router/room.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 from typing import Literal
 
+from app.database.lazer_user import User
 from app.database.room import RoomResp
 from app.dependencies.database import get_db, get_redis
 from app.dependencies.fetcher import get_fetcher
+from app.dependencies.user import get_current_user
 from app.fetcher import Fetcher
 from app.models.room import RoomStatus
 from app.signalr.hub import MultiplayerHubs
@@ -19,68 +21,31 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 @router.get("/rooms", tags=["rooms"], response_model=list[RoomResp])
 async def get_all_rooms(
     mode: Literal["open", "ended", "participated", "owned", None] = Query(
-        None
+        default="open"
     ),  # TODO: 对房间根据状态进行筛选
     category: str = Query(default="realtime"),  # TODO
     status: RoomStatus | None = Query(None),
     db: AsyncSession = Depends(get_db),
     fetcher: Fetcher = Depends(get_fetcher),
     redis: Redis = Depends(get_redis),
+    current_user: User = Depends(get_current_user),
 ):
     rooms = MultiplayerHubs.rooms.values()
-    return [await RoomResp.from_hub(room) for room in rooms]
+    resp_list: list[RoomResp] = []
-
+    for room in rooms:
-
+        if category != "realtime":  # 歌单模式的处理逻辑
-# @router.get("/rooms/{room}", tags=["room"], response_model=Room)
+            if room.category == category:
-# async def get_room(
+                if mode == "owned":
-#     room: int,
+                    if (
-#     db: AsyncSession = Depends(get_db),
+                        room.room.host.user_id if room.room.host is not None else 0
-#     fetcher: Fetcher = Depends(get_fetcher),
+                    ) != current_user.id:
-# ):
+                        continue
-#     redis = get_redis()
+        else:
-#     if redis:
+            if (
-#         dumped_room = str(redis.get(str(room)))
+                room.room.host.user_id if room.room.host is not None else 0
-#         if dumped_room is not None:
+            ) != current_user.id:
-#             resp = await Room.from_mpRoom(
+                continue
-#                 MultiplayerRoom.model_validate_json(str(dumped_room)), db, fetcher
+            if room.status != status:
-#             )
+                continue
-#             return resp
+        resp_list.append(await RoomResp.from_hub(room))
-#         else:
+    return resp_list
-#             raise HTTPException(status_code=404, detail="Room Not Found")
-#     else:
-#         raise HTTPException(status_code=500, detail="Redis error")
-
-
-# class APICreatedRoom(Room):
-#     error: str | None
-
-
-# @router.post("/rooms", tags=["beatmap"], response_model=APICreatedRoom)
-# async def create_room(
-#     room: Room,
-#     db: AsyncSession = Depends(get_db),
-#     fetcher: Fetcher = Depends(get_fetcher),
-# ):
-#     redis = get_redis()
-#     if redis:
-#         room_index = RoomIndex()
-#         db.add(room_index)
-#         await db.commit()
-#         await db.refresh(room_index)
-#         server_room = await MultiplayerRoom.from_apiRoom(room, db, fetcher)
-#         redis.set(str(room_index.id), server_room.model_dump_json())
-#         room.room_id = room_index.id
-#         return APICreatedRoom(**room.model_dump(), error=None)
-#     else:
-#         raise HTTPException(status_code=500, detail="redis error")
-
-
-# @router.delete("/rooms/{room}", tags=["room"])
-# async def remove_room(room: int, db: AsyncSession = Depends(get_db)):
-#     redis = get_redis()
-#     if redis:
-#         redis.delete(str(room))
-#     room_index = await db.get(RoomIndex, room)
-#     if room_index:
-#         await db.delete(room_index)
-#         await db.commit()