upd project structure

src/qbot/bot/handlers/menu/entities.py

@@ -0,0 +1,82 @@
+from aiogram import Router, F
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from babel.support import LazyProxy
+from logging import getLogger
+from typing import TYPE_CHECKING
+from ....model.settings import Settings
+from ..context import ContextData, CallbackCommand
+from ....utils.main import get_send_message
+from ....model.descriptors import EntityCaptionCallable
+from ....utils.navigation import save_navigation_context, pop_navigation_context
+
+if TYPE_CHECKING:
+    from ....main import QBotApp
+
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(
+    ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_ENTITIES)
+)
+async def menu_entry_entities(message: CallbackQuery, **kwargs):
+    callback_data: ContextData = kwargs["callback_data"]
+    state: FSMContext = kwargs["state"]
+    state_data = await state.get_data()
+    kwargs["state_data"] = state_data
+
+    stack = save_navigation_context(callback_data=callback_data, state_data=state_data)
+
+    await entities_menu(message=message, navigation_stack=stack, **kwargs)
+
+
+async def entities_menu(
+    message: Message | CallbackQuery,
+    app: "QBotApp",
+    state: FSMContext,
+    navigation_stack: list[ContextData],
+    **kwargs,
+):
+    keyboard_builder = InlineKeyboardBuilder()
+
+    entity_metadata = app.entity_metadata
+
+    for entity in entity_metadata.entity_descriptors.values():
+        if entity.show_in_entities_menu:
+            if entity.full_name_plural.__class__ == EntityCaptionCallable:
+                caption = entity.full_name_plural(entity) or entity.name
+            elif entity.full_name_plural.__class__ == LazyProxy:
+                caption = f"{f'{entity.icon} ' if entity.icon else ''}{entity.full_name_plural.value or entity.name}"
+            else:
+                caption = f"{f'{entity.icon} ' if entity.icon else ''}{entity.full_name_plural or entity.name}"
+
+            keyboard_builder.row(
+                InlineKeyboardButton(
+                    text=caption,
+                    callback_data=ContextData(
+                        command=CallbackCommand.ENTITY_LIST, entity_name=entity.name
+                    ).pack(),
+                )
+            )
+
+    context = pop_navigation_context(navigation_stack)
+    if context:
+        keyboard_builder.row(
+            InlineKeyboardButton(
+                text=(await Settings.get(Settings.APP_STRINGS_BACK_BTN)),
+                callback_data=context.pack(),
+            )
+        )
+
+    state_data = kwargs["state_data"]
+    await state.set_data(state_data)
+
+    send_message = get_send_message(message)
+
+    await send_message(
+        text=(await Settings.get(Settings.APP_STRINGS_REFERENCES)),
+        reply_markup=keyboard_builder.as_markup(),
+    )

src/qbot/bot/handlers/menu/language.py

@@ -0,0 +1,96 @@
+from aiogram import Router, F
+from aiogram.types import (
+    Message,
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+)
+from aiogram.fsm.context import FSMContext
+from aiogram.utils.i18n import I18n
+from logging import getLogger
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from ....utils.navigation import pop_navigation_context, save_navigation_context
+from ....model.language import LanguageBase
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ..context import ContextData, CallbackCommand
+from ..common.routing import route_callback
+from ....utils.main import get_send_message
+
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(
+    ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_LANGUAGE)
+)
+async def menu_entry_language(message: CallbackQuery, **kwargs):
+    callback_data: ContextData = kwargs["callback_data"]
+    state: FSMContext = kwargs["state"]
+    state_data = await state.get_data()
+    kwargs["state_data"] = state_data
+
+    stack = save_navigation_context(callback_data=callback_data, state_data=state_data)
+
+    await language_menu(message, navigation_stack=stack, **kwargs)
+
+
+async def language_menu(
+    message: Message | CallbackQuery,
+    navigation_stack: list[ContextData],
+    user: UserBase,
+    **kwargs,
+):
+    send_message = get_send_message(message)
+
+    inline_keyboard = [
+        [
+            InlineKeyboardButton(
+                text=locale.localized(user.lang.value),
+                callback_data=ContextData(
+                    command=CallbackCommand.SET_LANGUAGE, data=str(locale)
+                ).pack(),
+            )
+        ]
+        for locale in LanguageBase.all_members.values()
+    ]
+
+    context = pop_navigation_context(navigation_stack)
+    if context:
+        inline_keyboard.append(
+            [
+                InlineKeyboardButton(
+                    text=(await Settings.get(Settings.APP_STRINGS_BACK_BTN)),
+                    callback_data=context.pack(),
+                )
+            ]
+        )
+
+    state: FSMContext = kwargs["state"]
+    state_data = kwargs["state_data"]
+    await state.set_data(state_data)
+
+    await send_message(
+        text=(await Settings.get(Settings.APP_STRINGS_LANGUAGE)),
+        reply_markup=InlineKeyboardMarkup(inline_keyboard=inline_keyboard),
+    )
+
+
+@router.callback_query(ContextData.filter(F.command == CallbackCommand.SET_LANGUAGE))
+async def set_language(message: CallbackQuery, **kwargs):
+    user: UserBase = kwargs["user"]
+    callback_data: ContextData = kwargs["callback_data"]
+    db_session: AsyncSession = kwargs["db_session"]
+    state: FSMContext = kwargs["state"]
+
+    state_data = await state.get_data()
+    kwargs["state_data"] = state_data
+
+    user.lang = LanguageBase(callback_data.data)
+    await db_session.commit()
+
+    i18n: I18n = kwargs["i18n"]
+    with i18n.use_locale(user.lang.value):
+        await route_callback(message, **kwargs)

