refactor(router): restructure

app/router/v2/user.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Literal
+
+from app.database import (
+    BeatmapPlaycounts,
+    BeatmapPlaycountsResp,
+    BeatmapsetResp,
+    User,
+    UserResp,
+)
+from app.database.lazer_user import SEARCH_INCLUDED
+from app.database.pp_best_score import PPBestScore
+from app.database.score import Score, ScoreResp
+from app.dependencies.database import get_db
+from app.dependencies.user import get_current_user
+from app.models.score import GameMode
+from app.models.user import BeatmapsetType
+
+from .router import router
+
+from fastapi import Depends, HTTPException, Query, Security
+from pydantic import BaseModel
+from sqlmodel import exists, false, select
+from sqlmodel.ext.asyncio.session import AsyncSession
+from sqlmodel.sql.expression import col
+
+
+class BatchUserResponse(BaseModel):
+    users: list[UserResp]
+
+
+@router.get("/users", response_model=BatchUserResponse)
+@router.get("/users/lookup", response_model=BatchUserResponse)
+@router.get("/users/lookup/", response_model=BatchUserResponse)
+async def get_users(
+    user_ids: list[int] = Query(default_factory=list, alias="ids[]"),
+    current_user: User = Security(get_current_user, scopes=["public"]),
+    include_variant_statistics: bool = Query(default=False),  # TODO: future use
+    session: AsyncSession = Depends(get_db),
+):
+    if user_ids:
+        searched_users = (
+            await session.exec(select(User).limit(50).where(col(User.id).in_(user_ids)))
+        ).all()
+    else:
+        searched_users = (await session.exec(select(User).limit(50))).all()
+    return BatchUserResponse(
+        users=[
+            await UserResp.from_db(
+                searched_user,
+                session,
+                include=SEARCH_INCLUDED,
+            )
+            for searched_user in searched_users
+        ]
+    )
+
+
+@router.get("/users/{user}/{ruleset}", response_model=UserResp)
+@router.get("/users/{user}/", response_model=UserResp)
+@router.get("/users/{user}", response_model=UserResp)
+async def get_user_info(
+    user: str,
+    ruleset: GameMode | None = None,
+    session: AsyncSession = Depends(get_db),
+    current_user: User = Security(get_current_user, scopes=["public"]),
+):
+    searched_user = (
+        await session.exec(
+            select(User).where(
+                User.id == int(user)
+                if user.isdigit()
+                else User.username == user.removeprefix("@")
+            )
+        )
+    ).first()
+    if not searched_user:
+        raise HTTPException(404, detail="User not found")
+    return await UserResp.from_db(
+        searched_user,
+        session,
+        include=SEARCH_INCLUDED,
+        ruleset=ruleset,
+    )
+
+
+@router.get(
+    "/users/{user_id}/beatmapsets/{type}",
+    response_model=list[BeatmapsetResp | BeatmapPlaycountsResp],
+)
+async def get_user_beatmapsets(
+    user_id: int,
+    type: BeatmapsetType,
+    current_user: User = Security(get_current_user, scopes=["public"]),
+    session: AsyncSession = Depends(get_db),
+    limit: int = Query(100, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+):
+    if type in {
+        BeatmapsetType.GRAVEYARD,
+        BeatmapsetType.GUEST,
+        BeatmapsetType.LOVED,
+        BeatmapsetType.NOMINATED,
+        BeatmapsetType.PENDING,
+        BeatmapsetType.RANKED,
+    }:
+        # TODO: mapping, modding
+        resp = []
+
+    elif type == BeatmapsetType.FAVOURITE:
+        user = await session.get(User, user_id)
+        if not user:
+            raise HTTPException(404, detail="User not found")
+        favourites = await user.awaitable_attrs.favourite_beatmapsets
+        resp = [
+            await BeatmapsetResp.from_db(
+                favourite.beatmapset, session=session, user=current_user
+            )
+            for favourite in favourites
+        ]
+
+    elif type == BeatmapsetType.MOST_PLAYED:
+        most_played = await session.exec(
+            select(BeatmapPlaycounts)
+            .where(BeatmapPlaycounts.user_id == user_id)
+            .order_by(col(BeatmapPlaycounts.playcount).desc())
+            .limit(limit)
+            .offset(offset)
+        )
+        resp = [
+            await BeatmapPlaycountsResp.from_db(most_played_beatmap)
+            for most_played_beatmap in most_played
+        ]
+    else:
+        raise HTTPException(400, detail="Invalid beatmapset type")
+
+    return resp
+
+
+@router.get("/users/{user}/scores/{type}", response_model=list[ScoreResp])
+async def get_user_scores(
+    user: int,
+    type: Literal["best", "recent", "firsts", "pinned"],
+    legacy_only: bool = Query(False),
+    include_fails: bool = Query(False),
+    mode: GameMode | None = None,
+    limit: int = Query(100, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    session: AsyncSession = Depends(get_db),
+    current_user: User = Security(get_current_user, scopes=["public"]),
+):
+    db_user = await session.get(User, user)
+    if not db_user:
+        raise HTTPException(404, detail="User not found")
+
+    gamemode = mode or db_user.playmode
+    order_by = None
+    where_clause = (col(Score.user_id) == db_user.id) & (
+        col(Score.gamemode) == gamemode
+    )
+    if not include_fails:
+        where_clause &= col(Score.passed).is_(True)
+    if type == "pinned":
+        where_clause &= Score.pinned_order > 0
+        order_by = col(Score.pinned_order).asc()
+    elif type == "best":
+        where_clause &= exists().where(col(PPBestScore.score_id) == Score.id)
+        order_by = col(Score.pp).desc()
+    elif type == "recent":
+        where_clause &= Score.ended_at > datetime.now(UTC) - timedelta(hours=24)
+        order_by = col(Score.ended_at).desc()
+    elif type == "firsts":
+        # TODO
+        where_clause &= false()
+
+    scores = (
+        await session.exec(
+            select(Score)
+            .where(where_clause)
+            .order_by(order_by)
+            .limit(limit)
+            .offset(offset)
+        )
+    ).all()
+    if not scores:
+        return []
+    return [
+        await ScoreResp.from_db(
+            session,
+            score,
+        )
+        for score in scores
+    ]