ref(user): remove UserGameLocation

Author: emptybutton

src/ttt/application/game/game/cancel_game.py

@@ -7,8 +7,6 @@
 from ttt.application.game.game.ports.game_views import GameViews
 from ttt.application.game.game.ports.games import Games
 from ttt.entities.core.game.game import AlreadyCompletedGameError
-from ttt.entities.core.user.user import User
-from ttt.entities.tools.assertion import not_none
 from ttt.entities.tools.tracking import Tracking
 
 
@@ -23,18 +21,12 @@ class CancelGame:
 
     async def __call__(self, user_id: int) -> None:
         async with self.transaction:
-            game = await self.games.game_with_game_location(user_id)
+            game = await self.games.current_user_game(user_id)
 
             if game is None:
                 await self.game_views.no_game_view(user_id)
                 return
 
-            locations = tuple(
-                not_none(user.game_location)
-                for user in (game.player1, game.player2)
-                if isinstance(user, User)
-            )
-
             try:
                 tracking = Tracking()
                 game.cancel(user_id, tracking)
@@ -49,7 +41,4 @@ async def __call__(self, user_id: int) -> None:
             await self.log.game_cancelled(user_id, game)
 
             await self.map_(tracking)
-            await self.game_views.game_view_with_locations(
-                locations,
-                game,
-            )
+            await self.game_views.game_view(game)

src/ttt/application/game/game/make_move_in_game.py

@@ -17,8 +17,6 @@
     NoCellError,
     NotCurrentPlayerError,
 )
-from ttt.entities.core.user.user import User
-from ttt.entities.tools.assertion import not_none
 from ttt.entities.tools.tracking import Tracking
 
 
@@ -41,17 +39,12 @@ async def __call__(
         cell_number_int: int,
     ) -> None:
         async with self.transaction:
-            game = await self.games.game_with_game_location(user_id)
+            game = await self.games.current_user_game(user_id)
 
             if game is None:
                 await self.game_views.no_game_view(user_id)
                 return
 
