feat: fix issues (#10, #11)

Author: emptybutton

pyproject.toml

@@ -104,6 +104,8 @@ ignore = [
 ]
 
 [tool.ruff.lint.per-file-ignores]
+"src/ttt/infrastructure/adapters/*" = ["ARG002"]
+"src/ttt/presentation/adapters/*" = ["ARG002"]
 "src/ttt/presentation/aiogram/*" = ["RUF001"]
 "tests/*" = ["S101", "PT013", "PLR2004", "D400", "D415"]
 "tests/test_tgdb/test_entities/test_horizon.py" = ["D400", "D415"]

src/ttt/application/common/ports/players.py

@@ -18,12 +18,6 @@ async def contains_player_with_id(
     ) -> bool:
         ...
 
-    @abstractmethod
-    async def player_with_id(self, id_: int, /) -> Player:
-        """
-        :raises ttt.application.common.ports.players.NoPlayerWithIDError:
-        """
-
     @abstractmethod
     @overload
     async def players_with_ids(

src/ttt/application/game/make_move_in_game.py

@@ -8,6 +8,12 @@
 from ttt.application.common.ports.uuids import UUIDs
 from ttt.application.game.ports.game_views import GameViews
 from ttt.application.game.ports.games import Games
+from ttt.entities.core.game.cell import AlreadyFilledCellError
+from ttt.entities.core.game.game import (
+    AlreadyCompletedGameError,
+    NoCellError,
+    NotCurrentPlayerError,
+)
 from ttt.entities.core.player.location import PlayerLocation
 from ttt.entities.math.vector import Vector
 from ttt.entities.tools.assertion import not_none
@@ -29,22 +35,13 @@ async def __call__(
         location: PlayerLocation,
         cell_position: Vector,
     ) -> None:
-        """
-        :raises ttt.application.common.ports.players.NoPlayerWithIDError:
-        :raises ttt.application.game.ports.games.NoGameError:
-        :raises ttt.entities.core.game.game.AlreadyCompletedGameError:
-        :raises ttt.entities.core.game.game.NotCurrentPlayerError:
-        :raises ttt.entities.core.game.game.NoCellError:
-        :raises ttt.entities.core.game.cell.AlreadyFilledCellError:
-        """
-
         async with self.transaction:
-            player = await self.players.player_with_id(location.player_id)
-            game = await self.games.game_with_id(
-                None
-                if player.game_location is None
-                else player.game_location.game_id,
-            )
+            game = await self.games.game_with_game_location(location.player_id)
+
+            if game is None:
+                await self.game_views.render_no_game_view(location)
+                return
+
             locations = tuple(
                 not_none(player.game_location)
                 for player in (game.player1, game.player2)
@@ -54,12 +51,31 @@ async def __call__(
                 self.randoms.random(),
             )
 
-            tracking = Tracking()
-            game.make_move(
-                player.id, cell_position, game_result_id, random, tracking,
-            )
-
-            await self.map_(tracking)
-            await self.game_views.render_game_view_with_locations(
-                locations, game,
-            )
+            try:
+                tracking = Tracking()
+                game.make_move(
+                    location.player_id,
+                    cell_position,
+                    game_result_id,
+                    random,
+                    tracking,
+                )
+            except AlreadyCompletedGameError:
+                await self.game_views.render_game_already_complteted_view(
+                    location, game,
+                )
+            except NotCurrentPlayerError:
+                await self.game_views.render_not_current_player_view(
+                    location, game,
+                )
+            except NoCellError:
+                await self.game_views.render_no_cell_view(location, game)
+            except AlreadyFilledCellError:
+                await self.game_views.render_already_filled_cell_error(
+                    location, game,
+                )
+            else:
+                await self.map_(tracking)
+                await self.game_views.render_game_view_with_locations(
+                    locations, game,
+                )

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

@@ -31,3 +31,18 @@ async def render_no_game_view(
     async def render_game_already_complteted_view(
         self, player_location: PlayerLocation, game: Game, /,
     ) -> None: ...
+
+    @abstractmethod
+    async def render_not_current_player_view(
+        self, player_location: PlayerLocation, game: Game, /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def render_no_cell_view(
+        self, player_location: PlayerLocation, game: Game, /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def render_already_filled_cell_error(
+        self, player_location: PlayerLocation, game: Game, /,
+    ) -> None: ...

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

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from uuid import UUID
 
 from ttt.entities.core.game.game import Game
 
@@ -8,12 +7,6 @@ class NoGameError(Exception): ...
 
 
 class Games(ABC):
-    @abstractmethod
-    async def game_with_id(self, id_: UUID | None, /) -> Game:
-        """
-        :raises ttt.application.game.ports.games.NoGameError:
-        """
-
     @abstractmethod
     async def game_with_game_location(
         self, game_location_player_id: int, /,

src/ttt/infrastructure/adapters/games.py

@@ -1,10 +1,9 @@
 from dataclasses import dataclass
-from uuid import UUID
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from ttt.application.game.ports.games import Games, NoGameError
+from ttt.application.game.ports.games import Games
 from ttt.entities.core.game.game import Game
 from ttt.infrastructure.sqlalchemy.tables import TableGame, TablePlayer
 
@@ -13,14 +12,6 @@
 class InPostgresGames(Games):
     _session: AsyncSession
 
-    async def game_with_id(self, id_: UUID | None, /) -> Game:
-        table_game = await self._session.get(TableGame, id_)
-
-        if table_game is None:
-            raise NoGameError
-
-        return table_game.entity()
-
     async def game_with_game_location(
         self, game_location_player_id: int, /,
     ) -> Game | None:

src/ttt/infrastructure/adapters/players.py

@@ -22,14 +22,6 @@ async def contains_player_with_id(
 
         return bool(await self._session.execute(stmt))
 
-    async def player_with_id(self, id_: int, /) -> Player:
-        table_player = await self._session.get(TablePlayer, id_)
-
-        if table_player is None:
-            raise NoPlayerWithIDError(id_)
-
-        return table_player.entity()
-
     @overload
     async def players_with_ids(
         self, ids: Sequence[int], /,

src/ttt/presentation/adapters/game_views.py

@@ -10,9 +10,12 @@
 from ttt.infrastructure.background_tasks import BackgroundTasks
 from ttt.presentation.aiogram.game.messages import (
     already_completed_game_message,
+    already_filled_cell_message,
     completed_game_messages,
     maked_move_message,
+    no_cell_message,
     no_game_message,
+    not_current_player_message,
     started_game_message,
 )
 
@@ -60,8 +63,29 @@ async def render_no_game_view(
             no_game_message(self._bot, player_location.chat_id),
         )
 
+    async def render_not_current_player_view(
+        self, player_location: PlayerLocation, game: Game, /,
+    ) -> None:
+        self._tasks.create_task(
+            not_current_player_message(self._bot, player_location.chat_id),
+        )
+
+    async def render_no_cell_view(
+        self, player_location: PlayerLocation, game: Game, /,
+    ) -> None:
+        self._tasks.create_task(
+            no_cell_message(self._bot, player_location.chat_id),
+        )
+
+    async def render_already_filled_cell_error(
+        self, player_location: PlayerLocation, game: Game, /,
+    ) -> None:
+        self._tasks.create_task(
+            already_filled_cell_message(self._bot, player_location.chat_id),
+        )
+
     async def render_game_already_complteted_view(
-        self, player_location: PlayerLocation, game: Game, /,  # noqa: ARG002
+        self, player_location: PlayerLocation, game: Game, /,
     ) -> None:
         self._tasks.create_task(
             already_completed_game_message(self._bot, player_location.chat_id),

src/ttt/presentation/aiogram/game/routes/make_move_in_game.py

@@ -1,29 +1,12 @@
-
 from aiogram import F, Router
 from aiogram.types import Message
 from dishka.integrations.aiogram import FromDishka, inject
 
-from ttt.application.common.ports.players import NoPlayerWithIDError
 from ttt.application.game.make_move_in_game import MakeMoveInGame
-from ttt.application.game.ports.games import NoGameError
-from ttt.entities.core.game.cell import AlreadyFilledCellError
-from ttt.entities.core.game.game import (
-    AlreadyCompletedGameError,
-    NoCellError,
-    NotCurrentPlayerError,
-)
 from ttt.entities.core.player.location import PlayerLocation
 from ttt.entities.tools.assertion import not_none
 from ttt.presentation.aiogram.common.messages import (
     anons_are_rohibited_message,
-    need_to_start_message,
-)
-from ttt.presentation.aiogram.game.messages import (
-    already_completed_game_message,
-    already_filled_cell_message,
-    no_cell_message,
-    no_game_message,
-    not_current_player_message,
 )
 
 
@@ -44,23 +27,6 @@ async def _(
     x -= 1
     y -= 1
 
-    try:
-        await make_move_in_game(
-            PlayerLocation(message.from_user.id, message.chat.id), (x, y),
-        )
-    except NoPlayerWithIDError:
-        await need_to_start_message(message)
-    except NoGameError:
-        await no_game_message(not_none(message.bot), message.chat.id)
-    except AlreadyCompletedGameError:
-        await already_completed_game_message(
-            not_none(message.bot), message.chat.id,
-        )
-    except NotCurrentPlayerError:
-        await not_current_player_message(not_none(message.bot), message.chat.id)
-    except NoCellError:
-        await no_cell_message(not_none(message.bot), message.chat.id)
-    except AlreadyFilledCellError:
-        await already_filled_cell_message(
-            not_none(message.bot), message.chat.id,
-        )
+    await make_move_in_game(
+        PlayerLocation(message.from_user.id, message.chat.id), (x, y),
+    )