Merge pull request #91 from bomzheg/feature/#19

added sending info about prepared game to all teams

pyproject.toml

@@ -55,7 +55,7 @@ optional = true
 pytest = "^7.2.0"
 pytest-ordering = "^0.6"
 pytest-asyncio = "^0.18.3"
-testcontainers = {extras = ["postgresql"], version = "^3.7.0"}
+testcontainers = {extras = ["postgresql"], version = "^4.5.1"}
 httpx = "^0.23.0"
 coverage = {extras = ["toml"], version = "*"}
 ruff = "^0.2.1"

shvatka/api/routes/auth.py

@@ -2,7 +2,7 @@
 from typing import Annotated
 
 from aiogram.types import User
-from dishka.integrations.fastapi import inject, FromDishka as Depends
+from dishka.integrations.fastapi import inject, FromDishka
 from fastapi import Depends as fDepends, Body
 from fastapi import APIRouter
 from fastapi.security import OAuth2PasswordRequestForm
@@ -37,9 +37,9 @@
 @inject
 async def login(
     response: Response,
-    auth_properties: Annotated[AuthProperties, Depends()],
-    config: Annotated[AuthConfig, Depends()],
-    dao: Annotated[HolderDao, Depends()],
+    auth_properties: FromDishka[AuthProperties],
+    config: FromDishka[AuthConfig],
+    dao: FromDishka[HolderDao],
     form_data: OAuth2PasswordRequestForm = fDepends(),
 ):
     user = await auth_properties.authenticate_user(form_data.username, form_data.password, dao)