-            locations = tuple(
-                not_none(user.game_location)
-                for user in (game.player1, game.player2)
-                if isinstance(user, User)
-            )
             (
                 random,
                 games_played_by_player_id,
@@ -110,10 +103,7 @@ async def __call__(
                 await self.log.user_move_maked(user_id, game, user_move)
 
                 if user_move.next_move_ai_id is not None:
-                    await self.game_views.game_view_with_locations(
-                        locations,
-                        game,
-                    )
+                    await self.game_views.game_view(game)
 
                     (
                         free_cell_random,
@@ -142,7 +132,4 @@ async def __call__(
                     await self.log.game_completed(user_id, game)
 
                 await self.map_(tracking)
-                await self.game_views.game_view_with_locations(
-                    locations,
-                    game,
-                )
+                await self.game_views.game_view(game)

src/ttt/application/game/game/ports/game_views.py

@@ -1,26 +1,18 @@
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
 
 from ttt.entities.core.game.game import Game
-from ttt.entities.core.user.location import UserGameLocation
 
 
 class GameViews(ABC):
     @abstractmethod
     async def current_game_view_with_user_id(self, user_id: int, /) -> None: ...
 
     @abstractmethod
-    async def game_view_with_locations(
-        self,
-        user_locations: Sequence[UserGameLocation],
-        game: Game,
-        /,
-    ) -> None: ...
+    async def game_view(self, game: Game, /) -> None: ...
 
     @abstractmethod
-    async def started_game_view_with_locations(
+    async def started_game_view(
         self,
-        user_locations: Sequence[UserGameLocation],
         game: Game,
         /,
     ) -> None: ...

src/ttt/application/game/game/ports/games.py

@@ -8,8 +8,4 @@ class NoGameError(Exception): ...
 
 class Games(ABC):
     @abstractmethod
-    async def game_with_game_location(
-        self,
-        game_location_user_id: int,
-        /,
-    ) -> Game | None: ...
+    async def current_user_game(self, user_id: int, /) -> Game | None: ...

src/ttt/application/game/game/start_game_with_ai.py

@@ -14,7 +14,6 @@
 from ttt.application.user.common.ports.users import Users
 from ttt.entities.core.game.ai import AiType
 from ttt.entities.core.game.game import start_game_with_ai
-from ttt.entities.core.user.location import UserGameLocation
 from ttt.entities.core.user.user import UserAlreadyInGameError
 from ttt.entities.tools.tracking import Tracking
 
@@ -71,15 +70,9 @@ async def __call__(self, user_id: int, ai_type: AiType) -> None:
 
                 if started_game.next_move_ai_id is None:
                     await self.map_(tracking)
-                    await self.game_views.started_game_view_with_locations(
-                        [UserGameLocation(user_id, started_game.game.id)],
-                        started_game.game,
-                    )
+                    await self.game_views.started_game_view(started_game.game)
                 else:
-                    await self.game_views.started_game_view_with_locations(
-                        [UserGameLocation(user_id, started_game.game.id)],
-                        started_game.game,
-                    )
+                    await self.game_views.started_game_view(started_game.game)
 
                     (
                         free_cell_random,
@@ -104,7 +97,4 @@ async def __call__(self, user_id: int, ai_type: AiType) -> None:
                     )
 
                     await self.map_(tracking)
-                    await self.game_views.game_view_with_locations(
-                        [UserGameLocation(user_id, started_game.game.id)],
-                        started_game.game,
-                    )
+                    await self.game_views.game_view(started_game.game)

src/ttt/application/matchmaking_queue/game/wait_game.py

@@ -97,7 +97,4 @@ async def __call__(self, user_id: int) -> None:
                 await self.game_log.game_against_user_started(game)
                 await self.map_(tracking)
 
-                await self.game_views.started_game_view_with_locations(
-                    game.locations(),
-                    game,
-                )
+                await self.game_views.started_game_view(game)

src/ttt/entities/core/game/game.py

@@ -28,7 +28,6 @@
     PlayerLoss,
     PlayerWin,
 )
-from ttt.entities.core.user.location import UserGameLocation
 from ttt.entities.core.user.user import (
     User,
     UserAlreadyInGameError,
@@ -111,7 +110,7 @@ class Game:
 
     def __post_init__(self) -> None:
         assert_(
-            not all(isinstance(player, Ai) for player in self._players()),
+            not all(isinstance(player, Ai) for player in self.players()),
             else_=OnlyAiGameError,
         )
 
@@ -141,7 +140,7 @@ def is_against_user(self) -> bool:
         return not self.is_against_ai()
 
     def user(self, user_id: int) -> User | None:
-        for user in self._users():
+        for user in self.users():
             if user.id == user_id:
                 return user
 
@@ -195,10 +194,10 @@ def make_user_move(  # noqa: C901
         if not isinstance(current_player, User):
             raise TypeError
 
-        not_current_player = not_none(self._not_current_player())
+        not_current_player = not_none(self.not_current_player())
 
         assert_(
-            user_id in {user.id for user in self._users()},
+            user_id in {user.id for user in self.users()},
             else_=NotPlayerError(),
         )
         assert_(current_player.id == user_id, else_=NotCurrentPlayerError())
@@ -296,7 +295,7 @@ def make_ai_move(
         if not isinstance(current_player, Ai):
             raise NotAiCurrentMoveError
 
-        not_current_player = self._not_current_player()
+        not_current_player = self.not_current_player()
         if not isinstance(not_current_player, User):
             raise TypeError
 
@@ -384,9 +383,6 @@ def is_player_move_expected(self, player_id: int | UUID) -> bool:
             case _:
                 raise ValueError(self.state, player_id)
 
-    def locations(self) -> tuple[UserGameLocation, ...]:
-        return tuple(not_none(user.game_location) for user in self._users())
-
     def _make_random_ai_move(
         self,
         current_player: Ai,
@@ -459,15 +455,15 @@ def _current_player(self) -> Player | None:
             case GameState.completed:
                 return None
 
-    def _players(self) -> tuple[Player, ...]:
+    def players(self) -> tuple[Player, ...]:
         return self.player1, self.player2
 
-    def _users(self) -> tuple[User, ...]:
+    def users(self) -> tuple[User, ...]:
         return tuple(
-            player for player in self._players() if isinstance(player, User)
+            player for player in self.players() if isinstance(player, User)
         )
 
-    def _not_current_player(self) -> Player | None:
+    def not_current_player(self) -> Player | None:
         match self.state:
             case GameState.wait_player1:
                 return self.player2

src/ttt/entities/core/user/location.py

@@ -12,7 +12,6 @@
 )
 from ttt.entities.core.user.draw import UserDraw
 from ttt.entities.core.user.emoji import UserEmoji
-from ttt.entities.core.user.location import UserGameLocation
 from ttt.entities.core.user.loss import UserLoss
 from ttt.entities.core.user.rank import Rank, rank_for_rating
 from ttt.entities.core.user.win import UserWin
@@ -83,7 +82,7 @@ class User:
     selected_emoji_id: UUID | None
     rating: EloRating
     admin_right: AdminRight | None
-    game_location: UserGameLocation | None
+    current_game_id: UUID | None
 
     emoji_cost: ClassVar[Stars] = 1000
 
@@ -221,7 +220,7 @@ def set_user_account(
         return user
 
     def is_in_game(self) -> bool:
-        return self.game_location is not None
+        return self.current_game_id is not None
 
     def be_in_game(
         self,
@@ -234,7 +233,7 @@ def be_in_game(
 
         assert_(not self.is_in_game(), else_=UserAlreadyInGameError(self))
 
-        self.game_location = UserGameLocation(self.id, game_id)
+        self.current_game_id = game_id
         tracking.register_mutated(self)
 
     def lose_to_user(
@@ -346,7 +345,7 @@ def leave_game(self, tracking: Tracking) -> None:
 
         assert_(self.is_in_game(), else_=UserNotInGameError(self))
 
-        self.game_location = None
+        self.current_game_id = None
         tracking.register_mutated(self)
 
     def buy_emoji(
@@ -428,16 +427,16 @@ def register_user(user_id: int, tracking: Tracking) -> User:
         emojis=[],
         selected_emoji_id=None,
         rating=initial_elo_rating,
-        game_location=None,
+        current_game_id=None,
         admin_right=None,
     )
     tracking.register_new(user)
 
     return user
 
 
-def is_user_in_game(game_location: UserGameLocation | None) -> bool:
-    return game_location is not None
+def is_user_in_game(current_game_id: UUID | None) -> bool:
+    return current_game_id is not None
 
 
 def is_user_admin(admin_right: AdminRight | None) -> bool:

src/ttt/entities/core/user/user.py

@@ -13,21 +13,17 @@
 class InPostgresGames(Games):
     _session: AsyncSession
 
-    async def game_with_game_location(
-        self,
-        game_location_user_id: int,
-        /,
-    ) -> Game | None:
+    async def current_user_game(self, user_id: int, /) -> Game | None:
         lock_stmt = (
             select(TableGame.id)
-            .where(TableUser.game_location_game_id == TableGame.id)
+            .where(TableUser.current_game_id == TableGame.id)
             .with_for_update()
         )
         await self._session.execute(lock_stmt)
 
         join_condition = (
-            (TableUser.id == game_location_user_id)
-            & (TableUser.game_location_game_id == TableGame.id)
+            (TableUser.id == user_id)
+            & (TableUser.current_game_id == TableGame.id)
         )
         stmt = select(TableGame).join(TableUser, join_condition)
         table_game = await self._session.scalar(stmt)