Добавление возможности менять внешний вид бота

Модуль изменения описания бота
Добавление работы с конфликтными частями и исправление вайтлиста
2026-02-25 17:50:37 +07:00 · 2026-02-25 17:50:23 +07:00 · 2026-02-25 17:50:11 +07:00 · 2026-02-25 17:49:28 +07:00 · 2026-02-25 17:49:15 +07:00 · 2026-02-25 17:48:50 +07:00
23 changed files with 772 additions and 375 deletions
--- a/bot/core/bots.py
+++ b/bot/core/bots.py
@@ -65,7 +65,7 @@ class BotInfo:
    last_name: str = None
    username: str = None
    description: str = None
-    short_description: str = None
+    widget: str = None
    is_premium: bool = False

    # Возможности бота
@@ -159,11 +159,15 @@ class BotInfo:
        logger.info("Получение информации о боте", log_type='BOT')

        bot_info: User = await bots.get_me()
+        description_obj: BotDescription = await bots.get_my_description()
+        short_obj: BotShortDescription = await bots.get_my_short_description()

        cls.id = bot_info.id
        cls.url = f'tg://user?id={cls.id}'
        cls.first_name = bot_info.first_name
        cls.last_name = bot_info.last_name
+        cls.description = description_obj.description if description_obj else None
+        cls.widget = short_obj.short_description if short_obj else None
        cls.username = bot_info.username
        cls.can_join_groups = getattr(bot_info, 'can_join_groups', False)
        cls.can_read_all_group_messages = getattr(bot_info, 'can_read_all_group_messages', False)
@@ -183,6 +187,8 @@ class BotInfo:
            'username': cls.username,
            'prefix': cls.prefix,
            'is_premium': cls.is_premium,
+            'description': cls.description,
+            'short_description': cls.widget,
            'can_join_groups': cls.can_join_groups,
            'can_read_all_group_messages': cls.can_read_all_group_messages,
            'supports_inline_queries': cls.supports_inline_queries,
@@ -310,6 +316,8 @@ class BotInfo:
            f"║    • Имя: {cls.first_name} {cls.last_name or ''}".ljust(60) + "║",
            f"║    • Username: @{cls.username}".ljust(60) + "║",
            f"║    • ID: {cls.id}".ljust(60) + "║",
+            f"║    • Description: {cls.description}".ljust(60) + "║",
+            f"║    • Widget: {cls.widget}".ljust(60) + "║",
            f"║",
            f"║  ⚙️  ВОЗМОЖНОСТИ БОТА:",
            f"║    • Вступать в группы: {'✅' if cls.can_join_groups else '❌'}".ljust(60) + "║",
@@ -371,6 +379,7 @@ class BotInfo:
            setup_webhook: Устанавливать ли webhook (по умолчанию True)
        """
        perm = perm if perm is not None else settings.BOT_EDIT
+        await BotInfo.info()

        logger.info("🚀 Процесс запуска бота!", log_type='START')

--- a/bot/filters/callback.py
+++ b/bot/filters/callback.py
@@ -23,7 +23,7 @@ class CallbackStartsWith(BaseFilter):
    Проверяет, начинается ли callback_data с указанного префикса.

    Attributes:
-        prefix: Префикс для проверки (строка или список строк)
+        № prefix: Префикс для проверки (строка или список строк)
        ignore_case: Игнорировать регистр

    Example:
@@ -172,7 +172,7 @@ class CallbackMatches(BaseFilter):
    Example:
        ```python
        # Паттерн: user_123, user_456 и т.д.
-        @router.callback_query(CallbackMatches(r"^user_(\d+)$"))
+        @router.callback_query(CallbackMatches(r'^user_(\\d+)$'))
        async def user_handler(callback: CallbackQuery, matched: dict):
            user_id = matched['groups']
            await callback.answer(f"Пользователь {user_id}")
--- a/bot/handlers/commands/settings/set_avatar.py
+++ b/bot/handlers/commands/settings/set_avatar.py
@@ -0,0 +1,223 @@
+"""
+Модуль смены аватарки бота.
+Совместим с aiogram 3.22.0 и Bot API 9.4+
+
+Использует:
+- SetMyProfilePhoto
+- InputProfilePhotoStatic
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Union
+
+from aiogram import Router, Bot, 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,
+    FSInputFile,
+    InputProfilePhotoStatic,
+)
+from aiogram.methods.set_my_profile_photo import SetMyProfilePhoto
+from aiogram.exceptions import TelegramAPIError, TelegramRetryAfter
+from aiogram.utils.i18n import gettext as _
+
+from bot.filters import IsSuperAdmin
+from bot.templates import msg
+from bot.utils import format_retry_time, status_clear
+from bot.core.bots import BotInfo
+from bot.handlers.commands.settings.settings_cmd import settings_keyboard
+from configs import COMMANDS
+from middleware.loggers import logger
+
+__all__ = ("router",)
+
+CMD: str = "set_avatar".lower()
+router: Router = Router(name=f"{CMD}_router")
+
+
+# ================= FSM =================
+
+class SetBotAvatarForm(StatesGroup):
+    """
+    FSM состояния для смены аватарки.
+    """
+    waiting_for_photo: State = State()
+
+
+# ================= CORE =================
+
+async def handle_set_avatar(
+        update: Union[Message, CallbackQuery],
+        state: FSMContext,
+        bot: Bot
+) -> None:
+    """
+    Устанавливает новую аватарку бота.
+
+    Args:
+        update: Message или CallbackQuery
+        state: FSM контекст
+        bot: Экземпляр бота
+    """
+
+    message: Message = update.message if isinstance(update, CallbackQuery) else update
+
+    if not message.photo:
+        return
+
+    largest_photo = message.photo[-1]
+
+    # Получаем файл от Telegram
+    tg_file = await bot.get_file(largest_photo.file_id)
+
+    temp_path: str = f"/tmp/{largest_photo.file_unique_id}.jpg"
+
+    await bot.download_file(tg_file.file_path, destination=temp_path)
+
+    try:
+        method = SetMyProfilePhoto(
+            photo=InputProfilePhotoStatic(
+                photo=FSInputFile(temp_path)
+            )
+        )
+
+        result: bool = await bot(method)
+
+        if result:
+            logger.info("Аватарка бота успешно обновлена", log_type="BOT_SETUP")
+
+        await state.clear()
+
+        await msg(
+            update=update,
+            text=_("✅ Аватарка бота успешно обновлена."),
+            markup=settings_keyboard(),
+            state=state
+        )
+
+    except TelegramRetryAfter as e:
+        retry_text: str = format_retry_time(e.retry_after)
+
+        logger.warning(
+            f"Rate limit при смене аватарки. Повтор через {retry_text}",
+            log_type="BOT_SETUP"
+        )
+
+        await msg(
+            update=update,
+            text=_(
+                "⚠️ Слишком частая смена аватарки.\n"
+                "Попробуйте снова через: <b>{retry}</b>"
+            ).format(retry=retry_text),
+            markup=settings_keyboard(),
+            state=state
+        )
+
+    except TelegramAPIError as e:
+        logger.error(
+            f"Ошибка Telegram API при смене аватарки: {e}",
+            log_type="BOT_SETUP"
+        )
+
+        await msg(
+            update=update,
+            text=_(
+                "❌ Ошибка Telegram API:\n"
+                "<pre>{error}</pre>"
+            ).format(error=str(e)),
+            markup=settings_keyboard(),
+            state=state
+        )
+
+    except Exception as e:
+        logger.error(
+            f"Непредвиденная ошибка при смене аватарки: {e}",
+            log_type="BOT_SETUP"
+        )
+
+        await msg(
+            update=update,
+            text=_(
+                "❌ Непредвиденная ошибка:\n"
+                "<pre>{error}</pre>"
+            ).format(error=str(e)),
+            markup=settings_keyboard(),
+            state=state
+        )
+
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+
+# ================= COMMAND =================
+
+@router.callback_query(F.data.lower() == CMD, IsSuperAdmin())
+@router.message(
+    Command(*COMMANDS.get(CMD, [CMD]), prefix=BotInfo.prefix, ignore_case=True),
+    IsSuperAdmin()
+)
+async def set_avatar_cmd(
+        message: Message | CallbackQuery,
+        state: FSMContext,
+        bot: Bot
+) -> None:
+    """
+    Команда /set_avatar
+
+    Поддерживает:
+    - Фото вместе с командой
+    - Ответ на фото
+    - FSM режим
+    """
+
+    await status_clear(update=message, state=state)
+
+    msg_obj: Message = message.message if isinstance(message, CallbackQuery) else message
+
+    if msg_obj.photo:
+        await handle_set_avatar(message, state, bot)
+        return
+
+    if msg_obj.reply_to_message and msg_obj.reply_to_message.photo:
+        await handle_set_avatar(msg_obj.reply_to_message, state, bot)
+        return
+
+    await msg(
+        update=message,
+        text=_(
+            "🖼 <b>Смена аватарки бота</b>\n\n"
+            "Отправьте фотографию."
+        ),
+        markup=settings_keyboard(),
+        state=state
+    )
+
+    await state.set_state(SetBotAvatarForm.waiting_for_photo)
+
+
+# ================= FSM =================
+
+@router.message(SetBotAvatarForm.waiting_for_photo, IsSuperAdmin(), F.photo)
+async def process_avatar_photo(
+        message: Message,
+        state: FSMContext,
+        bot: Bot
+) -> None:
+    """
+    Обработка фото через FSM.
+    """
+    await handle_set_avatar(message, state, bot)
+
+
+@router.message(SetBotAvatarForm.waiting_for_photo, IsSuperAdmin())
+async def invalid_input(message: Message) -> None:
+    """
+    Обработка некорректного ввода.
+    """
+    await message.answer(_("❌ Пожалуйста, отправьте фотографию."))
--- a/bot/handlers/commands/settings/set_description_cmd.py
+++ b/bot/handlers/commands/settings/set_description_cmd.py
@@ -6,8 +6,8 @@ from aiogram.fsm.state import StatesGroup, State
 from aiogram.types import Message, CallbackQuery
 from aiogram.utils.i18n import gettext as _

+from bot.filters import IsSuperAdmin
 from bot.core.bots import BotInfo
-from bot.filters import IsOwner
 from bot.handlers.commands.settings.settings_cmd import settings_keyboard
 from bot.templates import msg
 from bot.utils import format_retry_time, status_clear
