added game stat route

shvatka/api/routes/game.py

@@ -13,6 +13,7 @@
     GameFileReaderInteractor,
     GamePlayReaderInteractor,
     GameKeysReaderInteractor,
+    GameStatReaderInteractor,
 )
 from shvatka.core.models import dto
 from shvatka.core.services.game import (
@@ -71,6 +72,15 @@ async def get_game_keys(
     return await interactor(user=user, game_id=id_)
 
 
+@inject
+async def get_game_stat(
+    interactor: FromDishka[GameStatReaderInteractor],
+    user: FromDishka[dto.User],
+    id_: Annotated[int, Path(alias="id")],
+):
+    return await interactor(user=user, game_id=id_)
+
+
 @inject
 async def get_game_file(
     user: Annotated[dto.User, FromDishka()],
@@ -101,5 +111,7 @@ def setup() -> APIRouter:
     router.add_api_route("/active", get_active_game, methods=["GET"])
     router.add_api_route("/running/hints", get_running_game_hints, methods=["GET"])
     router.add_api_route("/{id}", get_game_card, methods=["GET"])
+    router.add_api_route("/{id}/keys", get_game_keys, methods=["GET"])
+    router.add_api_route("/{id}/stat", get_game_stat, methods=["GET"])
     router.add_api_route("/{id}/files/{guid}", get_game_file, methods=["GET"])
     return router

shvatka/core/games/adapters.py

@@ -1,6 +1,6 @@
 from typing import Protocol
 
-from shvatka.core.interfaces.dal.complex import TypedKeyGetter
+from shvatka.core.interfaces.dal.complex import TypedKeyGetter, GameStatDao
 from shvatka.core.interfaces.dal.file_info import FileInfoGetter
 from shvatka.core.interfaces.dal.game import GameByIdGetter, ActiveGameFinder
 from shvatka.core.interfaces.dal.key_log import GameTeamKeyGetter
@@ -14,6 +14,10 @@ class GameKeysReader(TypedKeyGetter, GameByIdGetter, PlayerByUserGetter, Protoco
     pass
 
 
+class GameStatReader(GameStatDao, GameByIdGetter, PlayerByUserGetter, Protocol):
+    pass
+
+
 class GameFileReader(FileInfoGetter, GameByIdGetter, PlayerByUserGetter, Protocol):
     pass
 

shvatka/core/games/interactors.py

@@ -3,10 +3,15 @@
 
 from shvatka.core.games.dto import CurrentHints
 from shvatka.core.interfaces.clients.file_storage import FileGateway
-from shvatka.core.games.adapters import GameFileReader, GamePlayReader, GameKeysReader
+from shvatka.core.games.adapters import (
+    GameFileReader,
+    GamePlayReader,
+    GameKeysReader,
+    GameStatReader,
+)
 from shvatka.core.models import dto
 from shvatka.core.rules.game import check_can_read
-from shvatka.core.services.game_stat import get_typed_keys
+from shvatka.core.services.game_stat import get_typed_keys, get_game_stat
 from shvatka.core.services.scenario.files import check_file_meta_can_read
 from shvatka.core.utils import exceptions
 from shvatka.core.utils.datetime_utils import tz_utc
@@ -23,6 +28,16 @@ async def __call__(self, game_id: int, user: dto.User) -> dict[int, list[dto.Key
         return {t.id: k for t, k in keys.items()}
 
 
+class GameStatReaderInteractor:
+    def __init__(self, dao: GameStatReader):
+        self.dao = dao
+
+    async def __call__(self, game_id: int, user: dto.User) -> dto.GameStat:
+        player = await self.dao.get_by_user(user)
+        game = await self.dao.get_by_id(game_id)
+        return await get_game_stat(game, player, self.dao)
+
+
 class GameFileReaderInteractor:
     def __init__(self, dao: GameFileReader, file_gateway: FileGateway):
         self.file_gateway = file_gateway

shvatka/core/interfaces/dal/complex.py

@@ -8,6 +8,7 @@
     GameStatusCompleter,
 )
 from shvatka.core.interfaces.dal.key_log import TeamKeysMerger, GameKeyGetter
+from shvatka.core.interfaces.dal.level import MaxLevelNumberGetter
 from shvatka.core.interfaces.dal.level_times import TeamLevelsMerger, LevelTimesGetter
 from shvatka.core.interfaces.dal.organizer import OrgByPlayerGetter
 from shvatka.core.interfaces.dal.player import TeamPlayersMerger
@@ -33,9 +34,8 @@ class TypedKeyGetter(GameKeyGetter, OrgByPlayerGetter, Protocol):
     pass
 
 
-class GameStatDao(OrgByPlayerGetter, LevelTimesGetter, Protocol):
-    async def get_max_level_number(self, game: dto.Game) -> int:
-        raise NotImplementedError
+class GameStatDao(OrgByPlayerGetter, LevelTimesGetter, MaxLevelNumberGetter, Protocol):
+    pass
 
 
 class GameCompleter(

shvatka/core/interfaces/dal/level.py

@@ -61,3 +61,8 @@ async def delete(self, level_id: int) -> None:
 
 class LevelCorrectUnlinker(Committer, LevelUnlinker, LevelReorder, Protocol):
     pass
+
+
+class MaxLevelNumberGetter(Protocol):
+    async def get_max_level_number(self, game: dto.Game) -> int:
+        raise NotImplementedError

shvatka/infrastructure/db/dao/complex/level_times.py

@@ -1,6 +1,7 @@
 import typing
 from dataclasses import dataclass
 
+from shvatka.core.games.adapters import GameStatReader
 from shvatka.core.interfaces.dal.complex import GameStatDao
 from shvatka.core.models import dto
 
@@ -30,3 +31,36 @@ async def get_game_level_times_by_teams(
         self, game: dto.Game, levels_count: int
     ) -> dict[dto.Team, list[dto.LevelTimeOnGame]]:
         return await self.dao.level_time.get_game_level_times_by_teams(game, levels_count)
+
+
+class GameStatReaderImpl(GameStatReader):
+    def __init__(self, dao: "HolderDao"):
+        self.dao = dao
+
+    async def get_game_level_times(self, game: dto.Game) -> list[dto.LevelTime]:
+        return await self.dao.level_time.get_game_level_times(game)
+
+    async def get_max_level_number(self, game: dto.Game) -> int:
+        return await self.dao.level.get_max_level_number(game)
+
+    async def get_by_player(self, game: dto.Game, player: dto.Player) -> dto.SecondaryOrganizer:
+        return await self.dao.organizer.get_by_player(game=game, player=player)
+
+    async def get_by_player_or_none(
+        self, game: dto.Game, player: dto.Player
+    ) -> dto.SecondaryOrganizer | None:
+        return await self.dao.organizer.get_by_player_or_none(game=game, player=player)
+
+    async def get_game_level_times_by_teams(
+        self, game: dto.Game, levels_count: int
+    ) -> dict[dto.Team, list[dto.LevelTimeOnGame]]:
+        return await self.dao.level_time.get_game_level_times_by_teams(game, levels_count)
+
+    async def get_by_id(self, id_: int, author: dto.Player | None = None) -> dto.Game:
+        return await self.dao.game.get_by_id(id_, author)
+
+    async def get_full(self, id_: int) -> dto.FullGame:
+        return await self.dao.game.get_full(id_)
+
+    async def get_by_user(self, user: dto.User) -> dto.Player:
+        return await self.dao.player.get_by_user(user)

shvatka/infrastructure/di/interactors.py

@@ -4,10 +4,17 @@
     GameFileReaderInteractor,
     GamePlayReaderInteractor,
     GameKeysReaderInteractor,
+    GameStatReaderInteractor,
+)
+from shvatka.core.games.adapters import (
+    GameFileReader,
+    GamePlayReader,
+    GameKeysReader,
+    GameStatReader,
 )
-from shvatka.core.games.adapters import GameFileReader, GamePlayReader, GameKeysReader
 from shvatka.infrastructure.db.dao.complex.game import GameFilesGetterImpl, GamePlayReaderImpl
 from shvatka.infrastructure.db.dao.complex.key_log import GameKeysReaderImpl
+from shvatka.infrastructure.db.dao.complex.level_times import GameStatReaderImpl
 from shvatka.infrastructure.db.dao.holder import HolderDao
 
 
@@ -20,6 +27,12 @@ def get_game_keys(self, dao: HolderDao) -> GameKeysReader:
 
     get_game_keys_interactor = provide(GameKeysReaderInteractor)
 
+    @provide
+    def get_game_state(self, dao: HolderDao) -> GameStatReader:
+        return GameStatReaderImpl(dao)
+
+    get_game_state_interactor = provide(GameStatReaderInteractor)
+
     @provide
     def get_game_files(self, dao: HolderDao) -> GameFileReader:
         return GameFilesGetterImpl(dao)