src/qbot/bot/handlers/menu/main.py

@@ -0,0 +1,88 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from logging import getLogger
+from ....model.settings import Settings
+from ..context import ContextData, CallbackCommand
+from ....utils.main import get_send_message
+from ....utils.navigation import save_navigation_context, pop_navigation_context
+
+import qbot.bot.handlers.menu.entities as entities
+import qbot.bot.handlers.menu.settings as settings
+import qbot.bot.handlers.menu.parameters as parameters
+import qbot.bot.handlers.menu.language as language
+import qbot.bot.handlers.editors.main as editor
+import qbot.bot.handlers.editors.main_callbacks as editor_callbacks
+import qbot.bot.handlers.forms.entity_list as entity_list
+import qbot.bot.handlers.forms.entity_form as entity_form
+import qbot.bot.handlers.forms.entity_form_callbacks as entity_form_callbacks
+import qbot.bot.handlers.common.filtering_callbacks as filtering_callbacks
+import qbot.bot.handlers.user_handlers.main as user_handlers_main
+
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_MAIN))
+async def menu_entry_main(message: CallbackQuery, **kwargs):
+    stack = save_navigation_context(
+        callback_data=kwargs["callback_data"], state=kwargs["state"]
+    )
+
+    await main_menu(message, navigation_stack=stack, **kwargs)
+
+
+async def main_menu(
+    message: Message | CallbackQuery, navigation_stack: list[ContextData], **kwargs
+):
+    keyboard_builder = InlineKeyboardBuilder()
+
+    keyboard_builder.row(
+        InlineKeyboardButton(
+            text=(await Settings.get(Settings.APP_STRINGS_REFERENCES_BTN)),
+            callback_data=ContextData(
+                command=CallbackCommand.MENU_ENTRY_ENTITIES
+            ).pack(),
+        )
+    )
+
+    keyboard_builder.row(
+        InlineKeyboardButton(
+            text=(await Settings.get(Settings.APP_STRINGS_SETTINGS_BTN)),
+            callback_data=ContextData(
+                command=CallbackCommand.MENU_ENTRY_SETTINGS
+            ).pack(),
+        )
+    )
+
+    context = pop_navigation_context(navigation_stack)
+    if context:
+        keyboard_builder.row(
+            InlineKeyboardButton(
+                text=(await Settings.get(Settings.APP_STRINGS_BACK_BTN)),
+                callback_data=context.pack(),
+            )
+        )
+
+    send_message = get_send_message(message)
+
+    await send_message(
+        text=(await Settings.get(Settings.APP_STRINGS_MAIN_NENU)),
+        reply_markup=keyboard_builder.as_markup(),
+    )
+
+
+router.include_routers(
+    entities.router,
+    settings.router,
+    parameters.router,
+    language.router,
+    editor.router,
+    editor_callbacks.router,
+    entity_list.router,
+    entity_form.router,
+    entity_form_callbacks.router,
+    filtering_callbacks.router,
+    user_handlers_main.router,
+)

src/qbot/bot/handlers/menu/parameters.py