@@ -60,7 +60,7 @@ async def handle_set_bot_description(
        await bot.set_my_short_description(short_description=description)

        # Сохраняем текущее значение в BotInfo
-        BotInfo.short_description = description
+        BotInfo.widget = description

        # Сбрасываем состояние FSM
        await state.clear()
@@ -108,9 +108,9 @@ async def handle_set_bot_description(
        )


-@router.callback_query(F.data.lower() == CMD, IsOwner())
-@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsOwner())
-async def settings_cmd(
+@router.callback_query(F.data.lower() == CMD, IsSuperAdmin())
+@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsSuperAdmin())
+async def set_description_cmd(
        message: Message | CallbackQuery,
        state: FSMContext,
        bot: Bot,
@@ -155,7 +155,7 @@ async def settings_cmd(
    await state.set_state(SetBotDescriptionForm.new_description)


-@router.message(SetBotDescriptionForm.new_description, IsOwner())
+@router.message(SetBotDescriptionForm.new_description, IsSuperAdmin())
 async def process_new_bot_description(
        message: Message,
        state: FSMContext,
@@ -171,3 +171,4 @@ async def process_new_bot_description(
        return

    await handle_set_bot_description(description, message, state, bot)
+    BotInfo.description = description
--- a/bot/handlers/commands/settings/set_name_cmd.py
+++ b/bot/handlers/commands/settings/set_name_cmd.py
@@ -6,8 +6,8 @@ from aiogram.fsm.state import StatesGroup, State
 from aiogram.types import Message, CallbackQuery
 from aiogram.utils.i18n import gettext as _

+from bot.filters import IsSuperAdmin
 from bot.core.bots import BotInfo
-from bot.filters import IsOwner
 from bot.handlers.commands.settings.settings_cmd import settings_keyboard
 from bot.templates import msg
 from configs import COMMANDS
@@ -98,9 +98,9 @@ async def handle_set_name(
        )


-@router.callback_query(F.data.lower() == CMD, IsOwner())
-@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsOwner())
-async def settings_cmd(
+@router.callback_query(F.data.lower() == CMD, IsSuperAdmin())
+@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsSuperAdmin())
+async def set_name_cmd(
        message: Message | CallbackQuery,
        state: FSMContext,
        bot: Bot,
@@ -143,7 +143,7 @@ async def settings_cmd(
    await state.set_state(SetNameForm.new_name)


-@router.message(SetNameForm.new_name, IsOwner())
+@router.message(SetNameForm.new_name, IsSuperAdmin())
 async def process_new_name(message: Message, state: FSMContext, bot: Bot):
    """
    Обработка ввода нового имени через FSM
@@ -155,3 +155,4 @@ async def process_new_name(message: Message, state: FSMContext, bot: Bot):
        return

    await handle_set_name(new_name, message, state, bot)
+    BotInfo.first_name = new_name
--- a/bot/handlers/commands/settings/set_widget_cmd.py
+++ b/bot/handlers/commands/settings/set_widget_cmd.py
@@ -7,7 +7,7 @@ from aiogram.types import Message, CallbackQuery
 from aiogram.utils.i18n import gettext as _

 from bot.core.bots import BotInfo
-from bot.filters import IsOwner
+from bot.filters import IsSuperAdmin
 from bot.handlers.commands.settings.settings_cmd import settings_keyboard
 from bot.templates import msg
 from bot.utils import format_retry_time, status_clear
@@ -107,9 +107,9 @@ async def handle_set_widget(
        )


-@router.callback_query(F.data.lower() == CMD, IsOwner())
-@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsOwner())
-async def settings_cmd(
+@router.callback_query(F.data.lower() == CMD, IsSuperAdmin())
+@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsSuperAdmin())
+async def set_widget_cmd(
        message: Message | CallbackQuery,
        state: FSMContext,
        bot: Bot,
@@ -124,7 +124,7 @@ async def settings_cmd(
        3. FSM ввод.
    """
    # Получаем текущее значение виджета
-    current_widget: str = BotInfo.short_description
+    current_widget: str = BotInfo.widget

    # Вариант 1: пользователь ввёл аргумент сразу (/set_widget TEXT)
    if command and command.args:
@@ -155,7 +155,7 @@ async def settings_cmd(
    await state.set_state(SetWidgetForm.new_widget)


-@router.message(SetWidgetForm.new_widget, IsOwner())
+@router.message(SetWidgetForm.new_widget, IsSuperAdmin())
 async def process_new_widget(
        message: Message,
        state: FSMContext,
@@ -172,3 +172,4 @@ async def process_new_widget(
        return

    await handle_set_widget(new_widget, message, state, bot)
+    BotInfo.widget = new_widget
--- a/bot/handlers/commands/settings/settings_cmd.py
+++ b/bot/handlers/commands/settings/settings_cmd.py
@@ -6,7 +6,7 @@ from aiogram.utils.i18n import gettext as _
 from aiogram.utils.keyboard import InlineKeyboardBuilder

 from bot.core.bots import BotInfo
-from bot.filters import IsOwner
+from bot.filters import IsSuperAdmin
 from bot.templates import msg
 from bot.utils import status_clear
 from configs import COMMANDS
@@ -20,12 +20,12 @@ router: Router = Router(name=f"{CMD}_cmd_router")
 def settings_keyboard() -> InlineKeyboardBuilder:
    """Клавиатура настроек"""
    ikb: InlineKeyboardBuilder = InlineKeyboardBuilder()
-    ikb.row(InlineKeyboardButton(text="🔙 Вернуться", callback_data="settings"))
+    ikb.row(InlineKeyboardButton(text="🔙 Вернуться", callback_data=CMD))
    return ikb


-@router.callback_query(F.data.lower() == CMD, IsOwner())
-@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsOwner())
+@router.callback_query(F.data.lower() == CMD, IsSuperAdmin())
+@router.message(Command(*COMMANDS[CMD], prefix=BotInfo.prefix, ignore_case=True), IsSuperAdmin())
 async def settings_cmd(message: Message | CallbackQuery, state: FSMContext) -> None:
    """Обработчик команды /settings"""
    await status_clear(update=message, state=state)
@@ -35,7 +35,9 @@ async def settings_cmd(message: Message | CallbackQuery, state: FSMContext) -> N
    ikb.row(InlineKeyboardButton(text="Имя бота⚜️", callback_data='set_name'))
    ikb.row(InlineKeyboardButton(text="Описание бота📝", callback_data='set_description'))
    ikb.row(InlineKeyboardButton(text="Виджет🧩", callback_data='set_widget'))
-    ikb.row(InlineKeyboardButton(text="Назад◀️", callback_data='menu'))
+    ikb.row(InlineKeyboardButton(text="Аватарка🖼", callback_data='set_avatar'))
+    ikb.row(InlineKeyboardButton(text="Назад◀️", callback_data='settings'))
+    ikb.adjust(2)

    # Формируем приветственное сообщение
    text: str = _("""
@@ -46,3 +48,19 @@ async def settings_cmd(message: Message | CallbackQuery, state: FSMContext) -> N

    # Отправляем сообщение
    await msg(update=message, text=text, markup=ikb, state=state)
+
+@router.callback_query(F.data.lower() == "set_avatar", IsSuperAdmin())
+async def avatar_zaglushka(
+        callback: CallbackQuery,
+        state: FSMContext
+) -> None:
+    """
+    Аватары нельзя менять в aiogram хнык
+    """
+
+    await status_clear(update=callback, state=state)
+
+    await callback.answer(
+        text="Ну бля, я не виноват что тг говно и не даст поменять",
+        show_alert=True
+    )
--- a/bot/handlers/commands/users/bot_settings.py
+++ b/bot/handlers/commands/users/bot_settings.py
@@ -11,7 +11,6 @@ from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
 from aiogram.exceptions import TelegramBadRequest

-from middleware.loggers import logger
 from bot.filters.admin import IsAdmin
 from database import get_manager

@@ -48,6 +47,7 @@ def create_settings_menu() -> InlineKeyboardBuilder:
    ikb.button(text="📊 Чат репортов", callback_data="settings:report_chat")
    ikb.button(text="🧵 Топик репортов", callback_data="settings:report_thread")
    ikb.button(text="🔄 Обновить", callback_data="settings:refresh")
+    ikb.button(text="⚙️ Настройка бота", callback_data="botsettings")
    ikb.button(text="❌ Закрыть", callback_data="settings:close")
    ikb.adjust(2)
    return ikb
@@ -62,6 +62,7 @@ def cancel_keyboard():
 # MAIN HANDLER
 # ======================================================================

+@router.callback_query(F.data.lower() == "settings", IsAdmin())
@router.message(Command("settings"), IsAdmin())
 async def settings_cmd(message: Message, state: FSMContext) -> None:
    """Главная команда /settings"""
--- a/bot/handlers/commands/users/conflict.py
+++ b/bot/handlers/commands/users/conflict.py
@@ -99,7 +99,7 @@ async def add_conflict_word_cmd(message: Message) -> None:
    try:
        added = await manager.add_banword(
            word=word,
-            word_type=BanWordType.CONFLICT_SUBSTRING,
+            word_type=BanWordType.CONFLICT_WORD,
            added_by=message.from_user.id,
            reason="Конфликтное слово"
        )
@@ -192,7 +192,7 @@ async def remove_conflict_word_cmd(message: Message) -> None:
    try:
        removed = await manager.remove_banword(
            word=word,
-            word_type=BanWordType.CONFLICT_SUBSTRING
+            word_type=BanWordType.CONFLICT_WORD
        )

        if removed:
@@ -433,3 +433,113 @@ async def conflict_status_cmd(message: Message) -> None:
    except Exception as e:
        logger.error(f"Ошибка получения статуса режима: {e}", log_type="CONFLICT")
        await message.answer("❌ <b>Ошибка получения статуса</b>", parse_mode="HTML")
+
+
+@router.message(
+    Command(*COMMANDS.get("addconflictpart", ["addconflictpart"]),
+            prefix=settings.PREFIX,
+            ignore_case=True),
+    IsAdmin()
+)
+@log_action(action_name="ADD_CONFLICT_PART", log_args=True)
+async def add_conflict_part_cmd(message: Message) -> None:
+    """
+    Добавляет конфликтную часть.
+
+    Использование: /addconflictpart <комбинация>
+    """
+    success, result = parse_conflict_args(
+        message.text,
+        "addconflictpart",
+        need_minutes=False
+    )
+
+    if not success:
+        await message.answer(result, parse_mode="HTML")
+        return
+
+    word = result[0].lower().strip()
+    manager = get_manager()
+
+    try:
+        added = await manager.add_banword(
+            word=word,
+            word_type=BanWordType.CONFLICT_PART,
+            added_by=message.from_user.id,
+            reason="Конфликтная часть"
+        )
+
+        if added:
+            text = (
+                f"✅ <b>Конфликтная часть добавлена</b>\n\n"
+                f"🧩 Часть: <code>{word}</code>\n"
+                f"🔍 Тип: поиск без пробелов\n\n"
+                f"⚔️ <i>Работает только в режиме антиконфликта</i>\n"
+                f"Активируйте: <code>/stopconflict [минуты]</code>"
+            )
+        else:
+            text = f"⚠️ Конфликтная часть <code>{word}</code> уже существует"
+
+        await message.answer(text, parse_mode="HTML")
+
+    except Exception as e:
+        logger.error(
+            f"Ошибка добавления конфликтной части: {e}",
+            log_type="CONFLICT"
+        )
+        await message.answer(
+            "❌ <b>Ошибка добавления</b>\n\nПопробуйте позже",
+            parse_mode="HTML"
+        )
+
+@router.message(
+    Command(*COMMANDS.get("remconflictpart", ["remconflictpart"]),
+            prefix=settings.PREFIX,
+            ignore_case=True),
+    IsAdmin()
+)
+@log_action(action_name="REMOVE_CONFLICT_PART", log_args=True)
+async def remove_conflict_part_cmd(message: Message) -> None:
+    """
+    Удаляет конфликтную часть.
+
+    Использование: /remconflictpart <комбинация>
+    """
+    success, result = parse_conflict_args(
+        message.text,
+        "remconflictpart",
+        need_minutes=False
+    )
+
+    if not success:
+        await message.answer(result, parse_mode="HTML")
+        return
+
+    word = result[0].lower().strip()
+    manager = get_manager()
+
+    try:
+        removed = await manager.remove_banword(
+            word=word,
+            word_type=BanWordType.CONFLICT_PART
+        )
+
+        if removed:
+            text = (
+                f"🗑 <b>Конфликтная часть удалена</b>\n\n"
+                f"🧩 Часть: <code>{word}</code>"
+            )
+        else:
+            text = f"⚠️ Конфликтная часть <code>{word}</code> не найдена"
+
+        await message.answer(text, parse_mode="HTML")
+
+    except Exception as e:
+        logger.error(
+            f"Ошибка удаления конфликтной части: {e}",
+            log_type="CONFLICT"
+        )
+        await message.answer(
+            "❌ <b>Ошибка удаления</b>\n\nПопробуйте позже",
+            parse_mode="HTML"
+        )
--- a/bot/handlers/commands/users/listwords.py
+++ b/bot/handlers/commands/users/listwords.py
@@ -7,7 +7,6 @@ from aiogram.types import Message, CallbackQuery
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 from aiogram.exceptions import TelegramBadRequest

-from bot.filters.admin import IsAdmin
 from configs import settings, COMMANDS
 from database import get_manager
 from middleware.loggers import logger
@@ -27,7 +26,7 @@ def get_refresh_kb(page: int = 0):
    return ikb.as_markup()


-async def format_banwords_list(page: int = 0) -> str:
+async def format_banwords_list() -> str:
    """
    Форматирует список всех банвордов с разбивкой по типам.

@@ -46,13 +45,14 @@ async def format_banwords_list(page: int = 0) -> str:
        stats = await manager.get_stats()

        # Извлекаем данные из словаря
-        permanent_words = list(data.get('substring', set()))
+        permanent_words = list(data.get('word', set()))
        permanent_lemmas = list(data.get('lemma', set()))
        permanent_parts = list(data.get('part', set()))
-        temp_words = list(data.get('temp_substring', set()))
+        temp_words = list(data.get('temp_word', set()))
        temp_lemmas = list(data.get('temp_lemma', set()))
-        conflict_words = list(data.get('conflict_substring', set()))
+        conflict_words = list(data.get('conflict_word', set()))
        conflict_lemmas = list(data.get('conflict_lemma', set()))
+        conflict_parts = list(data.get('conflict_part', set()))
        exceptions = list(data.get('whitelist', set()))

    except Exception as e:
@@ -67,7 +67,7 @@ async def format_banwords_list(page: int = 0) -> str:
    total_count = (
        len(permanent_words) + len(permanent_lemmas) + len(permanent_parts) +
        len(temp_words) + len(temp_lemmas) +
-        len(conflict_words) + len(conflict_lemmas)
+        len(conflict_words) + len(conflict_lemmas) + len(conflict_parts)
    )

    output += f"📊 <b>Общая статистика:</b>\n"
@@ -81,21 +81,21 @@ async def format_banwords_list(page: int = 0) -> str:
        output += "🔴 <b>ПОСТОЯННЫЕ ПРАВИЛА:</b>\n\n"

        if permanent_words:
-            output += f"📝 <b>Подстроки</b> ({len(permanent_words)}):\n"
+            output += f"📝 <b>Слова</b> ({len(permanent_words)}):\n"
            words_str = ', '.join([f"<code>{w}</code>" for w in sorted(permanent_words)[:20]])
            if len(permanent_words) > 20:
                words_str += f" ... <i>(+{len(permanent_words) - 20} ещё)</i>"
            output += f"{words_str}\n\n"

        if permanent_lemmas:
-            output += f"🔤 <b>Леммы</b> ({len(permanent_lemmas)}):\n"
+            output += f"🔤 <b>Леммы (морф.формы)</b> ({len(permanent_lemmas)}):\n"
            lemmas_str = ', '.join([f"<code>{w}</code>" for w in sorted(permanent_lemmas)[:20]])
            if len(permanent_lemmas) > 20:
                lemmas_str += f" ... <i>(+{len(permanent_lemmas) - 20} ещё)</i>"
            output += f"{lemmas_str}\n\n"

        if permanent_parts:
-            output += f"🧩 <b>Части</b> ({len(permanent_parts)}):\n"
+            output += f"🧩 <b>Части в сообщении</b> ({len(permanent_parts)}):\n"
            parts_str = ', '.join([f"<code>{w}</code>" for w in sorted(permanent_parts)[:20]])
            if len(permanent_parts) > 20:
                parts_str += f" ... <i>(+{len(permanent_parts) - 20} ещё)</i>"
@@ -106,7 +106,7 @@ async def format_banwords_list(page: int = 0) -> str:
        output += "⏱ <b>ВРЕМЕННЫЕ ПРАВИЛА:</b>\n\n"

        if temp_words:
-            output += f"📝 <b>Временные подстроки</b> ({len(temp_words)}):\n"
+            output += f"📝 <b>Временные слова</b> ({len(temp_words)}):\n"
            # Для временных слов нужна дополнительная информация о времени истечения
            # Пока просто выводим список
            words_str = ', '.join([f"<code>{w}</code>" for w in sorted(temp_words)[:15]])
@@ -122,7 +122,7 @@ async def format_banwords_list(page: int = 0) -> str:
            output += f"{lemmas_str}\n\n"

    # === КОНФЛИКТНЫЕ ПРАВИЛА ===
-    if conflict_words or conflict_lemmas:
+    if conflict_words or conflict_lemmas or conflict_parts:
        output += "⚔️ <b>КОНФЛИКТНЫЕ ПРАВИЛА:</b>\n"
        output += "<i>(работают только в режиме <code>/stopconflict</code> <code>время</code>)</i>\n\n"

@@ -140,10 +140,17 @@ async def format_banwords_list(page: int = 0) -> str:
                lemmas_str += f" ... <i>(+{len(conflict_lemmas) - 15} ещё)</i>"
            output += f"{lemmas_str}\n\n"

+        if conflict_parts:
+            output += f"🧩 <b>Конфликтные части</b> ({len(conflict_parts)}):\n"
+            parts_str = ', '.join([f"<code>{w}</code>" for w in sorted(conflict_parts)[:15]])
+            if len(conflict_parts) > 15:
+                parts_str += f" ... <i>(+{len(conflict_parts) - 15} ещё)</i>"
+            output += f"{parts_str}\n\n"
+
    # === ИСКЛЮЧЕНИЯ (WHITELIST) ===
    if exceptions:
        output += f"✅ <b>ИСКЛЮЧЕНИЯ</b> ({len(exceptions)}):\n"
-        exc_str = ', '.join([f"<code>{exceptions}</code>" for w in sorted(exceptions)[:15]])
+        exc_str = ', '.join([f"<code>{w}</code>" for w in sorted(exceptions)[:15]])
        if len(exceptions) > 15:
            exc_str += f" ... <i>(+{len(exceptions) - 15} ещё)</i>"
        output += f"{exc_str}\n\n"
@@ -183,7 +190,7 @@ async def format_banwords_list(page: int = 0) -> str:


@router.callback_query(F.data.startswith("listwords:refresh"))
-@router.message(Command(*COMMANDS[CMD], prefix=settings.PREFIX, ignore_case=True), IsAdmin())
+@router.message(Command(*COMMANDS[CMD], prefix=settings.PREFIX, ignore_case=True))
@log_action(action_name="LISTWORDS_COMMAND")
 async def listwords_cmd(update: Message | CallbackQuery) -> None:
    """
@@ -209,7 +216,7 @@ async def listwords_cmd(update: Message | CallbackQuery) -> None:

    # Формируем список
    try:
-        text = await format_banwords_list(page)
+        text = await format_banwords_list()
        keyboard = get_refresh_kb(page)

        if is_callback:
--- a/bot/handlers/commands/users/start_cmd.py
+++ b/bot/handlers/commands/users/start_cmd.py
@@ -53,13 +53,13 @@ async def start_cmd(update: Message | CallbackQuery) -> None:

    # Формируем текст помощи
    help_text = (
-        f'{tg_emoji(4961073056677103064)} <b>PrimoGuard - Бот-модератор</b>\n\n'
-        '<blockquote>Автоматическое удаление сообщений с запрещёнными словами.\nПоддержка подстрок, лемм, временных блокировок и режимов модерации.</blockquote>\n\n'
+        f'{tg_emoji("4961073056677103064")} <b>PrimoGuard - Бот-модератор</b>\n\n'
+        '<blockquote>Автоматическое удаление сообщений с запрещёнными словами.\nПоддержка слов, лемм, временных блокировок и режимов модерации.</blockquote>\n\n'
    )

    # === Команды просмотра ===
    help_text += (
-        f'{tg_emoji(4961141003059725568)} <b>Просмотр:</b>\n'
+        f'{tg_emoji("4961141003059725568")} <b>Просмотр:</b>\n'
        '<b>/list</b> — список всех правил и слов\n'
        '<b>/stats</b> — статистика по удалениям\n'
        '<b>/id</b> — получение айди пользователя\n'
@@ -68,23 +68,23 @@ async def start_cmd(update: Message | CallbackQuery) -> None:

    # === Постоянные банворды ===
    help_text += (
-        f'{tg_emoji(4961019408240608234)} <b>Добавить банворд (постоянно):</b>\n'
-        '<code>/addword</code> <code>слово</code> — подстрока (простой поиск)\n'
-        '<code>/addlemma</code> <code>слово</code> — лемма (все формы слова)\n'
-        '<code>/addpart</code> <code>комбинация</code> — часть (поиск без пробелов)\n\n'
+        f'{tg_emoji("4961019408240608234")} <b>Добавить банворд (постоянно):</b>\n'
+        '<code>/word</code> <code>слово</code> — слова (простой поиск)\n'
+        '<code>/lemma</code> <code>слово</code> — лемма (все формы слова)\n'
+        '<code>/part</code> <code>комбинация</code> — часть (поиск без пробелов)\n\n'
    )

    # === Временные банворды ===
    help_text += (
-        f'{tg_emoji(4960719190026618714)} <b>Добавить банворд (временно):</b>\n'
-        '<code>/addtempword</code> <code>слово минуты</code> — временная подстрока\n'
-        '<code>/addtemplemma</code> <code>слово минуты</code> — временная лемма\n'
-        '<i>Пример: /addtempword спам 60</i>\n\n'
+        f'{tg_emoji("4960719190026618714")} <b>Добавить банворд (временно):</b>\n'
+        '<code>/tempword</code> <code>слово минуты</code> — временная слова\n'
+        '<code>/templemma</code> <code>слово минуты</code> — временная лемма\n'
+        '<i>Пример: /tempword спам 60</i>\n\n'
    )

    # === Исключения (whitelist) ===
    help_text += (
-        f'{tg_emoji(4963010134172239128)} <b>Исключения (whitelist):</b>\n'
+        f'{tg_emoji("4963010134172239128")} <b>Исключения (whitelist):</b>\n'
        '<code>/addexcept</code> <code>текст</code> — добавить исключение\n'
        '<code>/remexcept</code> <code>текст</code> — удалить исключение\n'
        '<i>Исключения не проверяются фильтром</i>\n\n'
@@ -92,36 +92,38 @@ async def start_cmd(update: Message | CallbackQuery) -> None:

    # === Режимы модерации ===
    help_text += (
-        f'{tg_emoji(4960987543878239236)} <b>Режим тишины:</b>\n'
+        f'{tg_emoji("4960987543878239236")} <b>Режим тишины:</b>\n'
        '<code>/silence</code> <code>минуты</code> — удалять ВСЕ сообщения\n'
        '<b>/unsilence</b> — отключить режим тишины\n'
        '<code>/report</code> — отправить репорт\n\n'
    )

    help_text += (
-        f'{tg_emoji(4960986152308835400)} <b>Режим антиконфликта:</b>\n'
+        f'{tg_emoji("4960986152308835400")} <b>Режим антиконфликта:</b>\n'
        '<code>/addconflictword</code> <code>слово</code> — добавить конфликтное слово\n'
        '<code>/addconflictlemma</code> <code>слово</code> — добавить конфликтную лемму\n'
+        '<code>/addconflictpart</code> <code>слово</code> — добавить конфликтную часть\n'
        '<code>/stopconflict</code> <code>минуты</code> — активировать режим\n'
        '<code>/unstopconflict</code> — отключить режим\n\n'
    )

    # === Удаление ===
    help_text += (
-        f'{tg_emoji(4961196485447254983)} <b>Удалить:</b>\n'
-        '<code>/remword</code> <code>слово</code> — удалить подстроку\n'
+        f'{tg_emoji("4961196485447254983")} <b>Удалить:</b>\n'
+        '<code>/remword</code> <code>слово</code> — удалить слову\n'
        '<code>/remlemma</code> <code>слово</code> — удалить лемму\n'
        '<code>/rempart</code> <code>комбинация</code> — удалить часть\n'
-        '<code>/remtempword</code> <code>слово</code> — удалить временную подстроку\n'
+        '<code>/remtempword</code> <code>слово</code> — удалить временную слову\n'
        '<code>/remtemplemma</code> <code>слово</code> — удалить временную лемму\n'
        '<code>/remconflictword</code> <code>слово</code> — удалить конфликтное слово\n'
+        '<code>/remconflictpart</code> <code>слово</code> — удалить конфликтное часть\n'
        '<code>/remconflictlemma</code> <code>слово</code> — удалить конфликтную лемму\n\n'
    )

    # === Управление админами (только для суперадминов) ===
    if is_super_admin:
        help_text += (
-            f'{tg_emoji(4960891456869893259)} <b>Управление админами (только для владельцев):</b>\n'
+            f'{tg_emoji("4960891456869893259")} <b>Управление админами (только для владельцев):</b>\n'
            '<code>/addadmin</code> <i>ID</i> — добавить администратора\n'
            '<code>/remadmin</code> <i>ID</i> — удалить администратора\n'
            '<b>/redactcomment</b> — изменить комментарий под постом\n'
@@ -130,8 +132,8 @@ async def start_cmd(update: Message | CallbackQuery) -> None:

    # === Типы проверок ===
    help_text += (
-        f'{tg_emoji(4961021096162755737)} <b>Типы проверок:</b>\n'
-        '• <b>Подстрока</b> — простой поиск в тексте\n'
+        f'{tg_emoji("4961021096162755737")} <b>Типы проверок:</b>\n'
+        '• <b>Слово</b> — простой поиск в тексте\n'
        '• <b>Лемма</b> — все формы слова (купить→куплю, купил, купишь...)\n'
        '• <b>Часть</b> — поиск без пробелов (обходит \"к у п и т ь\")\n'
        '• <b>Временные</b> — автоматически удаляются через N минут\n'
@@ -159,4 +161,4 @@ async def start_cmd(update: Message | CallbackQuery) -> None:
            log_type="ERROR"
        )
        if is_callback:
-            await update.answer(f'{tg_emoji(4963277744994518278)} Ошибка отображения справки', show_alert=True)
+            await update.answer(f'{tg_emoji("4963277744994518278")} Ошибка отображения справки', show_alert=True)
--- a/bot/handlers/commands/users/stats.py
+++ b/bot/handlers/commands/users/stats.py
@@ -153,7 +153,13 @@ async def stats_cmd(update: Message | CallbackQuery) -> None:

                conflict_words_count = len(data.get('conflict_substring', set()))
                conflict_lemmas_count = len(data.get('conflict_lemma', set()))
-                total_conflict = conflict_words_count + conflict_lemmas_count
+                conflict_parts_count = len(data.get('conflict_part', set()))
+
+                total_conflict = (
+                        conflict_words_count +
+                        conflict_lemmas_count +
+                        conflict_parts_count
+                )

                output += f"⚔️ <b>Режим антиконфликта</b>\n"
                output += f"├─ ⏱ Осталось: <code>{format_time_remaining(time_left_minutes)}</code>\n"
--- a/bot/handlers/commands/users/word.py
+++ b/bot/handlers/commands/users/word.py
@@ -108,7 +108,7 @@ async def add_word_cmd(message: Message) -> None:
    try:
        added = await manager.add_banword(
            word=word,
-            word_type=BanWordType.SUBSTRING,
+            word_type=BanWordType.WORD,
            added_by=message.from_user.id,
            reason=f"Добавлено через команду"
        )
@@ -126,7 +126,7 @@ async def add_word_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка добавления банворда: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка добавления банворда: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка добавления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -168,7 +168,7 @@ async def add_lemma_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка добавления леммы: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка добавления леммы: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка добавления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -210,7 +210,7 @@ async def add_part_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка добавления части: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка добавления части: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка добавления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -246,7 +246,7 @@ async def add_temp_word_cmd(message: Message) -> None:
    try:
        added = await manager.add_temp_banword(
            word=word,
-            word_type=BanWordType.SUBSTRING,
+            word_type=BanWordType.WORD,
            minutes=minutes,
            added_by=message.from_user.id
        )
@@ -265,7 +265,7 @@ async def add_temp_word_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка добавления временного банворда: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка добавления временного банворда: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка добавления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -319,7 +319,7 @@ async def add_temp_lemma_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка добавления временной леммы: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка добавления временной леммы: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка добавления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -360,7 +360,7 @@ async def add_exception_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка добавления исключения: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка добавления исключения: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка добавления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -384,7 +384,7 @@ async def remove_word_cmd(message: Message) -> None:
    manager = get_manager()

    try:
-        removed = await manager.remove_banword(word=word, word_type=BanWordType.SUBSTRING)
+        removed = await manager.remove_banword(word=word, word_type=BanWordType.WORD)

        if removed:
            text = format_success_message("удалена", word, "подстрока")
@@ -394,7 +394,7 @@ async def remove_word_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка удаления банворда: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка удаления банворда: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка удаления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -422,7 +422,7 @@ async def remove_lemma_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка удаления леммы: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка удаления леммы: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка удаления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -450,7 +450,7 @@ async def remove_part_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка удаления части: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка удаления части: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка удаления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -469,7 +469,7 @@ async def remove_temp_word_cmd(message: Message) -> None:
    manager = get_manager()

    try:
-        removed = await manager.remove_temp_banword(word=word, word_type=BanWordType.SUBSTRING)
+        removed = await manager.remove_temp_banword(word=word, word_type=BanWordType.WORD)

        if removed:
            text = format_success_message("удалена", word, "временная подстрока")
@@ -479,7 +479,7 @@ async def remove_temp_word_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка удаления временного банворда: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка удаления временного банворда: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка удаления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -508,7 +508,7 @@ async def remove_temp_lemma_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка удаления временной леммы: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка удаления временной леммы: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка удаления</b>\n\nПопробуйте позже", parse_mode="HTML")


@@ -536,5 +536,5 @@ async def remove_exception_cmd(message: Message) -> None:
        await message.answer(text, parse_mode="HTML")

    except Exception as e:
-        logger.error(f"Ошибка удаления исключения: {e}", log_type="CMD", exc_info=True)
+        logger.error(f"Ошибка удаления исключения: {e}", log_type="CMD")
        await message.answer("❌ <b>Ошибка удаления</b>\n\nПопробуйте позже", parse_mode="HTML")
--- a/bot/handlers/messages/init.py
+++ b/bot/handlers/messages/init.py
@@ -1,15 +1,9 @@
 from aiogram import Router

 from .default_msg import router as default_message_router
-from .ping_test import router as ping_test_message_router

 # Настройка экспорта и роутера
 router: Router = Router(name=__name__)

-# Подготовка роутера команд
-# router.include_routers(
-#     ping_test_message_router,
-# )
-
 # Подключение стандартного роутера
 router.include_router(default_message_router)
--- a/bot/middlewares/init.py
+++ b/bot/middlewares/init.py
@@ -47,8 +47,8 @@ def setup_middlewares(
        bot: Bot,
        admin_ids: list[int] = settings.ADMIN_ID+settings.OWNER_ID,
        channel_ids: list[int | str] | None = None,
-        enable_spam_check: bool = False,
-        enable_subscription_check: bool = False,
+            enable_spam_check: bool = settings.enable_spam_check,
+        enable_subscription_check: bool = settings.enable_subscription_check,
 ) -> dict:
    """
    Регистрирует все middleware в диспетчере.
@@ -138,5 +138,3 @@ def setup_middlewares(
    )

    return instances
-
-
--- a/bot/middlewares/banwords_mdw.py
+++ b/bot/middlewares/banwords_mdw.py
@@ -1,13 +1,5 @@
 """
 Middleware для проверки сообщений на запрещённые слова (банворды).
-
-✅ ИСПРАВЛЕНО:
- Полная нормализация текста с использованием UNICODE_MAP
- Удаление повторов символов (леееейн → лейн)
- Игнорирование разделителей (л.е.й.н → лейн)
- Поддержка всех типов проверок (SUBSTRING, LEMMA, PART, CONFLICT)
- Белый список и режимы тишины/конфликта
- Нет уведомлений в режиме тишины
 """

 from typing import Callable, Dict, Any, Awaitable, Optional
@@ -15,7 +7,7 @@ import re
 import unicodedata

 from aiogram import BaseMiddleware
-from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.types import Message
 from aiogram.exceptions import TelegramBadRequest

 from configs import settings, UNICODE_MAP, LATIN_TO_CYRILLIC, CYRILLIC_NORMALIZE
@@ -23,97 +15,86 @@ from database import get_manager, BanWordType
 from bot.special import extract_words, get_lemma
 from middleware.loggers import logger

-__all__ = ("BanWordsMiddleware",)

+__all__ = ("BanWordsMiddleware",)
+URL_PATTERN = re.compile(
+    r'(https?://\S+|www\.\S+)',
+    re.IGNORECASE
+)

 class TextNormalizer:
    """
    Класс для многоступенчатой нормализации текста.
-    Приводит различные юникод-символы к базовым буквам,
-    удаляет повторы, убирает разделители.
    """

-    # Объединяем все словари замен в один
-    FULL_MAP = {}
+    FULL_MAP: Dict[str, str] = {}
    FULL_MAP.update(LATIN_TO_CYRILLIC)
    FULL_MAP.update(CYRILLIC_NORMALIZE)
    FULL_MAP.update(UNICODE_MAP)

-    # Символы-разделители, которые могут быть вставлены между буквами
    SEPARATORS = re.compile(r'[\s.\-_,;:|]+', re.UNICODE)
-
-    # Паттерн для поиска повторяющихся букв (3+ раза)
    REPEAT_PATTERN = re.compile(r'([а-яёa-z])\1{2,}', re.IGNORECASE)

    @classmethod
    def normalize_characters(cls, text: str) -> str:
-        """
-        Заменяет все символы из FULL_MAP на их базовые эквиваленты.
-        Проходит по строке посимвольно для максимальной замены.
-        """
-        result = []
+        result: list[str] = []
        for ch in text:
-            # Сначала пробуем заменить по карте
-            if ch in cls.FULL_MAP:
-                result.append(cls.FULL_MAP[ch])
-            else:
-                result.append(ch)
-        # Приводим к нижнему регистру после замен (чтобы избежать потери регистра в карте)
+            result.append(cls.FULL_MAP.get(ch, ch))
        return ''.join(result).lower()

    @classmethod
    def remove_separators(cls, text: str) -> str:
-        """Удаляет разделители между буквами (пробелы, точки и т.д.)"""
        return cls.SEPARATORS.sub('', text)

    @classmethod
-    def collapse_repeats(cls, text: str, max_repeat: int = 2) -> str:
-        def repl(m):
-            ch = m.group(1)
-            return ch  # вместо ch * 2 — теперь схлопываем до одного символа
-
+    def collapse_repeats(cls, text: str) -> str:
+        def repl(match: re.Match[str]) -> str:
+            return match.group(1)
        return cls.REPEAT_PATTERN.sub(repl, text)

    @classmethod
-    def normalize_full(cls, text: str, remove_sep: bool = True, collapse: bool = True) -> str:
-        """
-        Полная нормализация:
-        1. Unicode нормализация (NFKC) для разложения составных символов
-        2. Замена по карте
-        3. Приведение к нижнему регистру
-        4. Удаление разделителей (опционально)
-        5. Схлопывание повторов (опционально)
-        """
-        # NFKC разлагает символы типа "ё" в "е" + умляут, но нам лучше оставить как есть,
-        # т.к. у нас есть прямые замены. Однако для совместимости применим.
+    def normalize_full(
+        cls,
+        text: str,
+        remove_sep: bool = True,
+        collapse: bool = True
+    ) -> str:
        text = unicodedata.normalize('NFKC', text)
-        # Замена символов
        text = cls.normalize_characters(text)
-        # Удаление разделителей
+
        if remove_sep:
            text = cls.remove_separators(text)
-        # Схлопывание повторов
+
        if collapse:
            text = cls.collapse_repeats(text)
+
        return text

    @classmethod
-    def normalize_for_part(cls, text: str) -> str:
+    def normalize_for_part_token(cls, text: str) -> str:
        """
-        Нормализация для типа PART:
-        - Полная нормализация
-        - Удаление всех не-буквенных символов (кроме пробелов)
-        - Приведение к нижнему регистру
+        Нормализация для PART:
+        - NFKC
+        - lower()
+        - удаление zero-width
+        - схлопывание повторов латиницы
+        - БЕЗ LATIN_TO_CYRILLIC
        """
-        text = cls.normalize_full(text, remove_sep=False, collapse=True)
-        # Оставляем только буквы и пробелы
-        text = re.sub(r'[^а-яёa-z\s]', '', text, flags=re.IGNORECASE)
-        text = re.sub(r'\s+', ' ', text).strip()
-        return text.lower()
+        text = unicodedata.normalize('NFKC', text)
+        text = text.lower()
+
+        # удаляем zero-width
+        text = re.sub(r'[\u200B-\u200D\uFEFF]', '', text)
+
+        # схлопываем повторы букв (3+ → 1)
+        text = re.sub(r'([a-z])\1+', r'\1', text)
+
+        return text


 class BanWordsMiddleware(BaseMiddleware):
-    def __init__(self):
+
+    def __init__(self) -> None:
        super().__init__()
        self.manager = get_manager()
        self.normalizer = TextNormalizer()
@@ -124,219 +105,178 @@ class BanWordsMiddleware(BaseMiddleware):
        event: Message,
        data: Dict[str, Any]
    ) -> Any:
-        # Проверяем наличие текста или подписи
+
        if not event.text and not event.caption:
            return await handler(event, data)

-        message_text = event.text or event.caption
+        message_text: str = event.text or event.caption

-        # Игнорируем команды
        if message_text.startswith('/'):
            return await handler(event, data)

-        # Проверка на админа
-        user_id = event.from_user.id
-        is_super_admin = user_id in settings.OWNER_ID
-        is_admin = is_super_admin or self.manager.is_admin_cached(user_id)
+        user_id: int = event.from_user.id
+        is_super_admin: bool = user_id in settings.OWNER_ID
+        is_admin: bool = is_super_admin or self.manager.is_admin_cached(user_id)
+
        if is_admin:
            return await handler(event, data)

-        # Проверяем сообщение на спам
        spam_result = await self._check_message(message_text)
+
        if spam_result:
-            await self._handle_spam(event, spam_result)
-            return None  # Сообщение удалено, дальше не обрабатываем
+            await self._handle_spam(event)
+            return None

        return await handler(event, data)

-    async def _check_message(self, text: str) -> Optional[Dict[str, str]]:
-        """
-        Многоступенчатая проверка текста.
-        Возвращает словарь с причиной блокировки или None.
-        """
-        # 1. Повторяющиеся символы (например, "леееейн") — блокируем сразу
-        # repeat_result = self._check_repeated_chars(text)
-        # if repeat_result:
-            # return repeat_result
+    @staticmethod
+    def is_allowed_url(url: str, allowed: str) -> bool:
+        url_lower = url.lower()
+        allowed_lower = allowed.lower()
+        if allowed_lower.endswith('/'):
+            # исключение со слешем: только строгое начало с этим слешем
+            return url_lower.startswith(allowed_lower)
+        else:
+            # исключение без слеша: разрешаем точное совпадение или начало с добавлением слеша
+            return url_lower == allowed_lower or url_lower.startswith(allowed_lower + '/')

-        # 2. Получаем кэшированные списки
-        substring_words = self.manager.get_banwords_cached(BanWordType.SUBSTRING)
+    async def _check_message(self, text: str) -> Optional[Dict[str, str]]:
+        whitelist = {
+            w.lower().strip()
+            for w in self.manager.get_whitelist_cached()
+        }
+
+        # ================= URL CHECK =================
+        urls = URL_PATTERN.findall(text)
+
+        for url in urls:
+            url_lower = url.lower()
+
+            # если URL начинается с разрешённого исключения — пропускаем
+            if any(self.is_allowed_url(url_lower, allowed) for allowed in whitelist):
+                continue
+
+            # если нет разрешения — проверяем WORD-правила для URL
+            for word in self.manager.get_banwords_cached(BanWordType.WORD):
+                if word in url_lower:
+                    return {"word": word, "type": "word"}
+        # =============================================
+
+        # 2. Убираем URL из текста для word/lemma проверки
+        text_without_urls = URL_PATTERN.sub(' ', text)
+
+        word_words = self.manager.get_banwords_cached(BanWordType.WORD)
        lemma_words = self.manager.get_banwords_cached(BanWordType.LEMMA)
        part_words = self.manager.get_banwords_cached(BanWordType.PART)
-        conflict_substring = self.manager.get_banwords_cached(BanWordType.CONFLICT_SUBSTRING)
+        conflict_word = self.manager.get_banwords_cached(BanWordType.CONFLICT_WORD)
        conflict_lemma = self.manager.get_banwords_cached(BanWordType.CONFLICT_LEMMA)
+        conflict_part = self.manager.get_banwords_cached(BanWordType.CONFLICT_PART)

-        # 3. Белый список
-        if self.manager.is_whitelisted(text):
-            logger.debug(f"⏭️ Пропуск по белому списку: {text[:30]}", log_type="BANWORDS")
-            return None
-
-        # 4. Режим тишины
        if await self.manager.is_silence_active():
            return {"word": "[режим тишины]", "type": "silence"}

-        # 5. Режим конфликта (более мягкие правила)
        if await self.manager.is_conflict_active():
-            # Проверка conflict_substring (с нормализацией)
-            normalized_text = self.normalizer.normalize_full(text, remove_sep=True, collapse=True)
-            for word in conflict_substring:
-                norm_word = self.normalizer.normalize_full(word, remove_sep=True, collapse=True)
-                if norm_word in normalized_text:
-                    return {"word": word, "type": "conflict_substring"}
+            normalized_text = self.normalizer.normalize_full(text)
+
+            for word in conflict_word:
+                if self.normalizer.normalize_full(word) in normalized_text:
+                    return {"word": word, "type": "conflict_word"}

-            # conflict_lemma
            for word_text in extract_words(text):
-                lemma = get_lemma(word_text)
-                if lemma in conflict_lemma:
-                    return {"word": lemma, "type": "conflict_lemma"}
+                if get_lemma(word_text) in conflict_lemma:
+                    return {"word": word_text, "type": "conflict_lemma"}

-            # Если в конфликтном режиме ничего не найдено — пропускаем
            return None

-        # 6. Обычный режим: проверка substring (с удалением разделителей и схлопыванием повторов)
-        normalized_text = self.normalizer.normalize_full(text, remove_sep=True, collapse=True)
-        for word in substring_words:
-            norm_word = self.normalizer.normalize_full(word, remove_sep=True, collapse=True)
-            if norm_word in normalized_text:
-                logger.info(f"✅ SUBSTRING: '{word}'", log_type="BANWORDS")
-                return {"word": word, "type": "substring"}
+        # WORD — строгое совпадение как отдельное слово
+        for word in word_words:
+            pattern = r'(?<!\w){}(?!\w)'.format(re.escape(word))
+
+            for match in re.finditer(pattern, text_without_urls, re.IGNORECASE):
+                matched = match.group(0).lower()
+
+                # если совпавшее слово в whitelist — игнорируем
+                if matched in whitelist:
+                    continue
+
+                # если это начало URL — пропускаем
+                if text[match.end():match.end() + 3] == '://':
+                    continue
+
+                return {"word": word, "type": "word"}
+
+        # PART
+        usernames = re.findall(r'@[\w_]+', text_without_urls)
+        latin_tokens = re.findall(r'\b[a-zA-Z0-9_]*[a-zA-Z]+[a-zA-Z0-9_]*\b', text_without_urls)
+
+        tokens_to_check = usernames + latin_tokens
+
+        # PART
+        for token in tokens_to_check:
+            token_lower = token.lower()
+
+            # если именно этот токен разрешён
+            normalized_for_whitelist = token_lower.lstrip('@')
+
+            if (
+                    token_lower in whitelist or
+                    normalized_for_whitelist in whitelist or
+                    f"@{normalized_for_whitelist}" in whitelist
+            ):
+                continue
+
+            normalized_token = self.normalizer.normalize_for_part_token(token)

-        # 7. Проверка part (строгая нормализация, только буквы и пробелы)
-        part_normalized = self.normalizer.normalize_for_part(text)
            for part in part_words:
-            norm_part = self.normalizer.normalize_for_part(part)
-            if norm_part in part_normalized:
-                logger.info(f"✅ PART: '{part}'", log_type="BANWORDS")
+                norm_part = self.normalizer.normalize_for_part_token(part)
+
+                if norm_part in normalized_token:
                    return {"word": part, "type": "part"}

-        # 8. Проверка lemma
-        for word_text in extract_words(text):
-            # Для леммы тоже применяем нормализацию (удаляем разделители, схлопываем повторы)
-            normalized_word = self.normalizer.normalize_full(word_text, remove_sep=True, collapse=True)
+        # CONFLICT PART
+        for token in tokens_to_check:
+            token_lower = token.lower()
+
+            normalized_for_whitelist = token_lower.lstrip('@')
+
+            if (
+                    token_lower in whitelist or
+                    normalized_for_whitelist in whitelist or
+                    f"@{normalized_for_whitelist}" in whitelist
+            ):
+                continue
+
+            normalized_token = self.normalizer.normalize_for_part_token(token)
+
+            for part in conflict_part:
+                norm_part = self.normalizer.normalize_for_part_token(part)
+
+                if norm_part in normalized_token:
+                    return {"word": part, "type": "conflict_part"}
+
+        # LEMMA
+        for word_text in extract_words(text_without_urls):
+            word_lower = word_text.lower()
+
+            # если слово разрешено — пропускаем
+            if word_lower in whitelist:
+                continue
+
+            normalized_word = self.normalizer.normalize_full(word_text)
            lemma = get_lemma(normalized_word)
+
            if lemma in lemma_words:
-                logger.info(f"✅ LEMMA: '{lemma}' из '{word_text}'", log_type="BANWORDS")
                return {"word": lemma, "type": "lemma"}

        return None

-    def _check_repeated_chars(self, text: str) -> Optional[Dict[str, str]]:
-        """
-        Проверяет на наличие 3+ повторяющихся букв подряд.
-        Использует сырой текст без нормализации (чтобы поймать "леееейн").
-        """
-        # Ищем повторения букв (только кириллица/латиница)
-        pattern = re.compile(r'([а-яёa-zA-Z])\1{2,}', re.IGNORECASE)
-        matches = pattern.finditer(text)
-        for match in matches:
-            char = match.group(1)
-            count = len(match.group(0))
-            if count >= 3:
-                logger.info(f"🔥 ПОВТОРЫ: '{match.group(0)}' ({count}x)", log_type="BANWORDS")
-                return {"word": f"'{match.group(0)}' ({count}x)", "type": "repeated_chars"}
-        return None
-
-    async def _handle_spam(self, message: Message, spam_result: Dict[str, str]) -> None:
-        """Обрабатывает спам-сообщение: удаляет, логирует, уведомляет (кроме silence)"""
-        user = message.from_user
-        matched_word = spam_result["word"]
-        match_type = spam_result["type"]
-        message_text = message.text or message.caption or "[нет текста]"
-
-        # В режиме тишины удаляем молча
-        if match_type == "silence":
-            try:
-                await message.delete()
-                logger.info(f"🔇 SILENCE: @{user.username or user.id} удалено молча", log_type="BANWORDS")
-            except TelegramBadRequest as e:
-                logger.error(f"❌ Не удалено (silence): {e}", log_type="BANWORDS")
-            return
-
-        # Удаляем сообщение
-        try:
-            await message.delete()
-            logger.info(f"🚫 @{user.username or user.id}: '{matched_word}' ({match_type})", log_type="BANWORDS")
-        except TelegramBadRequest as e:
-            logger.error(f"❌ Не удалено: {e}", log_type="BANWORDS")
-            return
-
-        # Логируем в БД
-        await self.manager.log_spam(
-            user_id=user.id,
-            username=user.username or f"id{user.id}",
-            chat_id=message.chat.id,
-            message_text=message_text,
-            matched_word=matched_word,
-            match_type=match_type
-        )
-
-        # Уведомляем админов
-        await self._notify_admins(message, matched_word, match_type, message_text)
-
-    async def _notify_admins(
-    self,
+    @staticmethod
+    async def _handle_spam(
            message: Message,
-    matched_word: str,
-    match_type: str,
-    message_text: str
-) -> None:
-        """Отправляет уведомление об удалении в админ-чат (берёт ID из БД)"""
-        user = message.from_user
-        username = f"@{user.username}" if user.username else f"ID: {user.id}"
-        spam_count = await self.manager.get_user_spam_count(user.id)
-        chat_title = message.chat.title or "Без названия"
-        source_thread_id = message.message_thread_id
-
-        notification_text = (
-            f"🚫 <b>Удалено сообщение</b>\n\n"
-            f"👤 <b>Пользователь:</b> {username}\n"
-            f"🆔 <b>ID:</b> <code>{user.id}</code>\n"
-            f"📊 <b>Нарушений:</b> {spam_count}\n\n"
-            f"💬 <b>Чат:</b> {self._escape_html(chat_title)}\n"
-            f"🆔 <b>Chat ID:</b> <code>{message.chat.id}</code>\n"
-            f"{'📌 <b>Topic ID:</b> <code>' + str(source_thread_id) + '</code>\n' if source_thread_id else ''}"
-            f"🔗 <b>Message ID:</b> <code>{message.message_id}</code>\n\n"
-            f"🔍 <b>Триггер:</b> <code>{self._escape_html(matched_word)}</code>\n"
-            f"📝 <b>Тип:</b> {self._get_type_emoji(match_type)} {self._escape_html(match_type)}\n\n"
-            f"💬 <b>Текст:</b>\n<code>{self._escape_html(message_text[:500])}</code>"
-        )
-
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [
-                InlineKeyboardButton(text="🔨 Забанить", callback_data=f"spam_ban:{user.id}:{message.chat.id}"),
-                InlineKeyboardButton(text="✅ Закрыть", callback_data="spam_close")
-            ],
-            [InlineKeyboardButton(text="📊 Статистика", callback_data=f"spam_stats:{user.id}")]
-        ])
+    ) -> None:

        try:
-            # ✅ Получаем настройки из БД (динамические, установленные через /settings)
-            admin_chat_id = await self.manager.get_bot_setting("admin_chat_id")
-            admin_thread_id = await self.manager.get_bot_setting("admin_thread_id")
-
-            if admin_chat_id:
-                await message.bot.send_message(
-                    chat_id=int(admin_chat_id),
-                    text=notification_text,
-                    reply_markup=keyboard,
-                    parse_mode="HTML",
-                    message_thread_id=int(admin_thread_id) if admin_thread_id else None
-                )
-        except Exception as e:
-            logger.error(f"❌ Уведомление админам: {e}", log_type="BANWORDS")
-
-    @staticmethod
-    def _get_type_emoji(match_type: str) -> str:
-        return {
-            "substring": "🔤",
-            "lemma": "📖",
-            "part": "🧩",
-            "silence": "🔇",
-            "conflict_substring": "⚔️",
-            "conflict_lemma": "⚔️",
-            "repeated_chars": "🔁"
-        }.get(match_type, "❓")
-
-    @staticmethod
-    def _escape_html(text: str) -> str:
-        return str(text).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            await message.delete()
+            logger.info(f"Удалено сообщение: {message.text}")
+        except TelegramBadRequest:
+            return
--- a/bot/middlewares/spam_mdw.py
+++ b/bot/middlewares/spam_mdw.py
@@ -105,7 +105,7 @@ class UserSpamStats:
        self.total_blocks += 1
        self.reputation = max(0.5, self.reputation - 0.3)

-    def detect_spam_patterns(self, time_window: float = 10.0) -> Dict[str, Any]:
+    def detect_spam_patterns(self, time_window: float = 2.0) -> Dict[str, Any]:
        """
        Умная детекция спама на основе паттернов.
        УЛУЧШЕНО: учитывает скорость отправки сообщений.
@@ -120,7 +120,7 @@ class UserSpamStats:
        current_time = time()

        # 1. КРИТИЧНО: Экстремально быстрая отправка (флуд-бот)
-        very_recent = [ctx for ctx in recent_contexts if (current_time - ctx.timestamp) < 2.0]
+        very_recent = [ctx for ctx in recent_contexts if (current_time - ctx.timestamp) < time_window]
        if len(very_recent) >= 5:
            return {
                'is_spam': True,
@@ -133,7 +133,7 @@ class UserSpamStats:

        # 2. КРИТИЧНО: 8+ сообщений за 5 секунд => агрессивный флуд
        recent_5s = [ctx for ctx in recent_contexts if (current_time - ctx.timestamp) < 5.0]
-        if len(recent_5s) >= 8:
+        if len(recent_5s) >= 15:
            return {
                'is_spam': True,
                'reason': 'aggressive_flood',
@@ -145,7 +145,7 @@ class UserSpamStats:

        # 3. Медиа-флуд
        media_contexts = [ctx for ctx in recent_contexts if ctx.media_type]
-        if len(media_contexts) >= 7:
+        if len(media_contexts) >= 15:
            media_recent = [ctx for ctx in media_contexts if (current_time - ctx.timestamp) < 5.0]
            if len(media_recent) >= 6:
                return {
@@ -303,7 +303,8 @@ class AntiSpamMiddleware(BaseMiddleware):
        self.enable_reputation = enable_reputation
        self.log_all = log_all

-    def _extract_context(self, event: TelegramObject) -> MessageContext:
+    @staticmethod
+    def _extract_context(event: TelegramObject) -> MessageContext:
        """Извлекает контекст из события"""
        context = MessageContext()

--- a/bot/templates/message_callback.py
+++ b/bot/templates/message_callback.py
@@ -246,8 +246,8 @@ async def msg(
    keyboard = markups(markup)

    try:
-        # Попытка редактирования (для callback)
        if edit_if_possible and isinstance(update, CallbackQuery):
+            try:
                sent_message = await message.edit_text(
                    text=text,
                    reply_markup=keyboard,
@@ -260,8 +260,25 @@ async def msg(
                        f"Сообщение отредактировано: {message.message_id}",
                        log_type='MESSAGE'
                    )
+
+            except (TelegramBadRequest, TelegramForbiddenError):
+                sent_message = await message.answer(
+                    text=text,
+                    reply_markup=keyboard,
+                    parse_mode=parse_mode,
+                    disable_web_page_preview=disable_web_page_preview,
+                    disable_notification=disable_notification,
+                    protect_content=protect_content
+                )
        else:
-            raise TelegramBadRequest
+            sent_message = await message.answer(
+                text=text,
+                reply_markup=keyboard,
+                parse_mode=parse_mode,
+                disable_web_page_preview=disable_web_page_preview,
+                disable_notification=disable_notification,
+                protect_content=protect_content
+            )

    except (TelegramBadRequest, TelegramForbiddenError):
        # Отправка нового сообщения
--- a/configs/cmd_alias_list.py
+++ b/configs/cmd_alias_list.py
@@ -64,7 +64,7 @@ COMMANDS: Final[dict[str, list[str]]] = {
    "addtemplemma": [
        "addtemplemma", "добавитьвремлемму", # основные
        "фввеуьздуььф", "lj,fdbnmdhtvktve",  # раскладка
-        "atl", "addtl", "темплемму", "addtlem", "addtemplem",
+        "atl", "addtl", "темплемму", "addtlem", "addtemplem", "templemma"
    ],

    # ==================== ДОБАВЛЕНИЕ ИСКЛЮЧЕНИЙ ====================
@@ -78,19 +78,19 @@ COMMANDS: Final[dict[str, list[str]]] = {
    "remword": [
        "remword", "удалитьслово",           # основные
        "кутцщкв", "elfkbnmckjdj",           # раскладка
-        "rw", "delword", "dw", "удслово",
+        "rw", "delword", "dw", "удслово", "rword",
    ],

    "remlemma": [
        "remlemma", "удалитьлемму",          # основные
        "кутдуььф", "elfkbnmktve",           # раскладка
-        "rl", "dellemma", "dl", "удлемму",
+        "rl", "dellemma", "dl", "удлемму", "rlemma",
    ],

    "rempart": [
        "rempart", "удалитьчасть",           # основные
        "кутзфке", "elfkbnmxfcnm",           # раскладка
-        "rp", "delpart", "dp", "удчасть",
+        "rp", "delpart", "dp", "удчасть", "rpart",
    ],

    # ==================== УДАЛЕНИЕ ВРЕМЕННЫХ ====================
@@ -110,45 +110,45 @@ COMMANDS: Final[dict[str, list[str]]] = {
    "remexcept": [
        "remexcept", "удалитьисключение",    # основные
        "кутучсузе", "elfkbnmbcrkx",         # раскладка
-        "rxc", "remwhite", "удискл",
+        "rxc", "remwhite", "удискл", "rexcept",
    ],

    # ==================== КОНФЛИКТНЫЕ СЛОВА ====================
    "addconflictword": [
        "addconflictword", "добавитьконфликт", # основные
        "фввсщтакшсецщкв", "lj,fdbnmrjyakbrn", # раскладка
-        "acw", "addcw", "конфслово", "conflictword",
+        "acw", "addcw", "конфслово", "conflictword", "cword",
    ],

    "addconflictlemma": [
        "addconflictlemma", "добавитьконфлемму", # основные
        "фввсщтакшседуььф", "lj,fdbnmrjyaktve",  # раскладка
-        "acl", "addcl", "конфлемму", "conflictlemma",
+        "acl", "addcl", "конфлемму", "conflictlemma", "clemma", "clema",
    ],

    "remconflictword": [
        "remconflictword", "удалитьконфликт", # основные
        "кутсщтакшсецщкв", "elfkbnmrjyakbrn",  # раскладка
-        "rcw", "delcw", "удконфликт",
+        "rcw", "delcw", "удконфликт", "rcword", "rconflictword",
    ],

    "remconflictlemma": [
        "remconflictlemma", "удалитьконфлемму", # основные
        "кутсщтакшседуььф", "elfkbnmrjyaktve",  # раскладка
-        "rcl", "delcl", "удконфлемму",
+        "rcl", "delcl", "удконфлемму", "rclemma", "rclema",
    ],

    # ==================== РЕЖИМ АНТИКОНФЛИКТА ====================
    "stopconflict": [
        "stopconflict", "стопконфликт",      # основные
        "cnjgsщтакшse", "cnjzrjyakbrn",      # раскладка
-        "sconf", "sc", "стопконф", "stopconf",
+        "sconf", "sc", "стопконф", "stopconf", "stopc",
    ],

    "unstopconflict": [
        "unstopconflict", "отменаконфликта", # основные
        "eycnjgsщтакшse", "jnvtyf",          # раскладка
-        "usconf", "usc", "откконф", "unstopconf",
+        "usconf", "usc", "откконф", "unstopconf", "ustopc",
    ],

    "conflictstatus": [
@@ -161,7 +161,7 @@ COMMANDS: Final[dict[str, list[str]]] = {
    "silence": [
        "silence", "тишина",                 # основные
        "ышдутсу", "nbibyf",                # раскладка
-        "sl", "sil", "mute", "quiet", "тиш", "ven",
+        "sl", "sil", "muteall", "quiet", "тиш", "ven",
    ],

    "unsilence": [
@@ -186,31 +186,31 @@ COMMANDS: Final[dict[str, list[str]]] = {
    "addadmin": [
        "addadmin", "добавитьадмина",        # основные
        "фввфвьшт", "lj,fdbnmflvbyf",        # раскладка
-        "aa", "addadm", "добадм",
+        "aa", "addadm", "добадм", "admin",
    ],

    "remadmin": [
        "remadmin", "удалитьадмина",         # основные
        "кутфвьшт", "elfkbnmflvbyf",         # раскладка
-        "ra", "remadm", "deladmin", "удадм",
+        "ra", "remadm", "deladmin", "удадм", "radmin",
    ],

    "listadmins": [
        "listadmins", "списокадминов",       # основные
        "дшыефвьшты", "cgbcjrflvbyjd",       # раскладка
-        "admins", "adm", "adminlist", "адм", "дшыефвь", "listadm", "la",
+        "admins", "adm", "adminlist", "адм", "дшыефвь", "listadm", "la", "ladmin"
    ],

    "adminhelp": [
        "adminhelp", "помощьадмину",         # основные
        "фвьштрудз", "gjvjomflvbyt",         # раскладка
-        "admhelp", "ah", "хелпадм",
+        "admhelp", "ah", "хелпадм", "adminh"
    ],

    "checkadmin": [
        "checkadmin", "проверкаадмина",      # основные
        "сруслфвьшт", "ghjdthrf",            # раскладка
-        "isadmin", "ca", "провадм", "checkadm",
+        "isadmin", "ca", "провадм", "checkadm", "cadmin"
    ],

    # ==================== ПРОСМОТР ====================
@@ -223,25 +223,25 @@ COMMANDS: Final[dict[str, list[str]]] = {
    "listlemmas": [
        "listlemmas", "списоклемм",          # основные
        "дшыедуььфы", "cgbcjrktv",           # раскладка
-        "ll", "lemmas", "леммы",
+        "ll", "lemmas", "леммы", "llemma", "llema",
    ],

    "listparts": [
        "listparts", "списокчастей",         # основные
        "дшыезфкеы", "cgbcjrxfcntq",         # раскладка
-        "lp", "parts", "части",
+        "lp", "parts", "части", "lpart"
    ],

    "listexcept": [
        "listexcept", "списокисключений",    # основные
        "дшыеучсузе", "cgbcjrbcrkx",         # раскладка
-        "lxc", "except", "white", "искл",
+        "lxc", "except", "white", "искл", "lexcept"
    ],

    "listconflict": [
        "listconflict", "списокконфликтов",  # основные
        "дшыесщтакшse", "cgbcjrrjyakbrnjd",  # раскладка
-        "lc", "conflict", "конф",
+        "lc", "conflict", "конф", "lconflict",
    ],

    # ==================== СТАТИСТИКА ====================
@@ -280,7 +280,7 @@ COMMANDS: Final[dict[str, list[str]]] = {
    "report": [
        "report", "репорт", "жалоба",        # основные
        "кузщке", "htgjhn", ";fkj,f",        # раскладка
-        "rep", "r", "жал",
+        "rep", "r", "жал", "жб"
    ],

    "reporthelp": [
@@ -362,6 +362,15 @@ COMMANDS: Final[dict[str, list[str]]] = {
        "redcom", "editcom", "коммент", "rc",      # дополнения
    ],

+    "set_description": [
+        "set_description", "description", "set_des",
+    ],
+    "set_name": [
+        "set_name",
+    ],
+    "set_widget": [
+        "set_widget",
+    ],
    "botsettings": [
        "botsettings", "bsettings", "botsetting", "bsetting", # основные + сокращения
        "bset", "ботнастрйоки",     # раскладка
--- a/configs/config.py
+++ b/configs/config.py
@@ -45,7 +45,6 @@ class _Settings(BaseSettings):
    WEBHOOK_URL: Optional[str] = None
    WEBAPP_HOST: str = "0.0.0.0"
    WEBAPP_PORT: int = 3131
-    LOG_LEVEL: str = "warning"
    ACCES_LOG: bool = False

    # API ключи
@@ -137,7 +136,10 @@ class _Settings(BaseSettings):
    SHOW_CAPTION_ABOVE_MEDIA: bool = False

    # улучшения
-    ANTI_SPAM: bool = True
+    ANTI_SPAM: bool = False
+    enable_spam_check: bool = False
+    enable_subscription_check: bool = False
+    BOT_USERNAME: str = "@OvhdLayla2_bot"

    # ================= ВАЛИДАТОРЫ =================
    @field_validator('PARSE_MODE')
--- a/database/manager.py
+++ b/database/manager.py
@@ -44,6 +44,7 @@ class BanWordsManager:
        """Инициализирует базу данных и загружает кэш"""
        await self.db.init()
        await self.init_default_bot_settings()   # ← добавлено
+        await self.init_default_words()
        await self.refresh_cache()
        logger.info("BanWordsManager инициализирован", log_type="DATABASE")

@@ -452,12 +453,13 @@ class BanWordsManager:
        admins = await self.repo.get_admins()

        return {
-            'substring': banwords.get(BanWordType.SUBSTRING, set()),
+            'word': banwords.get(BanWordType.WORD, set()),
            'lemma': banwords.get(BanWordType.LEMMA, set()),
            'part': banwords.get(BanWordType.PART, set()),
-            'conflict_substring': banwords.get(BanWordType.CONFLICT_SUBSTRING, set()),
+            'conflict_word': banwords.get(BanWordType.CONFLICT_WORD, set()),
            'conflict_lemma': banwords.get(BanWordType.CONFLICT_LEMMA, set()),
-            'temp_substring': temp_banwords.get(BanWordType.SUBSTRING, set()),
+            'conflict_part': banwords.get(BanWordType.CONFLICT_PART, set()),
+            'temp_word': temp_banwords.get(BanWordType.WORD, set()),
            'temp_lemma': temp_banwords.get(BanWordType.LEMMA, set()),
            'whitelist': whitelist,
            'admins': admins
@@ -516,6 +518,50 @@ class BanWordsManager:
                )
                return []

+    async def init_default_words(self) -> None:
+        """
+        Добавляет базовые банворды и whitelist при первом запуске.
+        Ничего не перезаписывает, если уже существует.
+        """
+        try:
+            from configs import settings
+
+            # --- Базовые слова ---
+            default_word = {"http", "t.me/"}
+            default_part = {"bot"}
+            default_lemma = {"скам", "мошенник"}
+
+            # Проверяем уже существующие
+            existing = await self.repo.get_all_banwords()
+
+            # word
+            for word in default_word:
+                if word not in existing.get(BanWordType.WORD, set()):
+                    await self.repo.add_banword(word, BanWordType.WORD)
+
+            # PART
+            for word in default_part:
+                if word not in existing.get(BanWordType.PART, set()):
+                    await self.repo.add_banword(word, BanWordType.PART)
+
+            # LEMMA
+            for word in default_lemma:
+                if word not in existing.get(BanWordType.LEMMA, set()):
+                    await self.repo.add_banword(word, BanWordType.LEMMA)
+
+            # --- Добавляем username бота в whitelist ---
+            bot_username = settings.BOT_USERNAME
+
+            if bot_username:
+                whitelist = await self.repo.get_whitelist()
+                if bot_username.lower() not in whitelist:
+                    await self.repo.add_whitelist(bot_username.lower())
+
+            logger.info("Базовые слова и whitelist инициализированы", log_type="DATABASE")
+
+        except Exception as e:
+            logger.error(f"Ошибка инициализации базовых слов: {e}", log_type="DATABASE")
+
    async def cleanup_expired_temp_words(self) -> int:
        """
        Удаляет истёкшие временные банворды.
--- a/database/models.py
+++ b/database/models.py
@@ -31,11 +31,12 @@ class Base(DeclarativeBase):

 class BanWordType(str, PyEnum):
    """Типы банвордов"""
-    SUBSTRING = "substring"
+    WORD = "word"
    LEMMA = "lemma"
    PART = "part"
-    CONFLICT_SUBSTRING = "conflict_substring"
+    CONFLICT_WORD = "conflict_word"
    CONFLICT_LEMMA = "conflict_lemma"
+    CONFLICT_PART = "conflict_part"


 class SpamMode(str, PyEnum):
@@ -62,7 +63,11 @@ class BanWord(Base):
    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    word: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
    type: Mapped[BanWordType] = mapped_column(
-        Enum(BanWordType, native_enum=False),
+        Enum(
+            BanWordType,
+            native_enum=False,
+            values_callable=lambda enum: [e.value for e in enum]
+        ),
        nullable=False,
        index=True
    )
@@ -95,8 +100,13 @@ class TempBanWord(Base):
    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
    word: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
    type: Mapped[BanWordType] = mapped_column(
-        Enum(BanWordType, native_enum=False),
-        nullable=False
+        Enum(
+            BanWordType,
+            native_enum=False,
+            values_callable=lambda enum: [e.value for e in enum]
+        ),
+        nullable=False,
+        index=True
    )
    added_by: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
    added_at: Mapped[datetime] = mapped_column(
--- a/database/repository.py
+++ b/database/repository.py
@@ -158,11 +158,12 @@ class BanWordsRepository:

    async def get_all_banwords(self) -> dict[BanWordType, Set[str]]:
        result = {
-            BanWordType.SUBSTRING: set(),
+            BanWordType.WORD: set(),
            BanWordType.LEMMA: set(),
            BanWordType.PART: set(),
-            BanWordType.CONFLICT_SUBSTRING: set(),
+            BanWordType.CONFLICT_WORD: set(),
            BanWordType.CONFLICT_LEMMA: set(),
+            BanWordType.CONFLICT_PART: set(),
        }
        try:
            async with self.db.get_session() as session:
@@ -335,7 +336,7 @@ class BanWordsRepository:
    async def get_all_temp_banwords(self) -> dict[BanWordType, Set[str]]:
        """Получает все активные временные банворды по типам"""
        result = {
-            BanWordType.SUBSTRING: set(),
+            BanWordType.WORD: set(),
            BanWordType.LEMMA: set(),
        }
Author	SHA1	Message	Date
Verum	61956d9808	Добавление возможности менять внешний вид бота	2026-02-25 17:50:37 +07:00
Verum	d646c1eb50	Модуль изменения описания бота	2026-02-25 17:50:23 +07:00
Verum	54125b82ac	Добавление работы с конфликтными частями и исправление вайтлиста	2026-02-25 17:50:11 +07:00
Verum	6a4e56c367	Улучшение элиасов команд	2026-02-25 17:49:28 +07:00
Verum	9e38397e85	Исправление не соответствий в ядре бота	2026-02-25 17:49:15 +07:00
Verum	8b5d567536	Модуль установки настроек бота	2026-02-25 17:48:50 +07:00
Verum	82d40ad6e8	Модуль установки виджета бота	2026-02-25 17:48:41 +07:00
Verum	66889721c2	Модуль установки имени бота	2026-02-25 17:48:35 +07:00
Verum	9b56d5a45a	Модуль установки аватара (В разработке!)	2026-02-25 17:48:18 +07:00