@@ -51,7 +51,7 @@ async def login(
 @inject
 async def logout(
     response: Response,
-    config: Annotated[AuthConfig, Depends()],
+    config: FromDishka[AuthConfig],
 ):
     response.delete_cookie(
         "Authorization",
@@ -67,9 +67,9 @@ async def logout(
 async def tg_login_result(
     response: Response,
     user: Annotated[UserTgAuth, fDepends()],
-    dao: Annotated[HolderDao, Depends()],
-    auth_properties: Annotated[AuthProperties, Depends()],
-    config: Annotated[AuthConfig, Depends()],
+    dao: FromDishka[HolderDao],
+    auth_properties: FromDishka[AuthProperties],
+    config: FromDishka[AuthConfig],
 ):
     check_tg_hash(user, config.bot_token)
     saved = await upsert_user(user.to_dto(), dao.user)
@@ -82,9 +82,9 @@ async def tg_login_result(
 async def tg_login_result_post(
     response: Response,
     user: Annotated[UserTgAuth, Body()],
-    dao: Annotated[HolderDao, Depends()],
-    auth_properties: Annotated[AuthProperties, Depends()],
-    config: Annotated[AuthConfig, Depends()],
+    dao: FromDishka[HolderDao],
+    auth_properties: FromDishka[AuthProperties],
+    config: FromDishka[AuthConfig],
 ):
     check_tg_hash(user, config.bot_token)
     saved = await upsert_user(user.to_dto(), dao.user)
@@ -97,9 +97,9 @@ async def tg_login_result_post(
 async def webapp_login_result_post(
     response: Response,
     web_auth: Annotated[WebAppAuth, Body()],
-    dao: Annotated[HolderDao, Depends()],
-    auth_properties: Annotated[AuthProperties, Depends()],
-    config: Annotated[AuthConfig, Depends()],
+    dao: FromDishka[HolderDao],
+    auth_properties: FromDishka[AuthProperties],
+    config: FromDishka[AuthConfig],
 ):
     parsed = check_webapp_hash(web_auth.init_data, config.bot_token)
     user = dto.User.from_aiogram(typing.cast(User, parsed.user))
@@ -110,7 +110,7 @@ async def webapp_login_result_post(
 
 
 @inject
-async def tg_login_page(config: Annotated[AuthConfig, Depends()]):
+async def tg_login_page(config: FromDishka[AuthConfig]):
     return TG_WIDGET_HTML.format(
         bot_username=config.bot_username,
         auth_url=config.auth_url,

shvatka/api/routes/game.py

@@ -28,15 +28,15 @@
 
 @inject
 async def get_my_games_list(
-    player: Annotated[dto.Player, FromDishka()],
-    dao: Annotated[HolderDao, FromDishka()],
+    player: FromDishka[dto.Player],
+    dao: FromDishka[HolderDao],
 ):
     return responses.Page(await get_authors_games(player, dao.game))
 
 
 @inject
 async def get_active_game(
-    dao: Annotated[HolderDao, FromDishka()],
+    dao: FromDishka[HolderDao],
     response: Response,
 ) -> responses.Game | None:
     game = await get_active(dao.game)
@@ -47,16 +47,16 @@ async def get_active_game(
 
 @inject
 async def get_all_games(
-    dao: Annotated[HolderDao, FromDishka()],
+    dao: FromDishka[HolderDao],
 ) -> responses.Page[responses.Game]:
     games = await get_completed_games(dao.game)
     return responses.Page([responses.Game.from_core(game) for game in games])
 
 
 @inject
 async def get_game_card(
-    dao: Annotated[HolderDao, FromDishka()],
-    player: Annotated[dto.Player, FromDishka()],
+    dao: FromDishka[HolderDao],
+    player: FromDishka[dto.Player],
     id_: Annotated[int, Path(alias="id")],
 ):
     game = await get_full_game(id_, player, dao.game)
@@ -85,8 +85,8 @@ async def get_game_stat(
 
 @inject
 async def get_game_file(
-    user: Annotated[dto.User, FromDishka()],
-    file_reader: Annotated[GameFileReaderInteractor, FromDishka()],
+    user: FromDishka[dto.User],
+    file_reader: FromDishka[GameFileReaderInteractor],
     id_: Annotated[int, Path(alias="id")],
     guid: Annotated[str, Path(alias="guid")],
 ) -> StreamingResponse:
@@ -100,8 +100,8 @@ async def get_game_file(
 
 @inject
 async def get_running_game_hints(
-    user: Annotated[dto.User, FromDishka()],
-    interactor: Annotated[GamePlayReaderInteractor, FromDishka()],
+    user: FromDishka[dto.User],
+    interactor: FromDishka[GamePlayReaderInteractor],
 ) -> responses.CurrentHintResponse:
     return responses.CurrentHintResponse.from_core(await interactor(user))
 

shvatka/api/routes/team.py

@@ -1,6 +1,4 @@
-from typing import Annotated
-
-from dishka.integrations.fastapi import FromDishka as Depends
+from dishka.integrations.fastapi import FromDishka
 from dishka.integrations.fastapi import inject
 from fastapi import APIRouter
 
@@ -9,7 +7,7 @@
 
 
 @inject
-async def get_my_team(team: Annotated[dto.Team, Depends()]) -> responses.Team:
+async def get_my_team(team: FromDishka[dto.Team]) -> responses.Team:
     return responses.Team.from_core(team)
 
 

shvatka/api/routes/user.py

@@ -1,7 +1,6 @@
 import logging
-from typing import Annotated
 
-from dishka.integrations.fastapi import FromDishka as Depends
+from dishka.integrations.fastapi import FromDishka
 from dishka.integrations.fastapi import inject
 from fastapi import APIRouter, HTTPException
 from fastapi.params import Body, Path
@@ -15,23 +14,23 @@
 
 
 @inject
-async def read_users_me(current_user: Annotated[dto.User, Depends()]) -> dto.User:
+async def read_users_me(current_user: FromDishka[dto.User]) -> dto.User:
     return current_user
 
 
 @inject
 async def read_user(
-    dao: Annotated[HolderDao, Depends()],
+    dao: FromDishka[HolderDao],
     id_: int = Path(alias="id"),  # type: ignore[assignment]
 ) -> dto.User:
     return await get_user(id_, dao.user)
 
 
 @inject
 async def set_password_route(
-    auth: Annotated[AuthProperties, Depends()],
-    user: Annotated[dto.User, Depends()],
-    dao: Annotated[HolderDao, Depends()],
+    auth: FromDishka[AuthProperties],
+    user: FromDishka[dto.User],
+    dao: FromDishka[HolderDao],
     password: str = Body(),  # type: ignore[assignment]
 ):
     hashed_password = auth.get_password_hash(password)

shvatka/api/routes/version.py

@@ -1,6 +1,4 @@
-from typing import Annotated
-
-from dishka.integrations.fastapi import FromDishka as Depends
+from dishka.integrations.fastapi import FromDishka
 from dishka.integrations.fastapi import inject
 from fastapi import APIRouter
 
@@ -9,7 +7,7 @@
 
 
 @inject
-def get_version_route(paths: Annotated[Paths, Depends()]):
+def get_version_route(paths: FromDishka[Paths]):
     return get_version(paths)
 
 

shvatka/infrastructure/di/bot.py

@@ -6,6 +6,7 @@
 from dishka import Provider, Scope, provide
 
 from shvatka.tgbot.config.models.bot import BotConfig
+from shvatka.tgbot.views.bot_alert import BotAlert
 from shvatka.tgbot.views.jinja_filters import setup_jinja
 
 
@@ -24,3 +25,7 @@ async def get_bot(self, config: BotConfig) -> AsyncIterable[Bot]:
         ) as bot:
             setup_jinja(bot)
             yield bot
+
+    @provide
+    async def bot_alert(self, bot: Bot, config: BotConfig) -> BotAlert:
+        return BotAlert(bot, config.log_chat)

shvatka/infrastructure/scheduler/wrappers.py

@@ -1,33 +1,29 @@
-from aiogram import Bot
 from dishka.integrations.base import FromDishka
 
-from shvatka.core.interfaces.clients.file_storage import FileStorage
+from shvatka.core.views.game import GameViewPreparer, GameView, GameLogWriter
+from shvatka.core.views.level import LevelView
 from shvatka.infrastructure.db.dao.holder import HolderDao
 from shvatka.infrastructure.scheduler.context import inject
 from shvatka.core.interfaces.scheduler import LevelTestScheduler, Scheduler
 from shvatka.core.models import dto
 from shvatka.core.services.game_play import prepare_game, start_game, send_hint
 from shvatka.core.services.level_testing import send_testing_level_hint
 from shvatka.core.services.organizers import get_by_player
-from shvatka.tgbot.config.models.bot import BotConfig
-from shvatka.tgbot.views.game import GameBotLog, create_bot_game_view
-from shvatka.tgbot.views.level_testing import create_level_test_view
 
 
 @inject
 async def prepare_game_wrapper(
     game_id: int,
     author_id: int,
     dao: FromDishka[HolderDao],
-    bot: FromDishka[Bot],
-    file_storage: FromDishka[FileStorage],
+    view_preparer: FromDishka[GameViewPreparer],
 ) -> None:
     author = await dao.player.get_by_id(author_id)
     game = await dao.game.get_by_id(game_id, author)
     await prepare_game(
         game=game,
         game_preparer=dao.game_preparer,
-        view_preparer=create_bot_game_view(bot, dao, file_storage),
+        view_preparer=view_preparer,
     )
 
 
@@ -36,18 +32,17 @@ async def start_game_wrapper(
     game_id: int,
     author_id: int,
     dao: FromDishka[HolderDao],
-    bot: FromDishka[Bot],
-    file_storage: FromDishka[FileStorage],
     scheduler: FromDishka[Scheduler],
-    config: FromDishka[BotConfig],
+    game_view: FromDishka[GameView],
+    game_log_writer: FromDishka[GameLogWriter],
 ):
     game = await dao.game.get_full(game_id)
     assert author_id == game.author.id
     await start_game(
         game=game,
         dao=dao.game_starter,
-        game_log=GameBotLog(bot=bot, log_chat_id=config.game_log_chat),
-        view=create_bot_game_view(bot, dao, file_storage),
+        game_log=game_log_writer,
+        view=game_view,
         scheduler=scheduler,
     )
 
@@ -58,8 +53,7 @@ async def send_hint_wrapper(
     team_id: int,
     hint_number: int,
     dao: FromDishka[HolderDao],
-    bot: FromDishka[Bot],
-    file_storage: FromDishka[FileStorage],
+    game_view: FromDishka[GameView],
     scheduler: FromDishka[Scheduler],
 ):
     level = await dao.level.get_by_id(level_id)
@@ -70,7 +64,7 @@ async def send_hint_wrapper(
         hint_number=hint_number,
         team=team,
         dao=dao.level_time,
-        view=create_bot_game_view(bot, dao, file_storage),
+        view=game_view,
         scheduler=scheduler,
     )
 
@@ -82,8 +76,7 @@ async def send_hint_for_testing_wrapper(
     player_id: int,
     hint_number: int,
     dao: FromDishka[HolderDao],
-    bot: FromDishka[Bot],
-    file_storage: FromDishka[FileStorage],
+    level_view: FromDishka[LevelView],
     scheduler: FromDishka[LevelTestScheduler],
 ):
     level = await dao.level.get_by_id(level_id)
@@ -94,7 +87,7 @@ async def send_hint_for_testing_wrapper(
     await send_testing_level_hint(
         suite=dto.LevelTestSuite(level=level, tester=org),
         hint_number=hint_number,
-        view=create_level_test_view(bot, dao, file_storage),
+        view=level_view,
         scheduler=scheduler,
         dao=dao.level_testing_complex,
     )

shvatka/tgbot/dialogs/game_publish/handlers.py

@@ -8,14 +8,13 @@
 from aiogram_dialog import DialogManager, BaseDialogManager
 from telegraph.aio import Telegraph
 
-from shvatka.core.interfaces.clients.file_storage import FileStorage
 from shvatka.core.models import dto
 from shvatka.core.services.game import get_full_game
 from shvatka.core.services.game_stat import get_game_stat, get_typed_keys
 from shvatka.core.utils.datetime_utils import tz_utc
 from shvatka.infrastructure.db.dao.holder import HolderDao
 from shvatka.tgbot.config.models.bot import BotConfig
-from shvatka.tgbot.views.hint_sender import create_hint_sender
+from shvatka.tgbot.views.hint_sender import HintSender
 from shvatka.tgbot.views.results.scenario import GamePublisher
 
 
@@ -41,11 +40,10 @@ async def process_publish_message(message: Message, dialog_: Any, manager: Dialo
 
     game_id = manager.start_data["game_id"]
     dao: HolderDao = manager.middleware_data["dao"]
-    storage: FileStorage = manager.middleware_data["file_storage"]
     telegraph: Telegraph = manager.middleware_data["telegraph"]
     author: dto.Player = manager.middleware_data["player"]
     config: BotConfig = manager.middleware_data["config"]
-    hint_sender = create_hint_sender(bot=bot, dao=dao, storage=storage)
+    hint_sender: HintSender = manager.middleware_data["hint_sender"]
     game = await get_full_game(id_=game_id, author=author, dao=dao.game)
     game_stat = await get_game_stat(game=game, player=author, dao=dao.game_stat)
     keys = await get_typed_keys(game=game, player=author, dao=dao.typed_keys)