arpakitlib 1.8.18__py3-none-any.whl → 1.8.20__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/kb_with_raise_error.py

@@ -0,0 +1,48 @@
+import aiogram.filters
+from aiogram.types import InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.callback.common import BaseCD
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+class _CD(BaseCD, prefix=AdminTgBotCommands.kb_with_raise_error):
+    pass
+
+
+@tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    aiogram.filters.Command(AdminTgBotCommands.kb_with_raise_error)
+)
+@as_tg_command()
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    kb_builder = InlineKeyboardBuilder()
+    kb_builder.row(InlineKeyboardButton(
+        text="Raise fake error",
+        callback_data=_CD().pack()
+    ))
+    await m.answer(
+        text=get_cached_admin_tg_bot_blank().good(),
+        reply_markup=kb_builder.as_markup()
+    )
+
+
+@tg_bot_router.callback_query(_CD.filter())
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    raise Exception("fake error")

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/kb_with_remove_message.py

@@ -0,0 +1,35 @@
+import aiogram.filters
+from aiogram.types import InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.callback.client import RemoveMessageCD
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    aiogram.filters.Command(AdminTgBotCommands.kb_with_remove_message)
+)
+@as_tg_command()
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    kb_builder = InlineKeyboardBuilder()
+    kb_builder.row(InlineKeyboardButton(
+        text="Remove",
+        callback_data=RemoveMessageCD().pack()
+    ))
+    await m.answer(
+        text=get_cached_admin_tg_bot_blank().good(),
+        reply_markup=kb_builder.as_markup()
+    )

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/log_file.py

@@ -0,0 +1,37 @@
+import os
+
+import aiogram
+from aiogram import Router, types
+from aiogram.filters import Command
+from aiogram.types import FSInputFile
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.core.settings import get_cached_settings
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    aiogram.filters.Command(AdminTgBotCommands.log_file),
+)
+@as_tg_command(passwd_validator=get_cached_settings().tg_bot_command_passwd)
+async def _(
+        m: types.Message,
+        **kwargs
+):
+    with open(get_cached_settings().log_filepath, mode="r") as f:
+        if not f.read():
+            await m.answer("log файл пустой")
+            return
+
+    await m.answer_document(
+        document=FSInputFile(
+            path=get_cached_settings().log_filepath,
+            filename=os.path.basename(get_cached_settings().log_filepath)
+        )
+    )

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/router/admin/me.py

@@ -3,12 +3,16 @@ import aiogram.filters
 from arpakitlib.ar_aiogram_util import as_tg_command
 from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
 from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
 from project.tg_bot.middleware.common import MiddlewareDataTgBot
 
 tg_bot_router = aiogram.Router()
 
 
 @tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
     aiogram.filters.Command(AdminTgBotCommands.me)
 )
 @as_tg_command()

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/router/admin/raise_fake_error.py

@@ -3,13 +3,17 @@ import aiogram.filters
 from arpakitlib.ar_aiogram_util import as_tg_command
 from project.core.settings import get_cached_settings
 from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
 from project.tg_bot.middleware.common import MiddlewareDataTgBot
 
 tg_bot_router = aiogram.Router()
 
 
 @tg_bot_router.message(
-    aiogram.filters.Command(AdminTgBotCommands.raise_fake_err)
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    aiogram.filters.Command(AdminTgBotCommands.raise_fake_error)
 )
 @as_tg_command(passwd_validator=get_cached_settings().tg_bot_command_passwd)
 async def _(

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/router/admin/reinit_sqlalchemy_db.py

@@ -7,21 +7,25 @@ from project.core.settings import get_cached_settings
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
 from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
 from project.tg_bot.filter_.not_prod_mode_filter import NotProdModeTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
 from project.tg_bot.middleware.common import MiddlewareDataTgBot
 
 tg_bot_router = Router()
 
 
 @tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    NotProdModeTgBotFilter(),
     Command(AdminTgBotCommands.reinit_sqlalchemy_db),
-    NotProdModeTgBotFilter()
 )
 @as_tg_command(passwd_validator=get_cached_settings().tg_bot_command_passwd)
