ref(application): remove dtos (#9)

Author: emptybutton

src/ttt/application/common/dto/__init__.py

@@ -46,3 +46,18 @@ async def render_no_cell_view(
     async def render_already_filled_cell_error(
         self, player_location: PlayerLocation, game: Game, /,
     ) -> None: ...
+
+    @abstractmethod
+    async def render_player_already_in_game_views(
+        self, locations: Sequence[PlayerLocation],
+    ) -> None: ...
+
+    @abstractmethod
+    async def render_waiting_for_game_view(
+        self, location: PlayerLocation,
+    ) -> None: ...
+
+    @abstractmethod
+    async def render_double_waiting_for_game_view(
+        self, location: PlayerLocation,
+    ) -> None: ...

src/ttt/application/common/dto/player_message.py

@@ -6,8 +6,6 @@
 from ttt.application.common.ports.players import Players
 from ttt.application.common.ports.transaction import Transaction
 from ttt.application.common.ports.uuids import UUIDs
-from ttt.application.game.dto.game_message import PlayerAlreadyInGameMessage
-from ttt.application.game.ports.game_message_sending import GameMessageSending
 from ttt.application.game.ports.game_views import GameViews
 from ttt.application.game.ports.games import Games
 from ttt.application.game.ports.waiting_locations import WaitingLocations
@@ -24,7 +22,6 @@ class StartGame:
     players: Players
     games: Games
     game_views: GameViews
-    game_message_sending: GameMessageSending
     waiting_locations: WaitingLocations
     transaction: Transaction
 
@@ -75,10 +72,9 @@ async def __call__(self) -> None:
                     await self.waiting_locations.push_many(
                         locations_of_players_not_in_game,
                     )
-                    await self.game_message_sending.send_messages(tuple(
-                        PlayerAlreadyInGameMessage(location)
-                        for location in locations_of_players_in_game
-                    ))
+                    await self.game_views.render_player_already_in_game_views(
+                        locations_of_players_in_game,
+                    )
                     continue
 
                 else:

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

@@ -1,47 +1,36 @@
 from dataclasses import dataclass
 
-from ttt.application.common.dto.player_message import (
-    PlayerIsNotRegisteredMessage,
-)
-from ttt.application.common.ports.player_message_sending import (
-    PlayerMessageSending,
-)
 from ttt.application.common.ports.players import Players
 from ttt.application.common.ports.transaction import Transaction
-from ttt.application.game.dto.game_message import (
-    DoubleWaitingForGameMessage,
-    WaitingForGameMessage,
-)
-from ttt.application.game.ports.game_message_sending import GameMessageSending
+from ttt.application.game.ports.game_views import GameViews
 from ttt.application.game.ports.waiting_locations import WaitingLocations
+from ttt.application.player.ports.player_views import PlayerViews
 from ttt.entities.core.player.location import PlayerLocation
 
 
 @dataclass(frozen=True, unsafe_hash=False)
 class WaitGame:
     players: Players
     waiting_locations: WaitingLocations
-    player_message_sending: PlayerMessageSending
-    game_message_sending: GameMessageSending
+    player_views: PlayerViews
+    game_views: GameViews
     transaction: Transaction
 
     async def __call__(self, location: PlayerLocation) -> None:
         async with self.transaction:
             if not await self.players.contains_player_with_id(
                 location.player_id,
             ):
-                await self.player_message_sending.send_message(
-                    PlayerIsNotRegisteredMessage(location),
+                await self.player_views.render_player_is_not_registered_view(
+                    location,
                 )
                 return
 
             push = await self.waiting_locations.push(location)
 
             if push.was_location_dedublicated:
-                await self.game_message_sending.send_message(
-                    DoubleWaitingForGameMessage(location),
+                await self.game_views.render_double_waiting_for_game_view(
+                    location,
                 )
             else:
-                await self.game_message_sending.send_message(
-                    WaitingForGameMessage(location),
-                )
+                await self.game_views.render_waiting_for_game_view(location)

src/ttt/application/game/dto/__init__.py

@@ -1,8 +1,24 @@
 from abc import ABC, abstractmethod
 
+from ttt.entities.core.player.location import PlayerLocation
+
+
+class PlayerViews(ABC):
+    @abstractmethod
+    async def render_view_of_player_with_id(self, player_id: int, /) -> None:
+        ...
+
+    @abstractmethod
+    async def render_player_is_not_registered_view(
+        self, location: PlayerLocation, /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def render_player_already_registered_view(
+        self, location: PlayerLocation, /,
+    ) -> None: ...
 
-class PlayerViews[PlayerWithIDViewT](ABC):
     @abstractmethod
-    async def view_of_player_with_id(
-        self, player_id: int, /,
-    ) -> PlayerWithIDViewT: ...
+    async def render_player_registered_view(
+        self, location: PlayerLocation, /,
+    ) -> None: ...