wip

src/ocab_modules/standard/command_helper/__init__.py

@@ -0,0 +1 @@
+from .main import module_init, module_late_init, register_command

src/ocab_modules/standard/command_helper/info.json

@@ -0,0 +1,12 @@
+{
+    "id": "standard.command_helper",
+    "name": "Command helper",
+    "description": "Модуль для отображения команд при вводе '/'",
+    "author": "OCAB Team",
+    "version": "1.0.0",
+    "privileged": false,
+    "dependencies": {
+        "standard.roles": "^1.0.0",
+        "standard.database": "^1.0.0"
+    }
+}

src/ocab_modules/standard/command_helper/main.py

@@ -0,0 +1,98 @@
+from typing import Any, Awaitable, Callable, Dict
+
+from aiogram import BaseMiddleware
+from aiogram.types import BotCommand, Message, TelegramObject
+
+from ocab_core.modules_system.public_api import (
+    get_module,
+    log,
+    register_outer_message_middleware,
+    set_my_commands,
+)
+
+commands = dict()
+
+
+db_api = get_module(
+    "standard.database",
+    "db_api",
+)
+
+Roles = get_module("standard.roles", "Roles")
+
+
+def register_command(command, description, role="USER"):
+    if role not in commands:
+        commands[role] = dict()
+    commands[role][command] = {
+        "description": description,
+    }
+
+
+class OuterMiddleware(BaseMiddleware):
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: Dict[str, Any],
+    ):
+
+        if not isinstance(event, Message):
+            return await handler(event, data)
+
+        user = db_api.get_user(event.from_user.id)
+
+        if user is None:
+            return
+
+        roles = Roles()
+        role_name = await roles.get_role_name(role_id=user.user_role)
+
+        if role_name not in commands:
+            return await handler(event, data)
+
+        # bot_commands = []
+
+        # for role_command in commands[role_name]:
+        #     bot_commands.append(
+        #         BotCommand(
+        #             command=role_command,
+        #             description=commands[role_name][role_command]["description"],
+        #         )
+        #     )
+
+        # await event.bot.set_my_commands(
+        #     bot_commands,
+        #     BotCommandScopeChatMember(
+        #         chat_id=event.chat.id,
+        #         user_id=event.from_user.id,
+        #     ),
+        # )
+
+        return await handler(event, data)
+
+
+async def module_init():
+    register_outer_message_middleware(OuterMiddleware())
+
+
+async def set_user_commands():
+    bot_commands = []
+    if "USER" in commands:
+        user_commands = commands["USER"]
+        for command in user_commands:
+            bot_commands.append(
+                BotCommand(
+                    command=command,
+                    description=user_commands[command]["description"],
+                )
+            )
+
+    await set_my_commands(
+        bot_commands,
+    )
+
+
+async def module_late_init():
+    await log("module_late_init")
+    await set_user_commands()

src/ocab_modules/standard/create_report_apps/__init__.py

@@ -0,0 +1 @@
+from .main import module_init

src/ocab_modules/standard/create_report_apps/create_report.py

@@ -0,0 +1,64 @@
+from aiogram import Bot, Router
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import BufferedInputFile, Message
+
+from ocab_core.modules_system.public_api import get_fsm_context
+
+router = Router()
+
+
+class ReportState(StatesGroup):
+    input_kernel_info = State()
+    input_app_name = State()
+    input_problem_step_by_step = State()
+
+
+async def start_report(chat_id: int, bot: Bot):
+    await bot.send_message(
+        chat_id=chat_id,
+        text="Какая версия ядра у тебя на "
+        "текущий момент? Можно узнать "
+        "командой `uname -rm`",
+        parse_mode="Markdown",
+    )
+    state = await get_fsm_context(chat_id, chat_id)
+
+    await state.set_state(ReportState.input_kernel_info)
+
+
+@router.message(ReportState.input_kernel_info)
+async def kernel_version_entered(message: Message, state: FSMContext):
+    await state.update_data(kernel=message.text)
+    await message.answer(text="В каком приложении " "возникла проблема?")
+    await state.set_state(ReportState.input_app_name)
+
+
+@router.message(ReportState.input_app_name)
+async def app_name_entered(message: Message, state: FSMContext):
+    await state.update_data(app_name=message.text)
+    await message.answer(
+        text="Опиши проблему пошагово, " "что ты делал, что происходило, что не так"
+    )
+    await state.set_state(ReportState.input_problem_step_by_step)
+
+
+@router.message(ReportState.input_problem_step_by_step)
+async def problem_step_by_step_entered(message: Message, state: FSMContext):
+    await state.update_data(problem_step_by_step=message.text)
+    await message.answer(text="Вот твой отчет сообщением, " "а также файлом:")
+    data = await state.get_data()
+
+    report = f"""Стенд с ошибкой:
+# uname -rm
+{data['kernel']}
+
+Шаги, приводящие к ошибке:
+
+{data['problem_step_by_step']}
+"""
+    await message.answer(text=report)
+    await message.answer_document(
+        document=BufferedInputFile(report.encode(), "report.txt")
+    )
+    await state.clear()

src/ocab_modules/standard/create_report_apps/info.json