-async def handler(
+async def _(
         m: aiogram.types.Message,
         middleware_data_tg_bot: MiddlewareDataTgBot,
         **kwargs
 ):
     get_cached_sqlalchemy_db().reinit()
-    await m.answer(text=get_cached_admin_tg_bot_blank().done())
+    await m.answer(text=get_cached_admin_tg_bot_blank().good())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/admin/set_tg_bot_commands.py

@@ -0,0 +1,28 @@
+import aiogram
+from aiogram import Router
+from aiogram.filters import Command
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+from project.tg_bot.util.set_tg_bot_commands import set_all_tg_bot_commands
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.message(
+    IsPrivateChatTgBotFilter(),
+    UserRolesHasAdminTgBotFilter(),
+    aiogram.filters.Command(AdminTgBotCommands.set_all_tg_bot_commands)
+)
+@as_tg_command()
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await set_all_tg_bot_commands()
+    await m.answer(get_cached_admin_tg_bot_blank().good())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/about.py

@@ -0,0 +1,30 @@
+import logging
+
+import aiogram
+from aiogram import Router
+from aiogram.filters import Command, or_f
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.const import ClientTgBotCommands
+from project.tg_bot.filter_.message_text import MessageTextTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = Router()
+_logger = logging.getLogger(__name__)
+
+
+@tg_bot_router.message(
+    or_f(
+        Command(ClientTgBotCommands.about),
+        MessageTextTgBotFilter([
+            ClientTgBotCommands.about,
+            "о проекте"
+        ], ignore_case=True)
+    ),
+)
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_client_tg_bot_blank().about_project())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/error_handler.py

