fix(solo-score): fix submit solo-score & Bigint

app/router/score.py

@@ -1,17 +1,22 @@
 from __future__ import annotations
 
+import datetime
+
 from app.database import (
     Beatmap,
     User as DBUser,
 )
 from app.database.beatmapset import Beatmapset
 from app.database.score import Score, ScoreResp
+from app.database.score_token import ScoreToken, ScoreTokenResp
+from app.database.user import User
 from app.dependencies.database import get_db
 from app.dependencies.user import get_current_user
+from app.models.score import INT_TO_MODE, HitResult, Rank, SoloScoreSubmissionInfo
 
 from .api_router import router
 
-from fastapi import Depends, HTTPException, Query
+from fastapi import Depends, Form, HTTPException, Query
 from pydantic import BaseModel
 from sqlalchemy.orm import joinedload
 from sqlmodel import col, select
@@ -63,8 +68,8 @@ async def get_beatmap_scores(
     ).first()
 
     return BeatmapScores(
-        scores=[ScoreResp.from_db(score) for score in all_scores],
-        userScore=ScoreResp.from_db(user_score) if user_score else None,
+        scores=[await ScoreResp.from_db(db, score) for score in all_scores],
+        userScore=await ScoreResp.from_db(db, user_score) if user_score else None,
     )
 
 
@@ -115,7 +120,7 @@ async def get_user_beatmap_score(
     else:
         return BeatmapUserScore(
             position=user_score.position if user_score.position is not None else 0,
-            score=ScoreResp.from_db(user_score),
+            score=await ScoreResp.from_db(db, user_score),
         )
 
 
@@ -153,4 +158,113 @@ async def get_user_all_beatmap_scores(
         )
     ).all()
 
-    return [ScoreResp.from_db(score) for score in all_user_scores]
+    return [await ScoreResp.from_db(db, score) for score in all_user_scores]
+
+
+@router.post(
+    "/beatmaps/{beatmap}/solo/scores", tags=["beatmap"], response_model=ScoreTokenResp
+)
+async def create_solo_score(
+    beatmap: int,
+    version_hash: str = Form(""),
+    beatmap_hash: str = Form(),
+    ruleset_id: int = Form(..., ge=0, le=3),
+    current_user: DBUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    async with db:
+        score_token = ScoreToken(
+            user_id=current_user.id,
+            beatmap_id=beatmap,
+            ruleset_id=INT_TO_MODE[ruleset_id],
+        )
+        db.add(score_token)
+        await db.commit()
+        await db.refresh(score_token)
+        return ScoreTokenResp.from_db(score_token)
+
+
+@router.put(
+    "/beatmaps/{beatmap}/solo/scores/{token}",
+    tags=["beatmap"],
+    response_model=ScoreResp,
+)
+async def submit_solo_score(
+    beatmap: int,
+    token: int,
+    info: SoloScoreSubmissionInfo,
+    current_user: DBUser = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    if not info.passed:
+        info.rank = Rank.F
+    async with db:
+        score_token = (
+            await db.exec(
+                select(ScoreToken)
+                .options(joinedload(ScoreToken.beatmap))  # pyright: ignore[reportArgumentType]
+                .where(ScoreToken.id == token, ScoreToken.user_id == current_user.id)
+            )
+        ).first()
+        if not score_token or score_token.user_id != current_user.id:
+            raise HTTPException(status_code=404, detail="Score token not found")
+        if score_token.score_id:
+            score = (
+                await db.exec(
+                    select(Score)
+                    .options(joinedload(Score.beatmap))  # pyright: ignore[reportArgumentType]
+                    .where(
+                        Score.id == score_token.score_id,
+                        Score.user_id == current_user.id,
+                    )
+                )
+            ).first()
+            if not score:
+                raise HTTPException(status_code=404, detail="Score not found")
+        else:
+            score = Score(
+                accuracy=info.accuracy,
+                max_combo=info.max_combo,
+                # maximum_statistics=info.maximum_statistics,
+                mods=info.mods,
+                passed=info.passed,
+                rank=info.rank,
+                total_score=info.total_score,
+                total_score_without_mods=info.total_score_without_mods,
+                beatmap_id=beatmap,
+                ended_at=datetime.datetime.now(datetime.UTC),
+                gamemode=INT_TO_MODE[info.ruleset_id],
+                started_at=score_token.created_at,
+                user_id=current_user.id,
+                preserve=info.passed,
+                map_md5=score_token.beatmap.checksum,
+                has_replay=False,
+                pp=info.pp,
+                type="solo",
+                n300=info.statistics.get(HitResult.GREAT, 0),
+                n100=info.statistics.get(HitResult.OK, 0),
+                n50=info.statistics.get(HitResult.MEH, 0),
+                nmiss=info.statistics.get(HitResult.MISS, 0),
+                ngeki=info.statistics.get(HitResult.PERFECT, 0),
+                nkatu=info.statistics.get(HitResult.GOOD, 0),
+            )
+            db.add(score)
+            await db.commit()
+            await db.refresh(score)
+            score_id = score.id
+            score_token.score_id = score_id
+            await db.commit()
+            score = (
+                await db.exec(
+                    select(Score)
+                    .options(
+                        joinedload(Score.beatmap)  # pyright: ignore[reportArgumentType]
+                        .joinedload(Beatmap.beatmapset)  # pyright: ignore[reportArgumentType]
+                        .selectinload(Beatmapset.beatmaps),  # pyright: ignore[reportArgumentType]
+                        joinedload(Score.user).joinedload(User.lazer_profile),  # pyright: ignore[reportArgumentType]
+                    )
+                    .where(Score.id == score_id)
+                )
+            ).first()
+            assert score is not None
+        return await ScoreResp.from_db(db, score)