@@ -0,0 +1,11 @@
+{
+    "id": "standard.create_report_apps",
+    "name": "Create Report Apps",
+    "description": "Модуль для создания отчетов о ошибках в приложениях",
+    "author": "OCAB Team",
+    "version": "1.0.0",
+    "privileged": false,
+    "dependencies": {
+        "standard.command_helper": "^1.0.0"
+    }
+}

src/ocab_modules/standard/create_report_apps/main.py

@@ -0,0 +1,101 @@
+from typing import Union
+
+from aiogram import Bot, F, Router
+from aiogram.exceptions import TelegramForbiddenError
+from aiogram.filters import BaseFilter, Command, CommandStart
+from aiogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+)
+
+from ocab_core.modules_system.public_api import get_module, register_router
+
+from .create_report import router as create_report_router
+from .create_report import start_report
+
+register_command = get_module("standard.command_helper", "register_command")
+
+router = Router()
+
+
+class ChatTypeFilter(BaseFilter):
+    def __init__(self, chat_type: Union[str, list]):
+        self.chat_type = chat_type
+
+    async def __call__(self, message: Message) -> bool:
+        if isinstance(self.chat_type, str):
+            return message.chat.type == self.chat_type
+        return message.chat.type in self.chat_type
+
+
+@router.message(
+    ChatTypeFilter(chat_type=["group", "supergroup"]), Command("create_report_apps")
+)
+async def create_report_apps_command_group(message: Message):
+    keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(text="Да", callback_data="create_report"),
+                InlineKeyboardButton(text="Нет", callback_data="cancel_report"),
+            ]
+        ]
+    )
+    await message.answer(
+        "Я могу отправить тебе пару вопросов "
+        "для помощи в составлении репорта личными "
+        "сообщениями.",
+        reply_markup=keyboard,
+    )
+
+
+@router.message(
+    ChatTypeFilter(chat_type=["private"]),
+    CommandStart(deep_link=True, magic=F.args == "create_report_apps"),
+)
+@router.message(ChatTypeFilter(chat_type=["private"]), Command("create_report_apps"))
+async def create_report_apps_command(message: Message, bot: Bot):
+    await start_report(message.from_user.id, bot)
+
+
+@router.callback_query(F.data == "cancel_report")
+async def cancel_report_callback(callback_query: CallbackQuery):
+    await callback_query.message.delete()
+
+
+@router.callback_query(F.data == "create_report")
+async def create_report_callback(callback_query: CallbackQuery, bot: Bot):
+    user_id = callback_query.from_user.id
+
+    async def on_chat_unavailable():
+        await callback_query.message.edit_text(
+            "Я в личных сообщениях задам тебе вопросы "
+            "для помощи в составлении репорта. "
+            'Но перед этим ты должен нажать кнопку "Запустить"'
+        )
+        info = await bot.get_me()
+        await callback_query.answer(
+            url=f"https://t.me/{info.username}?start=create_report_apps"
+        )
+
+    try:
+        chat_member = await bot.get_chat_member(chat_id=user_id, user_id=user_id)
+        if chat_member.status != "left":
+            await start_report(user_id, bot)
+            await callback_query.message.edit_text(
+                "Я в личных сообщениях задам тебе "
+                "вопросы для помощи в составлении "
+                "репорта."
+            )
+        else:
+            await on_chat_unavailable()
+    except TelegramForbiddenError:
+        await on_chat_unavailable()
+
+
+async def module_init():
+    router.include_router(create_report_router)
+
+    register_router(router)
+    register_command("create_report_apps", "Написать репорт о приложении")

src/ocab_modules/standard/database/__init__.py

@@ -1,5 +1,5 @@
 from . import db_api, models
 
 
-def module_init():
+async def module_init():
     db_api.connect_database()

src/ocab_modules/standard/info/__init__.py

@@ -1,14 +1,2 @@
-from aiogram import F, Router
-
-from ocab_core.modules_system.public_api import register_router
-
 from .handlers import get_chat_info, get_user_info
-
-
-def module_init():
-    router = Router()
-
-    router.message.register(get_user_info, F.text.startswith("/info"))
-    router.message.register(get_chat_info, F.text.startswith("/chatinfo"))
-
-    register_router(router)
+from .main import module_init

src/ocab_modules/standard/info/info.json

@@ -7,6 +7,7 @@
   "privileged": false,
   "dependencies": {
     "standard.roles": "^1.0.0",
-    "standard.database": "^1.0.0"
+    "standard.database": "^1.0.0",
+    "standard.command_helper": "^1.0.0"
   }
 }

src/ocab_modules/standard/info/main.py

@@ -0,0 +1,20 @@
+from aiogram import Router
+from aiogram.filters import Command
+
+from ocab_core.modules_system.public_api import get_module, register_router
+
+from .handlers import get_chat_info, get_user_info
+
+register_command = get_module("standard.command_helper", "register_command")
+
+
+async def module_init():
+    router = Router()
+
+    router.message.register(get_user_info, Command("info"))
+    router.message.register(get_chat_info, Command("chatinfo"))
+
+    register_router(router)
+
+    register_command("info", "Информация о пользователе")
+    register_command("chatinfo", "Информация о чате")