@@ -0,0 +1,91 @@
+import logging
+
+import aiogram
+from aiogram import Router
+from aiogram.exceptions import TelegramBadRequest
+
+from arpakitlib.ar_exception_util import exception_to_traceback_str
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.error()
+async def _(
+        error_event: aiogram.types.ErrorEvent,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    need_logging = True
+    need_create_story_log = True
+
+    if (
+            error_event.update.event_type == "message"
+            and isinstance(error_event.update.event, aiogram.types.Message)
+    ):
+        try:
+            await error_event.update.event.answer(
+                text=get_cached_client_tg_bot_blank().error()
+            )
+        except Exception as exception:
+            _logger.error(exception)
+
+    if (
+            error_event.update.event_type == "callback_query"
+            and isinstance(error_event.update.event, aiogram.types.CallbackQuery)
+    ):
+
+        if isinstance(error_event.exception, TelegramBadRequest) and (
+                error_event.exception.message
+                and "message is not modified".lower().strip() in error_event.exception.message.lower().strip()
+        ):
+            error_linked_with_message_not_modified = True
+        else:
+            error_linked_with_message_not_modified = False
+
+        if error_linked_with_message_not_modified:
+            need_logging = False
+            need_create_story_log = False
+
+        try:
+            await error_event.update.event.answer()
+        except Exception as exception:
+            _logger.error(exception)
+
+        if not error_linked_with_message_not_modified:
+
+            try:
+                await error_event.update.event.message.edit_reply_markup(reply_markup=None)
+            except Exception as exception:
+                _logger.error(exception)
+
+            try:
+                await error_event.update.event.message.answer(
+                    text=get_cached_client_tg_bot_blank().error()
+                )
+            except Exception as exception:
+                _logger.error(exception)
+
+    if need_logging:
+        _logger.exception(error_event.exception)
+
+    if need_create_story_log:
+        if get_cached_sqlalchemy_db() is not None:
+            async with get_cached_sqlalchemy_db().new_async_session() as session:
+                story_log_dbm = StoryLogDBM(
+                    level=StoryLogDBM.Levels.error,
+                    type=StoryLogDBM.Types.error_in_tg_bot,
+                    title=f"{type(error_event.exception)}",
+                    data={
+                        "exception": str(error_event.exception),
+                        "exception_traceback": exception_to_traceback_str(exception=error_event.exception)
+                    }
+                )
+                session.add(story_log_dbm)
+                await session.commit()
+                await session.refresh(story_log_dbm)

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/router/client/healthcheck.py

@@ -7,7 +7,9 @@ from project.tg_bot.middleware.common import MiddlewareDataTgBot
 tg_bot_router = aiogram.Router()
 
 
-@tg_bot_router.message(aiogram.filters.Command(ClientTgBotCommands.healthcheck))
+@tg_bot_router.message(
+    aiogram.filters.Command(ClientTgBotCommands.healthcheck),
+)
 async def _(
         m: aiogram.types.Message,
         middleware_data_tg_bot: MiddlewareDataTgBot,

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/router/client/hello_world.py

@@ -17,7 +17,8 @@ tg_bot_router = aiogram.Router()
     or_f(
         aiogram.filters.Command(ClientTgBotCommands.hello_world),
         MessageTextTgBotFilter(get_cached_client_tg_bot_blank().but_hello_world())
-    )
+    ),
+
 )
 async def _(
         m: aiogram.types.Message,
@@ -34,7 +35,9 @@ async def _(
     )
 
 
-@tg_bot_router.callback_query(HelloWorldClientCD.filter())
+@tg_bot_router.callback_query(
+    HelloWorldClientCD.filter()
+)
 async def _(
         cq: aiogram.types.CallbackQuery,
         middleware_data_tg_bot: MiddlewareDataTgBot,

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/raw_callback_query.py

@@ -0,0 +1,30 @@
+import logging
+
+import aiogram.filters
+from aiogram.exceptions import AiogramError
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.callback_query()
+async def _(
+        cq: aiogram.types.CallbackQuery,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    try:
+        await cq.answer(
+            text=get_cached_client_tg_bot_blank().keyboard_is_old(),
+            show_alert=True
+        )
+    except AiogramError as exception:
+        _logger.error(exception)
+
+    try:
+        await cq.message.edit_reply_markup(reply_markup=None)
+    except AiogramError as e:
+        _logger.error(e)

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/raw_inline_query.py

@@ -0,0 +1,14 @@
+import aiogram.filters
+
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.inline_query()
+async def _(
+        iq: aiogram.types.InlineQuery,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    pass

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/raw_message.py

@@ -0,0 +1,15 @@
+import aiogram.filters
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message()
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_client_tg_bot_blank().raw_message())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/remove_message.py

@@ -0,0 +1,28 @@
+import logging
+
+from aiogram import Router, types
+from aiogram.exceptions import AiogramError
+
+from project.tg_bot.callback.client import RemoveMessageCD
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+tg_bot_router = Router()
+
+
+@tg_bot_router.callback_query(
+    RemoveMessageCD.filter(),
+)
+async def _(
+        cq: types.CallbackQuery,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    try:
+        await cq.message.delete()
+    except AiogramError as exception:
+        _logger.error(exception)
+        try:
+            await cq.answer()
+        except AiogramError as exception:
+            _logger.error(exception)

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/router/client/start.py

@@ -17,13 +17,14 @@ _logger = logging.getLogger(__name__)
     or_f(
         Command(ClientTgBotCommands.start),
         MessageTextTgBotFilter([
+            ClientTgBotCommands.start,
             "начать",
             "старт",
             "привет",
             "запуск",
-            "start",
         ], ignore_case=True)
-    )
+    ),
+
 )
 async def _(
         m: aiogram.types.Message,

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/client/support.py

@@ -0,0 +1,30 @@
+import logging
+
+import aiogram
+from aiogram import Router
+from aiogram.filters import Command, or_f
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.const import ClientTgBotCommands
+from project.tg_bot.filter_.message_text import MessageTextTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = Router()
+_logger = logging.getLogger(__name__)
+
+
+@tg_bot_router.message(
+    or_f(
+        Command(ClientTgBotCommands.support),
+        MessageTextTgBotFilter([
+            ClientTgBotCommands.support,
+            "поддержка"
+        ], ignore_case=True)
+    )
+)
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_client_tg_bot_blank().support_info())

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/router/main_router.py

@@ -0,0 +1,36 @@
+from aiogram import Router
+
+from project.tg_bot.router.admin import reinit_sqlalchemy_db, arpakitlib_project_template_info, raise_fake_error, me, \
+    log_file, clear_log_file, set_tg_bot_commands, init_sqlalchemy_db, drop_sqlalchemy_db, kb_with_remove_message, \
+    kb_with_old_cd, kb_with_raise_error, kb_with_not_modified
+from project.tg_bot.router.client import remove_message, start, about, healthcheck, hello_world, \
+    support, error_handler, raw_callback_query, raw_message, raw_inline_query
+
+main_tg_bot_router = Router()
+
+# admin
+main_tg_bot_router.include_router(router=reinit_sqlalchemy_db.tg_bot_router)
+main_tg_bot_router.include_router(router=arpakitlib_project_template_info.tg_bot_router)
+main_tg_bot_router.include_router(router=raise_fake_error.tg_bot_router)
+main_tg_bot_router.include_router(router=me.tg_bot_router)
+main_tg_bot_router.include_router(router=log_file.tg_bot_router)
+main_tg_bot_router.include_router(router=clear_log_file.tg_bot_router)
+main_tg_bot_router.include_router(router=set_tg_bot_commands.tg_bot_router)
+main_tg_bot_router.include_router(router=init_sqlalchemy_db.tg_bot_router)
+main_tg_bot_router.include_router(router=drop_sqlalchemy_db.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_remove_message.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_old_cd.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_raise_error.tg_bot_router)
+main_tg_bot_router.include_router(router=kb_with_not_modified.tg_bot_router)
+
+# client
+main_tg_bot_router.include_router(router=error_handler.tg_bot_router)
+main_tg_bot_router.include_router(router=remove_message.tg_bot_router)
+main_tg_bot_router.include_router(router=start.tg_bot_router)
+main_tg_bot_router.include_router(router=about.tg_bot_router)
+main_tg_bot_router.include_router(router=healthcheck.tg_bot_router)
+main_tg_bot_router.include_router(router=hello_world.tg_bot_router)
+main_tg_bot_router.include_router(router=support.tg_bot_router)
+main_tg_bot_router.include_router(router=raw_message.tg_bot_router)
+main_tg_bot_router.include_router(router=raw_inline_query.tg_bot_router)
+main_tg_bot_router.include_router(router=raw_callback_query.tg_bot_router)

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/util/notify_admins.py

@@ -0,0 +1,58 @@
+import asyncio
+import logging
+
+import sqlalchemy
+from aiogram.exceptions import AiogramError
+from emoji import emojize
+
+from arpakitlib.ar_str_util import remove_tags_and_html
+from project.core.settings import get_cached_settings
+from project.core.util import setup_logging
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+from project.tg_bot.tg_bot import get_cached_tg_bot
+
+_logger = logging.getLogger(__name__)
+
+
+async def notify_admins(text: str):
+    text = emojize(text.strip())
+
+    admin_tg_ids = set()
+
+    if get_cached_sqlalchemy_db() is not None:
+        async with get_cached_sqlalchemy_db().new_async_session() as async_session:
+            admin_user_dbms: list[UserDBM] = (await async_session.scalars(
+                sqlalchemy.select(UserDBM).filter(UserDBM.roles.any(UserDBM.Roles.admin))
+            )).all()
+        for admin_user_dbm in admin_user_dbms:
+            admin_tg_ids.add(admin_user_dbm.tg_id)
+
+    for tg_id in get_cached_settings().tg_bot_admin_tg_ids:
+        admin_tg_ids.add(tg_id)
+
+    for admin_tg_id in admin_tg_ids:
+        try:
+            await get_cached_tg_bot().send_message(
+                chat_id=admin_tg_id,
+                text=text
+            )
+        except AiogramError as exception:
+            _logger.error(exception)
+            try:
+                await get_cached_tg_bot().send_message(
+                    chat_id=admin_tg_id,
+                    text=remove_tags_and_html(text)
+                )
+            except AiogramError as exception:
+                _logger.error(exception)
+
+
+async def __async_example():
+    setup_logging()
+    await notify_admins("Hello world")
+    await get_cached_tg_bot().session.close()
+
+
+if __name__ == '__main__':
+    asyncio.run(__async_example())

arpakitlib/{_arpakit_project_template_v_4 → _arpakit_project_template_v_5}/project/tg_bot/util/set_tg_bot_commands.py

@@ -4,6 +4,7 @@ import logging
 from aiogram.types import BotCommand, BotCommandScopeChat
 
 from arpakitlib.ar_str_util import return_str_if_none
+from project.core.settings import get_cached_settings
 from project.core.util import setup_logging
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
@@ -29,6 +30,13 @@ def get_client_tg_bot_commands_to_set() -> list[BotCommand]:
                 get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.about),
                 ClientTgBotCommands.about
             )