@@ -0,0 +1,102 @@
+from aiogram import Router, F
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from logging import getLogger
+
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ..context import ContextData, CallbackCommand, CommandContext
+from ....utils.main import (
+    get_send_message,
+    clear_state,
+    get_value_repr,
+    get_callable_str,
+)
+from ....utils.navigation import save_navigation_context, pop_navigation_context
+from ....auth import authorize_command
+
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(
+    ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_PARAMETERS)
+)
+async def menu_entry_parameters(message: CallbackQuery, **kwargs):
+    callback_data: ContextData = kwargs["callback_data"]
+    state: FSMContext = kwargs["state"]
+    state_data = await state.get_data()
+    kwargs["state_data"] = state_data
+
+    clear_state(state_data=state_data)
+    stack = save_navigation_context(callback_data=callback_data, state_data=state_data)
+
+    await parameters_menu(message=message, navigation_stack=stack, **kwargs)
+
+
+async def parameters_menu(
+    message: Message | CallbackQuery,
+    user: UserBase,
+    callback_data: ContextData,
+    navigation_stack: list[ContextData],
+    **kwargs,
+):
+    if not await authorize_command(user=user, callback_data=callback_data):
+        await message.answer(await Settings.get(Settings.APP_STRINGS_FORBIDDEN))
+
+    settings = await Settings.get_params()
+
+    keyboard_builder = InlineKeyboardBuilder()
+    for key, value in settings.items():
+        if not key.is_visible:
+            continue
+
+        if key.caption_value:
+            caption = get_callable_str(
+                callable_str=key.caption_value, descriptor=key, entity=None, value=value
+            )
+        else:
+            if key.caption:
+                caption = get_callable_str(
+                    callable_str=key.caption, descriptor=key, entity=None, value=value
+                )
+            else:
+                caption = key.name
+
+            if key.type_ is bool:
+                caption = f"{'【✔︎】' if value else '【  】'} {caption}"
+            else:
+                caption = f"{caption}: {get_value_repr(value=value, field_descriptor=key, locale=user.lang)}"
+
+        keyboard_builder.row(
+            InlineKeyboardButton(
+                text=caption,
+                callback_data=ContextData(
+                    command=CallbackCommand.FIELD_EDITOR,
+                    context=CommandContext.SETTING_EDIT,
+                    field_name=key.name,
+                ).pack(),
+            )
+        )
+
+    context = pop_navigation_context(navigation_stack)
+    if context:
+        keyboard_builder.row(
+            InlineKeyboardButton(
+                text=(await Settings.get(Settings.APP_STRINGS_BACK_BTN)),
+                callback_data=context.pack(),
+            )
+        )
+
+    state: FSMContext = kwargs["state"]
+    state_data = kwargs["state_data"]
+    await state.set_data(state_data)
+
+    send_message = get_send_message(message)
+
+    await send_message(
+        text=(await Settings.get(Settings.APP_STRINGS_PARAMETERS)),
+        reply_markup=keyboard_builder.as_markup(),
+    )

src/qbot/bot/handlers/menu/settings.py

@@ -0,0 +1,80 @@
+from aiogram import Router, F
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from logging import getLogger
+
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ....utils.main import get_send_message
+from ..context import ContextData, CallbackCommand
+from ....auth import authorize_command
+from ....utils.navigation import save_navigation_context, pop_navigation_context
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(
+    ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_SETTINGS)
+)
+async def menu_entry_settings(message: CallbackQuery, **kwargs):
+    callback_data: ContextData = kwargs["callback_data"]
+    state: FSMContext = kwargs["state"]
+    state_data = await state.get_data()
+    kwargs["state_data"] = state_data
+
+    stack = save_navigation_context(callback_data=callback_data, state_data=state_data)
+
+    await settings_menu(message, navigation_stack=stack, **kwargs)
+
+
+async def settings_menu(
+    message: Message | CallbackQuery,
+    user: UserBase,
+    navigation_stack: list[ContextData],
+    **kwargs,
+):
+    keyboard_builder = InlineKeyboardBuilder()
+
+    if await authorize_command(
+        user=user,
+        callback_data=ContextData(command=CallbackCommand.MENU_ENTRY_PARAMETERS),
+    ):
+        keyboard_builder.row(
+            InlineKeyboardButton(
+                text=(await Settings.get(Settings.APP_STRINGS_PARAMETERS_BTN)),
+                callback_data=ContextData(
+                    command=CallbackCommand.MENU_ENTRY_PARAMETERS
+                ).pack(),
+            )
+        )
+
+    keyboard_builder.row(
+        InlineKeyboardButton(
+            text=(await Settings.get(Settings.APP_STRINGS_LANGUAGE_BTN)),
+            callback_data=ContextData(
+                command=CallbackCommand.MENU_ENTRY_LANGUAGE
+            ).pack(),
+        )
+    )
+
+    context = pop_navigation_context(navigation_stack)
+    if context:
+        keyboard_builder.row(
+            InlineKeyboardButton(
+                text=(await Settings.get(Settings.APP_STRINGS_BACK_BTN)),
+                callback_data=context.pack(),
+            )
+        )
+
+    state: FSMContext = kwargs["state"]
+    state_data = kwargs["state_data"]
+    await state.set_data(state_data)
+
+    send_message = get_send_message(message)
+
+    await send_message(
+        text=(await Settings.get(Settings.APP_STRINGS_SETTINGS)),
+        reply_markup=keyboard_builder.as_markup(),
+    )