init

bot/handlers/menu/entities.py

@@ -0,0 +1,67 @@
+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 sqlmodel.ext.asyncio.session import AsyncSession
+
+from ....main import QBotApp
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ..context import ContextData, CallbackCommand
+from ..common import get_send_message
+from ....model.descriptors import EntityCaptionCallable
+
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_ENTITIES))
+async def menu_entry_entities(message: CallbackQuery, **kwargs):
+
+    stack = await save_navigation_context(
+        callback_data = kwargs["callback_data"],
+        state = kwargs["state"])
+
+    await entities_menu(message = message, navigation_stack = stack, **kwargs) 
+
+
+async def entities_menu(message: Message | CallbackQuery,
+                        callback_data: ContextData,
+                        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.caption_btn.__class__ == EntityCaptionCallable:
+            caption = entity.caption_btn(entity) or entity.name
+        elif entity.caption_btn.__class__ == LazyProxy: 
+            caption = f"{f"{entity.icon} " if entity.icon else ""}{entity.caption_btn.value or entity.name}" 
+        else:
+            caption = f"{f"{entity.icon} " if entity.icon else ""}{entity.caption_btn 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()))
+    
+    send_message = get_send_message(message)
+
+    await send_message(text = (await Settings.get(Settings.APP_STRINGS_REFERENCES)), reply_markup = keyboard_builder.as_markup())
+
+
+from ..navigation import save_navigation_context, pop_navigation_context

bot/handlers/menu/language.py

@@ -0,0 +1,62 @@
+from aiogram import Router, F
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from logging import getLogger
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from ....main import QBotApp
+from ....model.language import LanguageBase
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ..context import ContextData, CallbackCommand
+from ..navigation import route_callback
+from .settings import settings_menu
+from ..common 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):
+
+    stack = await save_navigation_context(callback_data = kwargs["callback_data"],
+                                          state = kwargs["state"])
+
+    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),
+                              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())])
+    
+    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, user: UserBase, callback_data: ContextData, db_session: AsyncSession, **kwargs):
+
+    user.lang = callback_data.data
+    await db_session.commit()
+
+    await route_callback(message, callback_data = callback_data, user = user, db_session = db_session, **kwargs)
+
+
+from ..navigation import pop_navigation_context, save_navigation_context

bot/handlers/menu/main.py

@@ -0,0 +1,91 @@
+from aiogram import Router, F
+from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from logging import getLogger
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from ....main import QBotApp
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ..context import ContextData, CallbackCommand
+from ..common import get_send_message
+
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.message(Command("menu"))
+async def command_menu(message: Message, **kwargs):
+
+    await clear_state(state = kwargs["state"], clear_nav = True)
+    callback_data = ContextData(command = CallbackCommand.MENU_ENTRY_MAIN)
+    stack = await save_navigation_context(callback_data = callback_data, state = kwargs["state"])
+    kwargs.update({"navigation_stack": stack, "callback_data": callback_data})
+
+    await main_menu(message, **kwargs)
+        
+
+# @router.callback_query(CallbackData.filter(F.command == CallbackCommand.MENU_ENTRY))
+# async def menu_entry(query: CallbackQuery, callback_data: CallbackData, user: UserBase, db_session: AsyncSession, app: QBotApp):
+
+#     pass
+
+
+@router.callback_query(ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_MAIN))
+async def menu_entry_main(message: CallbackQuery,  **kwargs):
+
+    stack = await 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())
+
+
+from .entities import router as entities_router
+from .settings import router as settings_router
+from .parameters import router as parameters_router
+from .language import router as language_router
+from ..editors import router as editors_router
+from ..forms.entity_list import router as entity_list_router
+from ..forms.entity_form import router as entity_form_router
+
+router.include_routers(
+    entities_router,
+    settings_router,
+    parameters_router,
+    language_router,
+    editors_router,
+    entity_list_router,
+    entity_form_router
+)
+
+from ..navigation import save_navigation_context, pop_navigation_context, clear_state

bot/handlers/menu/parameters.py

@@ -0,0 +1,80 @@
+from aiogram import Router, F
+from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import StatesGroup, State
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
+from aiogram.utils.i18n import I18n
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from logging import getLogger
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from ....main import QBotApp
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ..context import ContextData, CallbackCommand, CommandContext
+from ..common import get_send_message, get_value_repr, get_callable_str, authorize_command
+from ..navigation import save_navigation_context, pop_navigation_context
+
+
+logger = getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(ContextData.filter(F.command == CallbackCommand.MENU_ENTRY_PARAMETERS))
+async def menu_entry_parameters(message: CallbackQuery, **kwargs):
+
+    await clear_state(state = kwargs["state"])
+
+    stack = await save_navigation_context(callback_data = kwargs["callback_data"], state = kwargs["state"])
+
+    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_btn:
+            caption = get_callable_str(callable_str = key.caption_value_btn, descriptor = key, entity = None, value = value)
+        else:
+            if key.caption_btn:
+                caption = get_callable_str(callable_str = key.caption_btn, descriptor = key, entity = None, value = value)
+            else:
+                caption = key.name 
+            
+            if key.type_ == 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()))
+
+    send_message = get_send_message(message)
+
+    await send_message(text = (await Settings.get(Settings.APP_STRINGS_PARAMETERS)), reply_markup = keyboard_builder.as_markup())
+
+
+from ..navigation import pop_navigation_context, get_navigation_context, clear_state

bot/handlers/menu/settings.py

@@ -0,0 +1,58 @@
+from aiogram import Router, F
+from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from logging import getLogger
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from ....main import QBotApp
+from ....model.settings import Settings
+from ....model.user import UserBase
+from ..context import ContextData, CallbackCommand
+from ..common import get_send_message, authorize_command
+from ..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):
+
+    stack = await save_navigation_context(callback_data = kwargs["callback_data"], state = kwargs["state"])
+
+    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()))
+    
+    send_message = get_send_message(message)
+
+    await send_message(text = (await Settings.get(Settings.APP_STRINGS_SETTINGS)), reply_markup = keyboard_builder.as_markup())
+
+
+from ..navigation import pop_navigation_context, get_navigation_context