+        ),
+        BotCommand(
+            command=ClientTgBotCommands.support,
+            description=return_str_if_none(
+                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.support),
+                ClientTgBotCommands.support
+            )
         )
     ]
     return res
@@ -53,18 +61,32 @@ async def set_client_tg_bot_commands():
 async def set_admin_tg_bot_commands():
     _logger.info(f"start")
 
-    with get_cached_sqlalchemy_db().new_session() as session:
-        user_dbms: list[UserDBM] = session.query(UserDBM).filter(UserDBM.roles.any(UserDBM.Roles.admin)).all()
+    user_tg_ids = set()
+    for tg_bot_admin_tg_id in get_cached_settings().tg_bot_admin_tg_ids:
+        user_tg_ids.add(tg_bot_admin_tg_id)
+
+    if get_cached_sqlalchemy_db() is not None:
+        with get_cached_sqlalchemy_db().new_session() as session:
+            user_dbms: list[UserDBM] = session.query(UserDBM).filter(UserDBM.roles.any(UserDBM.Roles.admin)).all()
+            for user_dbm in user_dbms:
+                user_tg_ids.add(user_dbm.tg_id)
 
-    for user_dbm in user_dbms:
+    for user_tg_id in user_tg_ids:
         await get_cached_tg_bot().set_my_commands(
             commands=get_client_tg_bot_commands_to_set() + get_admin_tg_bot_commands_to_set(),
-            scope=BotCommandScopeChat(chat_id=user_dbm.tg_id)
+            scope=BotCommandScopeChat(chat_id=user_tg_id)
         )
 
     _logger.info("finish")
 
 
+async def set_all_tg_bot_commands():
+    _logger.info(f"start")
+    await set_client_tg_bot_commands()
+    await set_admin_tg_bot_commands()
+    _logger.info("finish")
+
+
 async def __async_example():
     setup_logging()
     await set_client_tg_bot_commands()