up version

Fixed: back button in stars/ traffic display/ trial in country mode. Added error duplicate handling and request queueing.
yookassa ip adresses
2026-03-02 00:11:39 +03:00 · 2026-03-02 00:09:40 +03:00 · 2026-02-25 23:27:58 +03:00 · 2026-02-14 23:44:23 +03:00 · 2026-02-14 22:42:17 +03:00 · 2026-02-14 22:27:52 +03:00
285 changed files with 33235 additions and 11968 deletions
@@ -0,0 +1,36 @@
+---
+name: Issue
+about: Сообщить об ошибке, предложить улучшение или указать на уязвимость
+title: "[ISSUE] "
+labels: triage
+assignees: ''
+---
+
+### Тип
+- [ ] Баг
+- [ ] Фича
+- [ ] Безопасность
+
+### Кратко
+Опишите суть задачи.
+
+### Шаги воспроизведения (для багов/безопасности)
+1.
+2.
+3.
+
+### Ожидаемое / Фактическое
+-
+
+### Окружение
+- Ветка: main/dev
+- Коммит:
+- ОС:
+- Python:
+
+### Дополнительно (для фич)
+Опишите мотивацию, альтернативы.
+
+### Примечание по безопасности
+Не публикуйте PoC публично.  
+Для сообщений об уязвимостях свяжитесь напрямую: [@solonet_sup](https://t.me/solonet_sup).
@@ -0,0 +1,21 @@
+### Описание изменений
+Опишите, что изменилось и зачем.
+
+### Ветка назначения
+- [ ] dev (основная ветка разработки)
+- [ ] main (только для критических исправлений безопасности)
+
+### Тип изменений
+- [ ] Новая функциональность
+- [ ] Исправление ошибки
+- [ ] Рефакторинг
+- [ ] Документация
+- [ ] Другое
+
+### Чек-лист
+- [ ] Изменения протестированы локально
+- [ ] Документация обновлена (если требуется)
+- [ ] Нет лишних изменений в коде
+
+### Связанные задачи
+Укажите номер issue, если PR его закрывает (например: Closes #123).
@@ -43,7 +43,6 @@ database.db
 bot_old.py
 bot_old_2.py
 backup_pg.sh
-docker-compose.yml
 config copy.py
 handlers/texts.py

@@ -53,9 +52,12 @@ Thumbs.db

 nginx.conf
 scripts
-Dockerfile
 .csv
 /logs
 setup.py
 .ruff_cache
-.github/workflows/
+.github/workflows/
+modules/
+storage/
+
+.license_state
@@ -0,0 +1,25 @@
+# Code of Conduct
+
+## Общие правила
+
+- Уважайте друг друга. Недопустимы оскорбления, дискриминация или токсичное поведение.  
+- Обсуждения должны оставаться по теме и в конструктивной форме.  
+- Личные и конфиденциальные данные публиковать запрещено.  
+- Нарушения могут привести к предупреждению, ограничению участия или блокировке по усмотрению мейнтейнеров.  
+
+## Участники GitHub
+
+- Могут предлагать изменения через **Issues** и **Pull Requests**.  
+- Их вклад рассматривается и принимается по решению мейнтейнеров.  
+- Дискуссии ограничены рамками кода и технических вопросов.  
+
+## Участники сообщества в Telegram
+
+- Имеют приоритетное взаимодействие с разработчиком.  
+- Могут обсуждать проект шире: идеи, улучшения, новые направления.  
+- Влияние на развитие кода выше, чем у участников извне.  
+- Общение остаётся в рамках уважения и конструктивности.  
+
+## Контакты
+
+По вопросам поведения используйте Issues с меткой `conduct` или обращайтесь через сообщество в Telegram.
@@ -0,0 +1,29 @@
+# Contributing Guidelines
+
+Спасибо, что хотите внести вклад в развитие проекта!
+
+## Как помочь
+
+- Создавайте **Issues** для конкретных целей или описания найденных багов.  
+- Отправляйте **Pull Requests** с улучшениями и исправлениями. Каждое предложение будет рассмотрено, и мы примем решение о включении.  
+- Делайте **форки** репозитория и дорабатывайте код — лучшие практики мы обязательно объединим в общее дело.  
+
+## Стиль кода
+
+- Соблюдайте стандарт **PEP8**.  
+- Для автоматической проверки можно использовать **ruff**.  
+
+## Правила коммитов
+
+- Сообщения должны быть осмысленными и отражать суть изменений.  
+- Если в одном коммите несколько изменений, перечисляйте их через `/`.  
+
+## Лицензия
+
+Creative Commons Attribution-NonCommercial 4.0 International Public License © Vladless, 2024.
+
+By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.
+
+Внося изменения, вы соглашаетесь, что ваш вклад распространяется на условиях этой лицензии. Перепродажа или коммерческое распространение этого кода без явного письменного согласия правообладателя не допускаются.
+---
+Ваш вклад помогает проекту расти и становиться лучше.
@@ -0,0 +1,26 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    tzdata \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+COPY . .
+
+RUN rm -rf /app/venv \
+    && python -m venv /app/venv \
+    && /app/venv/bin/pip install --upgrade pip \
+    && /app/venv/bin/pip install -r requirements.txt
+
+RUN adduser --disabled-password --gecos "" appuser && chown -R appuser:appuser /app
+USER appuser
+
+CMD ["/app/venv/bin/python", "main.py"]
@@ -1,7 +1,10 @@
-formatting:
+format:
 	@echo "Running Ruff format..." && ruff format . --config pyproject.toml --exclude main.py,handlers/payments
-
 	@echo "Running Ruff..." && ruff check . --config pyproject.toml --exclude main.py,handlers/payments --fix

 lint:
-	@echo "Running Ruff checks..." && ruff check . --config pyproject.toml --exclude main.py,handlers/payments
+	@echo "Running Ruff checks..." && ruff check . --config pyproject.toml --exclude main.py,handlers/payments
+
+format-payments:
+	@echo "Running Ruff format ONLY on handlers/payments..." && ruff format handlers/payments --config pyproject.toml
+	@echo "Running Ruff check ONLY on handlers/payments..." && ruff check handlers/payments --config pyproject.toml --fix
@@ -1,87 +1,211 @@
-# 🚀 SoloBot
+<div align="center" style="max-width:980px;margin:0 auto;padding:0 12px">

-## **SoloBot** — ваш идеальный помощник для управления 3x-UI или Remnawave на протоколе VLESS.
+![IMG_1565](https://github.com/user-attachments/assets/71cfb259-9889-4066-8626-b804ae4cf7fb)

-<img src=".github/images/preview.gif" alt="SoloBot" width="1600">
+  <h1 style="margin:0;font-weight:900;letter-spacing:.3px">SoloBot</h1>
+  <p style="margin:6px 0 0;font-size:16px;opacity:.9"><b>Идеальный помощник для 3x-UI и Remnawave (VLESS)</b></p>

-# Описание

-## Бот, предоставляющий инструменты под различные реализации. Хорошая кастомизация и подстройка под свой бренд.
+  <p style="margin:16px 0 0">
+    <a href="https://pocomacho.ru/solonetbot/" target="_blank">
+      <img height="46" src="https://img.shields.io/badge/➡_Website-visit-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=firefox&logoColor=ff6a00" alt="Website">
+    </a>&nbsp;
+    <a href="https://t.me/SoloNetVPN_bot" target="_blank">
+      <img height="46" src="https://img.shields.io/badge/Try_in_Telegram-demo-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=telegram&logoColor=ff6a00" alt="Telegram">
+    </a>&nbsp;
+    <a href="https://pocomacho.ru/solonetbot/features" target="_blank">
+      <img height="46" src="https://img.shields.io/badge/Features-overview-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=readthedocs&logoColor=ff6a00" alt="Features">
+    </a>&nbsp;
+    <a href="https://github.com/Vladless/Solo_bot/releases" target="_blank">
+      <img height="46" src="https://img.shields.io/badge/Releases-history-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=github&logoColor=ff6a00" alt="Releases">
+    </a>
+  </p>

-## ⚙️ Основные возможности SoloBot
+  <p style="margin:10px 0 0">
+    <a href="LICENSE" target="_blank">
+      <img height="32" src="https://img.shields.io/badge/License-CC_BY--NC_4.0-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=creative-commons&logoColor=ff6a00" alt="License">
+    </a>
+  </p>

-| 📌 Раздел                        | 💡 Возможности                                                                                                                                                                                                                                                                                                                                                                                      |
-|----------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| **Мультипанель**                 | • Работа с панелями [3x-ui](https://github.com/MHSanaei/3x-ui) <br> • Работа с панелями [Remnawave](https://github.com/remnawave/panel) <br> • Работа в режиме совместимости (различные панели одновременно)                                                                                                                                                                                        |
-| **Управление подписками**        | • Выдача подписок на 1 / 3 / 6 / 12 месяцев или заданные сроки <br> • Пробный период на заданный период <br> • Продление ключей по тарифному плану <br> • Поддержка различных клиентов (Happ, Hiddify, v2RayTun) <br> • Кастомизируемые заголовки профилей                                                                                                                                          |
-| **Полный контроль над клиентом** | • Просмотр ключа, сервера и оставшегося времени через админку <br> • Продление и удаление ключей, начисление дней, отключение клиента <br> • Смена локации между серверами <br> • Поддержка нескольких устройств                                                                                                                                                                                    |
-| **Реферальная программа**        | • Уникальные ссылки для приглашений <br> • Инлайн-режим и обычные сообщения <br> • Награда: процент или фиксированная сумма за пополнение                                                                                                                                                                                                                                                           |
-| **UTM-аналитика**                | • Отслеживание рекламных переходов <br> • Привязка по рефералам, купонам, пробникам <br> • Анализ конверсий: регистрации, покупки, триалы <br> • Удалённый просмотр и контроль через админку                                                                                                                                                                                                        |
-| **Поддержка платёжных систем**   | • YooKassa (ИП / Самозанятые) <br> • YooMoney (Физ. лица) [@TrackLine](https://github.com/TrackLine) <br> • Robokassa (ИП) <br> • Cryptobot [@izzzzzi](https://github.com/izzzzzi) <br> • Telegram Stars <br> • Heleket (Физ. лица) [@JustYay](https://github.com/JustYay) <br> • Wata (Физ. лица) [@TrackLine](https://github.com/TrackLine) <br> • Kassai (Физ. лица) [@JustYay](https://github.com/JustYay)|
-| **Безопасность и стабильность**  | • Периодические бэкапы <br> • Смена домена в случае переезда <br> • Проверка доступности серверов <br> • Уведомление о недоступности сервера и его аптайм <br>                                                                                                                                                                                                                                      |
-| **Уведомления**                  | • Напоминания об истекающих подписках (24ч / 6ч / момент) <br> • Напоминания о неиспользованном трафике                                                                                                                                                                                                                                                                                             |
-| **Серверная часть**              | • Мультисерверность (добавление серверов в неограниченном количестве) <br> • Выдача в разных режимах (по одной локации или в формате подписки) <br> • Автопроверка доступности <br> • Балансировка нагрузки при выдаче ключей <br> • Синхронизация клиентов между серверами <br> • Ограничение максимального количества ключей на сервер <br> • Возможность включения/отключения отдельных серверов |
-| **Админ-панель**                 | • Поиск по TG ID / username / ключу / email <br> • Управление балансом, подписками, заморозками <br> • Перезагрузка, бан-лист <br> • Создание купонов, UTM, статистика                                                                                                                                                                                                                              |
-| **Кастомизация**                 | • Все функции бота кастомизируемы, вплоть до логики работы <br>                                                                                                                                                                                                                                                                                                                                     |
+  <hr style="height:1px;border:0;background:#222;margin:18px 0 16px">
+  <p><b>Многофункциональный бот, кастомизируемый под ваш бренд.</b></p>
+</div>

-<a href="https://pocomacho.ru/solonetbot/features" target="_blank">
-  <img src="https://img.shields.io/badge/Возможности_бота-перейти-ffa726?style=for-the-badge" />
-</a>

-## 🛠 Обновления
+<h2 align="center">Основные возможности</h2>

-### SoloBot регулярно получает новые функции и улучшения.
+<table align="center" style="max-width:980px;width:100%">
+  <tr>
+    <th align="left" style="width:30%">📌 Раздел</th>
+    <th align="left">💡 Возможности</th>
+  </tr>

-#### [➡ Все обновления и версии](https://github.com/Vladless/Solo_bot/releases)
+  <tr>
+    <td><b>Мультипанель</b></td>
+    <td>3x-ui<br>Remnawave<br>Совместимый режим</td>
+  </tr>

-# Наш сайт и полная версия
+  <tr>
+    <td><b>Подписки</b></td>
+    <td>Произвольный срок и триал<br>Продление по тарифу<br>Happ / Hiddify / v2RayTun<br>Кастом заголовков</td>
+  </tr>

-### Переходи на наш сайт!
-<h3>
+  <tr>
+    <td><b>Тарификация</b></td>
+    <td>Лимиты устройств<br>Лимиты трафика<br>Лимиты серверов в подписках</td>
+  </tr>
+
+  <tr>
+    <td><b>Клиент</b></td>
+    <td>Ключ / сервер / TTL<br>Продление / удаление / начисление дней / отключение<br>Смена локации<br>Несколько устройств</td>
+  </tr>
+
+  <tr>
+    <td><b>Поддержка роутеров</b></td>
+    <td>Выдача VLESS подписки за отдельную цену</td>
+  </tr>
+
+  <tr>
+    <td><b>Рефералы</b></td>
+    <td>Уникальные ссылки<br>Инлайн и обычные сообщения<br>% или фикс</td>
+  </tr>
+
+  <tr>
+    <td><b>UTM-аналитика</b></td>
+    <td>Трекинг переходов<br>Привязка к рефералам / купонам / триалам<br>Конверсии<br>Просмотр в админке</td>
+  </tr>
+
+  <tr>
+    <td><b>Оплата</b></td>
+    <td>YooKassa (ИП/Самозанятые)<br>YooMoney (Физ. лица) <a href="https://github.com/TrackLine">@TrackLine</a><br>Robokassa (ИП)<br>Telegram Stars<br>Heleket (Физ. лица) <a href="https://github.com/JustYay">@JustYay</a><br>Wata (Физ. лица) <a href="https://github.com/TrackLine">@TrackLine</a><br>Kassai (Физ. лица) <a href="https://github.com/JustYay">@JustYay</a><br>И другие <a href="https://pocomacho.ru/solonetbot/modules/">см. Модули</a></td>
+  </tr>
+
+  <tr>
+    <td><b>Валютность</b></td>
+    <td>Оплата в разных валютах</td>
+  </tr>
+
+  <tr>
+    <td><b>Надёжность</b></td>
+    <td>Бэкапы<br>Смена домена<br>Проверка доступности<br>Уведомления об аптайме</td>
+  </tr>
+
+  <tr>
+    <td><b>Уведомления</b></td>
+    <td>О скором окончании подписки<br>О непотраченном трафике</td>
+  </tr>
+
+  <tr>
+    <td><b>Рассылки</b></td>
+    <td>По заданным группам<br>С картинками или видео</td>
+  </tr>
+
+  <tr>
+    <td><b>Серверы</b></td>
+    <td>Мультисерверность<br>Одна локация или подписка<br>Автопроверка и балансировка<br>Синхронизация и лимиты<br>Вкл/выкл</td>
+  </tr>
+
+  <tr>
+    <td><b>Воронка продаж</b></td>
+    <td>Доп. дни к триалу: не взял триал → оффер → активация<br>Горячие лиды: платил → перестал → таргет/КП → возврат</td>
+  </tr>
+
+  <tr>
+    <td><b>Админка</b></td>
+    <td>Поиск TG/username/ключ/email<br>Баланс / подписки / заморозки<br>Перезагрузка<br>Бан-лист · купоны · UTM · статистика<br>Синхронизация / импорт из панели</td>
+  </tr>
+
+  <tr>
+    <td><b>Модульность</b></td>
+    <td>Подключаемые модули<br>Вкл/выкл и перезапуск из админки<br>Обновления и версии<br>Возможность дорабатывать код не теряя обновления</td>
+  </tr>
+
+  <tr>
+    <td><b>Кастомизация</b></td>
+    <td>Гибкая настройка функций и логики<br>Возможность отключения отдельных функций</td>
+  </tr>
+</table>
+
+<div style="height:22px"></div>
+<div style="height:1px;background:linear-gradient(90deg,rgba(0,0,0,0),#ff6a00,rgba(0,0,0,0));filter:drop-shadow(0 0 10px rgba(255,106,0,.6))"></div>
+<div style="height:22px"></div>
+
+<hr style="height:1px;border:0;background:#222;margin:18px 0 16px">
+
+<h2 align="center">Обновления</h2>
+<p align="center">Регулярные релизы. Обновление через CLI. Ветки: <code>main</code> — стабильные версии, <code>dev</code> — бета.</p>
+<p align="center">
+  <a href="https://github.com/Vladless/Solo_bot/releases" target="_blank">
+    <img height="46" src="https://img.shields.io/badge/➡_Все_версии-смотреть-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=github&logoColor=ff6a00" alt="Все версии">
+  </a>
+</p>
+
+<div style="height:22px"></div>
+<div style="height:1px;background:linear-gradient(90deg,rgba(0,0,0,0),#ff6a00,rgba(0,0,0,0));filter:drop-shadow(0 0 10px rgba(255,106,0,.6))"></div>
+<div style="height:22px"></div>
+
+<hr style="height:1px;border:0;background:#222;margin:18px 0 16px">
+
+<h2 align="center">Гайды и расширения</h2>
+<p align="center" style="max-width:900px;margin:8px auto 14px">
+  На сайте всегда лежат актуальные файлы для запуска разных версий бота. Есть собственное Wiki с пошаговыми инструкциями по установке и обновлениям. Доступна система модулей: бот легко дополняется готовыми расширениями и вашим кастомным функционалом.
+</p>
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/7d0a954d-41b7-4d7c-8618-aee1f4459792" alt="Guides" width="100%">
+</p>
+<p align="center">
  <a href="https://pocomacho.ru/solonetbot/" target="_blank">
-    <img src="https://img.shields.io/badge/➡_Сайт_SoloBot-перейти-ffa726?style=for-the-badge" alt="Сайт SoloNetBot">
-  </a>
-</h3>
-
-
-#### Всегда актуальные гайды по установке, файлы для запуска и ссылка на общий чат:
-
-![image](https://github.com/user-attachments/assets/fb0028cd-c588-4548-b290-a4bfcc96a3e1)
-
-<h3>
-  <a href="https://t.me/SoloNetVPN_bot" target="_blank">
-    <img src="https://img.shields.io/badge/Попробовать_SoloBot_в_Telegram-жми-ffa726?style=for-the-badge&logo=telegram" alt="Попробовать SoloBot в Telegram">
-  </a>
-</h3>
-
-## Отзывы пользователей:
-
-#### SoloBot уже помог сотням пользователей в нашем сообществе:
-
-![image](https://github.com/user-attachments/assets/597e6c4e-68be-4d8f-826b-35754c682a30)
-
-<h3>
+    <img height="44" src="https://img.shields.io/badge/➡_Сайт_SoloBot-перейти-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=firefox&logoColor=ff6a00" alt="Site">
+  </a>&nbsp;
  <a href="https://pocomacho.ru/solonetbot/reviews/" target="_blank">
-    <img src="https://img.shields.io/badge/Читать_отзывы-на_сайте-ffa726?style=for-the-badge&logo=discourse" alt="Читать отзывы">
+    <img height="44" src="https://img.shields.io/badge/Отзывы-на_сайте-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=discourse&logoColor=ff6a00" alt="Reviews">
  </a>
-</h3>
+</p>

-Связаться с нами через [**➡ поддержку**](https://t.me/solonet_sup). Там вы сможете купить полную версию и получить логин
-и пароль от сайта, получить доступ в наш чат сообщества, а также задать необходимые вопросы!
+<div style="height:22px"></div>
+<div style="height:1px;background:linear-gradient(90deg,rgba(0,0,0,0),#ff6a00,rgba(0,0,0,0));filter:drop-shadow(0 0 10px rgba(255,106,0,.6))"></div>
+<div style="height:22px"></div>
+<hr style="height:1px;border:0;background:#222;margin:18px 0 16px">

-## 🚨 Права на использование
+<h2 align="center">Полная версия</h2>
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/597e6c4e-68be-4d8f-826b-35754c682a30" alt="Community" width="100%">
+</p>
+<p align="center" style="max-width:900px;margin:8px auto 14px">
+  SoloBot уже помог более чем 500 пользователям из сообщества. Присоединяйтесь: попробуйте бота или напишите в поддержку, чтобы получить доступ и консультацию.
+</p>
+<p align="center">
+  <a href="https://t.me/SoloNetVPN_bot" target="_blank">
+    <img height="46" src="https://img.shields.io/badge/Попробовать_бота-открыть_Telegram-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=telegram&logoColor=ff6a00" alt="Try bot">
+  </a>&nbsp;
+  <a href="https://t.me/solonet_sup" target="_blank">
+    <img height="46" src="https://img.shields.io/badge/Написать_в_поддержку-получить_доступ-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=telegram&logoColor=ff6a00" alt="Support">
+  </a>
+</p>
+<hr style="height:1px;border:0;background:#222;margin:18px 0 16px">

-| ❗                                | **Этот проект распространяется по лицензии [CC BY-NC 4.0](LICENSE)** |
-|----------------------------------|----------------------------------------------------------------------|
-| ⛔ **Перепродажа кода запрещена** | Нельзя продавать или перепродавать код без разрешения автора.        |
-| ✅ **Для личного использования**  | Код можно использовать и модифицировать для личного использования.   |
+<h2 align="center">Лицензия</h2>
+<table align="center" style="max-width:900px;width:100%">
+  <tr>
+    <td style="width:8%;text-align:center">❗</td>
+    <td><b>Этот проект распространяется по лицензии <a href="LICENSE">CC BY-NC 4.0</a></b></td>
+  </tr>
+  <tr>
+    <td style="text-align:center">⛔</td>
+    <td><b>Перепродажа кода запрещена.</b> Нельзя продавать или перепродавать код без разрешения автора.</td>
+  </tr>
+  <tr>
+    <td style="text-align:center">✅</td>
+    <td><b>Для личного использования.</b> Код можно использовать и модифицировать для личных проектов.</td>
+  </tr>
+</table>
+<hr style="height:1px;border:0;background:#222;margin:18px 0 16px">
+
+<h2 align="center">Участники</h2>
+<p align="center">
+  <a href="https://github.com/Vladless/Solo_bot/graphs/contributors">
+    <img src="https://contrib.rocks/image?repo=Vladless/Solo_bot" alt="Contributors">
+  </a>
+</p>


-## Участники проекта
-
-Благодарим всех, кто помогает развивать SoloBot! 💖
-
-<a href="https://github.com/Vladless/Solo_bot/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=Vladless/Solo_bot" />
-</a>
-
@@ -0,0 +1,32 @@
+# Security Policy
+
+## Поддерживаемые ветки
+- Рассматриваются только `main` (последняя стабильная) и `dev` (текущая разработка).  
+- Другие ветки и теги не поддерживаются.  
+
+## Как сообщить об уязвимости
+- Не создавайте публичные Issues или Pull Requests.  
+- Сообщите напрямую владельцу: [@solonet_sup](https://t.me/solonet_sup).  
+- Также можно уведомить через сообщество в Telegram (доступно после вступления).  
+- Укажите: ветку (`main`/`dev`), версию/коммит, шаги воспроизведения, ожидаемое и фактическое поведение, возможное влияние, логи или скриншоты.  
+
+## Процесс
+1. Подтверждаем получение отчёта.  
+2. Анализируем и определяем критичность.  
+3. Исправления выпускаются в `dev`.  
+4. Если уязвимость критическая — фикс публикуется напрямую в `main`.  
+5. После релиза уведомляем сообщество и при необходимости публикуем рекомендации по обновлению.  
+
+## Область действия
+- Бот (aiogram), веб-админка (flask), внутренние модули/плагины и API проекта.  
+- Вне области: сторонние сервисы и библиотеки (платёжные провайдеры, Telegram, панели и т. п.). Для них обращайтесь к поставщику напрямую.  
+
+## Ответственное раскрытие
+- Просим не публиковать детали до выхода исправления.  
+- Тесты проводите только на своих данных и аккаунтах.  
+- Атаки на инфраструктуру или пользователей строго запрещены.  
+
+## Лучшие практики при отчёте
+- Минимальный PoC без риска для данных и доступности.  
+- Чёткие и воспроизводимые шаги.  
+- Возможные предложения по снижению риска до исправления.  
@@ -1,15 +1,50 @@
-from fastapi import FastAPI
-from api.routes import users, keys, coupons, servers, tariffs, gifts, referrals, misc
+from time import perf_counter
+
+from fastapi import FastAPI, Request
+from api.routes import (
+    users,
+    keys,
+    coupons,
+    servers,
+    tariffs,
+    gifts,
+    referrals,
+    misc,
+    partners,
+    modules,
+    management,
+    settings,
+)
+from config import API_LOGGING
+from logger import logger

 app = FastAPI(
-    title="SoloBot API (preAlpha)",
-    version="0.2.0",
-    docs_url="/api/docs",           
-    redoc_url="/api/redoc",         
-    openapi_url="/api/openapi.json" 
+    title="SoloBot API (Alpha)",
+    version="0.5.2",
+    docs_url="/api/docs",
+    redoc_url="/api/redoc",
+    openapi_url="/api/openapi.json",
 )


+@app.middleware("http")
+async def api_access_log_middleware(request: Request, call_next):
+    if not API_LOGGING:
+        return await call_next(request)
+
+    started = perf_counter()
+    response = await call_next(request)
+    duration_ms = int((perf_counter() - started) * 1000)
+    client_ip = request.client.host if request.client else "-"
+    path_qs = request.url.path
+    if request.url.query:
+        path_qs = f"{path_qs}?{request.url.query}"
+
+    logger.info(
+        f'[API] {client_ip} "{request.method} {path_qs}" {response.status_code} {duration_ms}ms'
+    )
+    return response
+
 app.include_router(users.router, prefix="/api/users", tags=["Users"])
 app.include_router(keys.router, prefix="/api/keys", tags=["Keys"])
 app.include_router(coupons.router, prefix="/api/coupons", tags=["Coupons"])
@@ -17,7 +52,11 @@ app.include_router(servers.router, prefix="/api/servers", tags=["Servers"])
 app.include_router(tariffs.router, prefix="/api/tariffs", tags=["Tariffs"])
 app.include_router(gifts.router, prefix="/api/gifts", tags=["Gifts"])
 app.include_router(referrals.router, prefix="/api/referrals", tags=["Referrals"])
+app.include_router(partners.router, prefix="/api/partners", tags=["Partners"])
 app.include_router(misc.router, prefix="/api")
+app.include_router(modules.router, prefix="/api")
+app.include_router(management.router, prefix="/api/management", tags=["Management"])
+app.include_router(settings.router, prefix="/api/settings", tags=["Settings"])


@app.get("/api", include_in_schema=False)
@@ -1,6 +1,6 @@
-from typing import Any, Type, Union
+from typing import Any

-from fastapi import APIRouter, Depends, HTTPException, Path, Query
+from fastapi import APIRouter, Body, Depends, HTTPException, Path, Query
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm.attributes import InstrumentedAttribute
@@ -9,13 +9,23 @@ from api.depends import get_session, verify_admin_token
 from database.models import Admin


-def _cast_identifier_type(field: InstrumentedAttribute, value: int | str):
+def cast_identifier_type(field: InstrumentedAttribute, value: int | str):
    column_type = type(field.property.columns[0].type).__name__
    if column_type in ("Integer", "BigInteger"):
        return int(value)
    return value


+def normalize_outgoing_object(obj: object) -> None:
+    if hasattr(obj, "vless") and getattr(obj, "vless") is None:
+        setattr(obj, "vless", False)
+
+
+def to_schema(schema_response: type, obj: object):
+    normalize_outgoing_object(obj)
+    return schema_response.model_validate(obj, from_attributes=True)
+
+
 def generate_crud_router(
    *,
    model: type,
@@ -37,7 +47,10 @@ def generate_crud_router(
            session: AsyncSession = Depends(get_session),
        ):
            result = await session.execute(select(model))
-            return result.scalars().all()
+            items = result.scalars().all()
+            for item in items:
+                normalize_outgoing_object(item)
+            return [schema_response.model_validate(item, from_attributes=True) for item in items]

    if "get_by_email" in enabled_methods and extra_get_by_email:

@@ -51,7 +64,7 @@ def generate_crud_router(
            obj = result.scalar_one_or_none()
            if not obj:
                raise HTTPException(status_code=404, detail="Not found by email")
-            return obj
+            return to_schema(schema_response, obj)

    if "get_one" in enabled_methods:

@@ -62,12 +75,12 @@ def generate_crud_router(
            session: AsyncSession = Depends(get_session),
        ):
            field = getattr(model, identifier_field)
-            casted = _cast_identifier_type(field, value)
+            casted = cast_identifier_type(field, value)
            result = await session.execute(select(model).where(field == casted))
            obj = result.scalar_one_or_none()
            if not obj:
                raise HTTPException(status_code=404, detail=f"{model.__name__} not found")
-            return obj
+            return to_schema(schema_response, obj)

    if "get_all_by_field" in enabled_methods:

@@ -78,52 +91,56 @@ def generate_crud_router(
            session: AsyncSession = Depends(get_session),
        ):
            field = getattr(model, identifier_field)
-            casted = _cast_identifier_type(field, value)
+            casted = cast_identifier_type(field, value)
            result = await session.execute(select(model).where(field == casted))
            objs = result.scalars().all()
            if not objs:
                raise HTTPException(status_code=404, detail=f"{model.__name__} not found")
-            return objs
+            for obj in objs:
+                normalize_outgoing_object(obj)
+            return [schema_response.model_validate(obj, from_attributes=True) for obj in objs]

    if "create" in enabled_methods:

        @router.post("/", response_model=schema_response)
        async def create(
-            payload: schema_create,  # type: ignore
+            payload: Any = Body(...),
            admin: Admin = Depends(verify_admin_token),
            session: AsyncSession = Depends(get_session),
        ):
-            data = payload.dict(exclude_unset=True)
+            validated = schema_create.model_validate(payload)
+            data = validated.model_dump(exclude_unset=True)
            if "days" in data and data["days"] == 0:
                data["days"] = None
            obj = model(**data)
            session.add(obj)
            await session.commit()
            await session.refresh(obj)
-            return obj
+            return to_schema(schema_response, obj)

    if "update" in enabled_methods:

        @router.patch(f"/{{{parameter_name}}}", response_model=schema_response)
        async def update(
-            payload: schema_update,  # type: ignore
+            payload: Any = Body(...),
            value: int | str = Path(..., alias=parameter_name),
            admin: Admin = Depends(verify_admin_token),
            session: AsyncSession = Depends(get_session),
        ):
            field = getattr(model, identifier_field)
-            casted = _cast_identifier_type(field, value)
+            casted = cast_identifier_type(field, value)
            result = await session.execute(select(model).where(field == casted))
            obj = result.scalar_one_or_none()
            if not obj:
                raise HTTPException(status_code=404, detail=f"{model.__name__} not found")

-            for k, v in payload.dict(exclude_unset=True).items():
+            validated = schema_update.model_validate(payload)
+            for k, v in validated.model_dump(exclude_unset=True).items():
                setattr(obj, k, v)

            await session.commit()
            await session.refresh(obj)
-            return obj
+            return to_schema(schema_response, obj)

    if "delete" in enabled_methods:

@@ -134,7 +151,7 @@ def generate_crud_router(
            session: AsyncSession = Depends(get_session),
        ):
            field = getattr(model, identifier_field)
-            casted = _cast_identifier_type(field, value)
+            casted = cast_identifier_type(field, value)
            result = await session.execute(select(model).where(field == casted))
            obj = result.scalar_one_or_none()
            if not obj:
@@ -1,5 +1,5 @@
 from fastapi import APIRouter, Depends, HTTPException, Path
-from sqlalchemy import select
+from sqlalchemy import delete, select
 from sqlalchemy.ext.asyncio import AsyncSession

 from api.depends import get_session, verify_admin_token
@@ -18,7 +18,7 @@ gift_router = generate_crud_router(
    schema_update=GiftUpdate,
    identifier_field="gift_id",
    parameter_name="gift_id",
-    enabled_methods=["get_all", "get_one", "create", "update", "delete"],
+    enabled_methods=["get_all", "get_one", "create", "update"],
 )
 router.include_router(gift_router, prefix="", tags=["Gifts"])

@@ -46,3 +46,20 @@ gift_usage_router = generate_crud_router(
 )
 router.include_router(gift_usage_router, prefix="/usages", tags=["GiftUsages"])
 router.include_router(gift_usage_router, prefix="/usages", tags=["Gifts"])
+
+
+@router.delete("/{gift_id}", response_model=dict, tags=["Gifts"])
+async def delete_gift_with_usages(
+    gift_id: str = Path(..., description="ID подарка"),
+    admin: Admin = Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(Gift).where(Gift.gift_id == gift_id))
+    gift = result.scalar_one_or_none()
+    if not gift:
+        raise HTTPException(status_code=404, detail="Gift not found")
+
+    await session.execute(delete(GiftUsage).where(GiftUsage.gift_id == gift_id))
+    await session.delete(gift)
+    await session.commit()
+    return {"message": "Подарок и связанные использования удалены"}
@@ -8,7 +8,7 @@ from api.depends import get_session, verify_admin_token
 from api.routes.base_crud import generate_crud_router
 from api.schemas.keys import KeyBase, KeyCreateRequest, KeyResponse, KeyUpdate
 from database.models import Admin, Key, Tariff
-from handlers.keys.key_utils import create_key_on_cluster, delete_key_from_cluster, renew_key_in_cluster
+from handlers.keys.operations import create_key_on_cluster, delete_key_from_cluster, renew_key_in_cluster
 from logger import logger


@@ -0,0 +1,219 @@
+import os
+import re
+import subprocess
+import sys
+import asyncio
+from typing import Literal
+
+import psutil
+from aiogram import Bot
+from aiogram.client.default import DefaultBotProperties
+from aiogram.enums import ParseMode
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import distinct, exists, func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.depends import get_session, verify_admin_token
+from config import API_TOKEN
+from core.bootstrap import MANAGEMENT_CONFIG
+from core.settings.management_config import update_management_config
+from database.models import Key, User
+from database.models import Server
+from handlers.admin.sender.sender_service import BroadcastService
+from handlers.admin.sender.sender_utils import get_recipients, parse_message_buttons
+from logger import logger
+from utils.backup import backup_database
+
+
+router = APIRouter()
+
+
+class MaintenanceUpdate(BaseModel):
+    enabled: bool
+
+
+class DomainChange(BaseModel):
+    domain: str
+
+
+class BroadcastLaunchPayload(BaseModel):
+    send_to: Literal["all", "subscribed", "unsubscribed", "untrial", "trial", "hotleads", "cluster"] = "all"
+    text: str
+    photo: str | None = None
+    cluster_name: str | None = None
+    workers: int = 5
+    messages_per_second: int = 35
+
+
+_broadcast_bot: Bot | None = None
+
+
+def _get_broadcast_bot() -> Bot:
+    global _broadcast_bot
+    if _broadcast_bot is None:
+        _broadcast_bot = Bot(token=API_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
+    return _broadcast_bot
+
+
+async def _restart_bot() -> None:
+    await asyncio.sleep(1)
+    try:
+        parent = psutil.Process(os.getpid()).parent()
+        is_systemd = parent and "systemd" in parent.name().lower()
+
+        if is_systemd:
+            subprocess.run(
+                ["sudo", "systemctl", "restart", "bot.service"],
+                check=True,
+            )
+        else:
+            python_exe = sys.executable
+            script_path = os.path.abspath(sys.argv[0])
+            os.execv(python_exe, [python_exe, script_path] + sys.argv[1:])
+    except Exception:
+        os._exit(1)
+
+
+@router.get("/status")
+async def get_status(admin=Depends(verify_admin_token)):
+    return {
+        "maintenance_enabled": bool(MANAGEMENT_CONFIG.get("MAINTENANCE_ENABLED", False)),
+        "management": dict(MANAGEMENT_CONFIG or {}),
+    }
+
+
+@router.post("/maintenance")
+async def set_maintenance(
+    payload: MaintenanceUpdate,
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    current_config = dict(MANAGEMENT_CONFIG or {})
+    current_config["MAINTENANCE_ENABLED"] = bool(payload.enabled)
+    await update_management_config(session, current_config)
+    return {"maintenance_enabled": bool(MANAGEMENT_CONFIG.get("MAINTENANCE_ENABLED", False))}
+
+
+@router.post("/restart")
+async def restart_bot(
+    background: BackgroundTasks,
+    admin=Depends(verify_admin_token),
+):
+    background.add_task(_restart_bot)
+    return {"status": "restarting"}
+
+
+@router.post("/change-domain")
+async def change_domain(
+    payload: DomainChange,
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    domain = payload.domain.strip()
+    if not domain or " " in domain or not re.fullmatch(r"[a-zA-Z0-9.-]+", domain):
+        raise HTTPException(status_code=400, detail="Invalid domain")
+
+    new_domain_url = f"https://{domain}"
+
+    stmt = (
+        update(Key)
+        .values(
+            key=func.regexp_replace(Key.key, r"^https://[^/]+", new_domain_url),
+            remnawave_link=func.regexp_replace(Key.remnawave_link, r"^https://[^/]+", new_domain_url),
+        )
+        .where(
+            (Key.key.startswith("https://") & ~Key.key.startswith(new_domain_url))
+            | (Key.remnawave_link.startswith("https://") & ~Key.remnawave_link.startswith(new_domain_url))
+        )
+    )
+    result = await session.execute(stmt)
+    await session.commit()
+
+    return {"updated": result.rowcount or 0}
+
+
+@router.post("/restore-trials")
+async def restore_trials(
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    stmt = (
+        update(User)
+        .where(
+            User.trial == 1,
+            ~exists(select(Key.tg_id).where(Key.tg_id == User.tg_id)),
+        )
+        .values(trial=0)
+    )
+    result = await session.execute(stmt)
+    await session.commit()
+
+    return {"restored": result.rowcount or 0}
+
+
+@router.post("/backup")
+async def trigger_backup(admin=Depends(verify_admin_token)):
+    async def _run_backup() -> None:
+        exception = await backup_database()
+        if exception:
+            logger.error(f"[Management] Backup finished with error: {exception}")
+
+    asyncio.create_task(_run_backup())
+    return {"status": "backup_started"}
+
+
+@router.get("/broadcast/clusters")
+async def get_broadcast_clusters(
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(distinct(Server.cluster_name)).where(Server.cluster_name.is_not(None)))
+    clusters = sorted([row[0] for row in result.all() if row and row[0]])
+    return {"clusters": clusters}
+
+
+@router.post("/broadcast")
+async def launch_broadcast(
+    payload: BroadcastLaunchPayload,
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    text_raw = (payload.text or "").strip()
+    if not text_raw:
+        raise HTTPException(status_code=400, detail="Broadcast text is required")
+
+    if payload.send_to == "cluster" and not (payload.cluster_name or "").strip():
+        raise HTTPException(status_code=400, detail="Cluster name is required for cluster broadcast")
+
+    clean_text, keyboard = parse_message_buttons(text_raw)
+
+    max_len = 1024 if payload.photo else 4096
+    if len(clean_text) > max_len:
+        raise HTTPException(status_code=400, detail=f"Message too long. Max {max_len} symbols")
+
+    tg_ids, total_users = await get_recipients(session, payload.send_to, (payload.cluster_name or None))
+    if not tg_ids:
+        return {"success": False, "message": "No recipients found", "stats": {"total_messages": 0}}
+
+    bot = _get_broadcast_bot()
+    messages = [
+        {
+            "tg_id": tg_id,
+            "text": clean_text,
+            "photo": payload.photo,
+            "keyboard": keyboard,
+        }
+        for tg_id in tg_ids
+    ]
+
+    workers = max(1, min(int(payload.workers or 5), 30))
+    rate = max(1, min(int(payload.messages_per_second or 35), 60))
+    broadcast_service = BroadcastService(bot=bot, session=session, messages_per_second=rate)
+    stats = await broadcast_service.broadcast(messages, workers=workers)
+    return {
+        "success": True,
+        "message": "Broadcast completed",
+        "recipients": total_users,
+        "stats": stats,
+    }
@@ -9,17 +9,16 @@ from api.schemas import (
    ManualBanResponse,
    NotificationResponse,
    PaymentResponse,
-    ReferralResponse,
    TemporaryDataResponse,
    TrackingSourceResponse,
 )
+from database import get_tracking_source_stats
 from database.models import (
    Admin,
    BlockedUser,
    ManualBan,
    Notification,
    Payment,
-    Referral,
    TemporaryData,
    TrackingSource,
 )
@@ -55,20 +54,6 @@ async def get_payments_by_tg_id(
    return payments


-router.include_router(
-    generate_crud_router(
-        model=Referral,
-        schema_response=ReferralResponse,
-        schema_create=None,
-        schema_update=None,
-        identifier_field="referred_tg_id",
-        enabled_methods=["get_all", "get_one", "delete"],
-    ),
-    prefix="/referrals",
-    tags=["Referrals"],
-    dependencies=[Depends(verify_admin_token)],
-)
-
 router.include_router(
    generate_crud_router(
        model=Notification,
@@ -133,9 +118,38 @@ router.include_router(
        schema_create=None,
        schema_update=None,
        identifier_field="id",
-        enabled_methods=["get_all", "get_one", "delete"],
+        enabled_methods=["get_all", "delete"],
    ),
    prefix="/tracking-sources",
    tags=["TrackingSources"],
    dependencies=[Depends(verify_admin_token)],
 )
+
+
+@router.get(
+    "/tracking-sources/{code}", response_model=TrackingSourceResponse, dependencies=[Depends(verify_admin_token)]
+)
+async def get_tracking_source_with_stats(
+    code: str,
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(TrackingSource).where(TrackingSource.code == code))
+    source = result.scalar_one_or_none()
+    if not source:
+        raise HTTPException(status_code=404, detail="Tracking source not found")
+
+    stats = await get_tracking_source_stats(session, code)
+
+    return TrackingSourceResponse(
+        id=source.id,
+        name=source.name,
+        code=source.code,
+        type=source.type,
+        created_by=source.created_by,
+        created_at=source.created_at,
+        registrations=(stats["registrations"] if stats else 0),
+        trials=(stats["trials"] if stats else 0),
+        payments=(stats["payments"] if stats else 0),
+        total_amount=(float(stats["total_amount"]) if stats else 0.0),
+        monthly=(stats["monthly"] if stats and "monthly" in stats else []),
+    )
@@ -0,0 +1,124 @@
+import pkgutil
+from pathlib import Path
+from typing import Literal
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from api.depends import verify_admin_token
+from utils.modules_loader import _is_safe_module_name
+from utils.modules_manager import manager
+
+
+router = APIRouter(prefix="/modules", tags=["Modules"])
+
+
+MODULES_DIR = Path(__file__).resolve().parents[2] / "modules"
+
+
+class ModuleAction(BaseModel):
+    action: Literal["start", "stop", "restart"]
+
+
+def _available_module_names() -> list[str]:
+    candidates: set[str] = set()
+    if MODULES_DIR.is_dir():
+        for _finder, name, _ispkg in pkgutil.iter_modules([str(MODULES_DIR)]):
+            name = (name or "").strip()
+            if name and _is_safe_module_name(name):
+                candidates.add(name)
+
+    return sorted(n for n in candidates if _is_safe_module_name(n))
+
+
+def _prune_missing_state(installed: set[str]) -> None:
+    changed = False
+
+    stale_disabled = {name for name in manager.disabled if name not in installed}
+    if stale_disabled:
+        for name in stale_disabled:
+            manager.disabled.discard(name)
+        changed = True
+
+    stale_registry = [name for name in list(manager.registry.keys()) if name not in installed]
+    if stale_registry:
+        for name in stale_registry:
+            manager.registry.pop(name, None)
+        changed = True
+
+    if changed:
+        save_state = getattr(manager, "_save_state", None)
+        if callable(save_state):
+            save_state()
+
+
+def _module_state(name: str) -> dict:
+    normalized = name.strip()
+    record = manager.registry.get(normalized)
+    is_enabled = manager.is_enabled(normalized)
+    return {
+        "name": normalized,
+        "enabled": is_enabled,
+        "loaded": bool(record and record.enabled),
+        "autostart": manager.should_autostart(normalized),
+    }
+
+
+def _read_local_module_version(name: str) -> str | None:
+    version_file = MODULES_DIR / name / "VERSION"
+    if not version_file.exists() or not version_file.is_file():
+        return None
+
+    try:
+        with version_file.open("r", encoding="utf-8") as handle:
+            for line in handle:
+                value = line.strip()
+                if value:
+                    return value
+    except Exception:
+        return None
+    return None
+
+
+@router.get("/")
+async def list_modules(admin=Depends(verify_admin_token)):
+    refresh = getattr(manager, "refresh_state", None)
+    if callable(refresh):
+        refresh()
+    else:
+        legacy_refresh = getattr(manager, "_load_state", None)
+        if callable(legacy_refresh):
+            legacy_refresh()
+    module_names = _available_module_names()
+    _prune_missing_state(set(module_names))
+    modules = [_module_state(name) for name in module_names]
+
+    for item in modules:
+        name = str(item.get("name") or "").strip()
+        local_version = _read_local_module_version(name)
+        item["local_version"] = local_version
+
+    return {"items": modules}
+
+
+@router.post("/{module_name}/actions")
+async def control_module(module_name: str, payload: ModuleAction, admin=Depends(verify_admin_token)):
+    name = (module_name or "").strip()
+    if not _is_safe_module_name(name):
+        raise HTTPException(status_code=404, detail="Module not found")
+
+    try:
+        if payload.action == "start":
+            await manager.start(name)
+        elif payload.action == "stop":
+            await manager.stop(name)
+        elif payload.action == "restart":
+            await manager.restart(name)
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported action")
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+    return {"item": _module_state(name)}
@@ -0,0 +1,962 @@
+from datetime import datetime
+import csv
+from io import StringIO
+
+from fastapi import APIRouter, Depends, Path, Query
+from fastapi.responses import JSONResponse, StreamingResponse
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.depends import get_session, verify_admin_token
+
+try:
+    from modules.partner_program.settings import PARTNER_BONUS_PERCENTAGES
+except Exception:
+    PARTNER_BONUS_PERCENTAGES = {1: 0.0}
+
+
+router = APIRouter()
+
+
+def _parse_percent(value: float) -> float | None:
+    """Normalize percent input to 0-100 range."""
+    try:
+        val = float(value)
+    except (TypeError, ValueError):
+        return None
+
+    if 0.0 <= val <= 1.0:
+        val *= 100.0
+
+    if 0.0 <= val <= 100.0:
+        return val
+    return None
+
+
+def _default_partner_percent() -> float:
+    try:
+        return float(PARTNER_BONUS_PERCENTAGES.get(1, 0.0)) * 100.0
+    except Exception:
+        return 0.0
+
+
+def _row_dt_iso(value) -> str | None:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    return None
+
+
+@router.get("/all")
+async def get_all_partners(
+    limit: int = Query(1000, ge=1, le=10000, description="Лимит результатов"),
+    offset: int = Query(0, ge=0, description="Смещение"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Возвращает список всех партнёров со статистикой.
+
+    Структура ответа:
+    {
+      "total": int,
+      "items": [
+        {
+          "tg_id": int,
+          "balance": float,
+          "percent": float,
+          "code": str | None,
+          "method": str | None,
+          "referred_count": int
+        }
+      ]
+    }
+    """
+
+    partners_sql = text(
+        """
+        SELECT 
+            p.partner_tg_id AS tg_id,
+            COALESCE(u.partner_balance, 0) AS partner_balance,
+            u.partner_percent,
+            COALESCE(u.partner_percent_custom, false) AS partner_percent_custom,
+            u.partner_code,
+            u.payout_method,
+            COUNT(p.joined_tg_id) as joined_count
+        FROM partners p
+        LEFT JOIN users u ON u.tg_id = p.partner_tg_id
+        WHERE p.partner_tg_id IS NOT NULL
+        GROUP BY p.partner_tg_id, u.partner_balance, u.partner_percent, u.partner_percent_custom, u.partner_code, u.payout_method
+        ORDER BY partner_balance DESC
+        LIMIT :limit OFFSET :offset
+        """
+    )
+
+    count_sql = text(
+        """
+        SELECT COUNT(DISTINCT partner_tg_id) FROM partners
+        WHERE partner_tg_id IS NOT NULL
+        """
+    )
+
+    result = await session.execute(partners_sql, {"limit": limit, "offset": offset})
+    partners = result.fetchall()
+
+    count_result = await session.execute(count_sql)
+    total = count_result.scalar() or 0
+
+    partners_list = []
+    default_percent = _default_partner_percent()
+    for partner in partners:
+        percent_value = partner[2]
+        percent_custom = bool(partner[3])
+        if percent_custom and percent_value is not None:
+            percent = float(percent_value)
+        else:
+            percent = float(default_percent)
+
+        partners_list.append({
+            "tg_id": int(partner[0]),
+            "balance": float(partner[1] or 0),
+            "percent": percent,
+            "code": partner[4] or None,
+            "method": partner[5] or None,
+            "referred_count": int(partner[6] or 0),
+        })
+
+    return JSONResponse(content={"total": total, "items": partners_list})
+
+
+@router.get("/stats/all")
+async def get_partners_stats(
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Возвращает общую статистику партнёрской программы.
+
+    Структура ответа:
+    {
+      "total_partners": int,
+            "partners_today": int,
+      "total_referred": int,
+      "total_balance": float,
+      "top_partner_tg_id": int,
+      "top_partner_refs": int
+    }
+    """
+
+    stats_sql = text(
+        """
+        WITH partner_refs AS (
+            SELECT partner_tg_id, COUNT(DISTINCT joined_tg_id) AS ref_count
+            FROM partners
+            WHERE partner_tg_id IS NOT NULL
+            GROUP BY partner_tg_id
+        )
+        SELECT 
+            (SELECT COUNT(*) FROM partner_refs) AS total_partners,
+            (
+                SELECT COUNT(DISTINCT partner_tg_id)
+                FROM partners
+                WHERE partner_tg_id IS NOT NULL
+                  AND DATE(created_at) = CURRENT_DATE
+            ) AS partners_today,
+            (SELECT COUNT(DISTINCT joined_tg_id) FROM partners WHERE partner_tg_id IS NOT NULL) AS total_referred,
+            (
+                SELECT COALESCE(SUM(u.partner_balance), 0.0)
+                FROM users u
+                WHERE u.tg_id IN (SELECT partner_tg_id FROM partner_refs)
+            ) AS total_balance,
+            (SELECT partner_tg_id FROM partner_refs ORDER BY ref_count DESC LIMIT 1) AS top_partner_tg_id,
+            (SELECT ref_count FROM partner_refs ORDER BY ref_count DESC LIMIT 1) AS top_partner_refs
+        """
+    )
+
+    stats_result = await session.execute(stats_sql)
+    stats_row = stats_result.fetchone()
+
+    if stats_row:
+        stats = {
+            "total_partners": int(stats_row[0] or 0),
+            "partners_today": int(stats_row[1] or 0),
+            "total_referred": int(stats_row[2] or 0),
+            "total_balance": float(stats_row[3] or 0.0),
+            "top_partner_tg_id": int(stats_row[4] or 0),
+            "top_partner_refs": int(stats_row[5] or 0),
+        }
+    else:
+        stats = {
+            "total_partners": 0,
+            "partners_today": 0,
+            "total_referred": 0,
+            "total_balance": 0.0,
+            "top_partner_tg_id": 0,
+            "top_partner_refs": 0,
+        }
+
+    return JSONResponse(content=stats)
+
+
+@router.patch("/{tg_id}")
+async def update_partner(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    balance: float = Query(..., description="Новый баланс партнёра"),
+    percent: float = Query(..., description="Новый процент партнёра"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Обновляет данные партнёра (баланс и процент).
+
+    Структура ответа:
+    {
+      "success": bool,
+      "message": str
+    }
+    """
+
+    try:
+        stmt = text(
+            """
+            UPDATE users 
+            SET partner_balance = :balance, partner_percent = :percent 
+            WHERE tg_id = :tg_id
+            """
+        )
+
+        result = await session.execute(stmt, {"tg_id": tg_id, "balance": balance, "percent": percent})
+        await session.commit()
+
+        if result.rowcount > 0:
+            return JSONResponse(
+                content={"success": True, "message": f"Партнёр {tg_id} успешно обновлён"},
+                status_code=200,
+            )
+        else:
+            return JSONResponse(
+                content={"success": False, "message": "Партнёр не найден"},
+                status_code=404,
+            )
+    except Exception as e:
+        await session.rollback()
+        return JSONResponse(
+            content={"success": False, "message": str(e)},
+            status_code=500,
+        )
+
+
+@router.get("/{tg_id}")
+async def get_partner_data(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Возвращает партнёрские данные для указанного `tg_id`.
+
+    Структура ответа:
+    {
+      "tg_id": int,
+      "partner_balance": float,
+      "partner_percent": float,
+      "partner_code": str | None,
+      "payout_method": str | None,
+      "invited": [
+        { "tg_id": int, "joined_at": str | None, "balance": float, "subs_count": int, "payments_count": int }
+      ]
+    }
+    """
+
+    meta_sql = text(
+        """
+        SELECT 
+            COALESCE(u.partner_balance, 0) AS partner_balance,
+            u.partner_percent,
+            COALESCE(u.partner_percent_custom, false) AS partner_percent_custom,
+            u.partner_code,
+            u.payout_method
+        FROM users u
+        WHERE u.tg_id = :tg_id
+        """
+    )
+
+    invited_sql = text(
+        """
+        SELECT 
+            pr.joined_tg_id,
+            pr.created_at,
+            COALESCE(u.balance, 0) AS user_balance,
+            (
+                SELECT COUNT(*) FROM keys k 
+                WHERE k.tg_id = pr.joined_tg_id
+            ) AS subs_count,
+            (
+                SELECT COUNT(*) FROM payments pay 
+                WHERE pay.tg_id = pr.joined_tg_id 
+                  AND lower(pay.status) = 'success'
+            ) AS payments_count
+        FROM partners pr
+        LEFT JOIN users u ON u.tg_id = pr.joined_tg_id
+        WHERE pr.partner_tg_id = :tg_id
+        ORDER BY pr.created_at DESC
+        """
+    )
+
+    meta_res = await session.execute(meta_sql, {"tg_id": tg_id})
+    meta_row = meta_res.fetchone()
+
+    invited_res = await session.execute(invited_sql, {"tg_id": tg_id})
+    invited_rows = invited_res.fetchall()
+
+    default_percent = _default_partner_percent()
+    percent = default_percent
+    if meta_row:
+        percent_value = meta_row[1]
+        percent_custom = bool(meta_row[2])
+        if percent_custom and percent_value is not None:
+            percent = float(percent_value)
+
+    response = {
+        "tg_id": tg_id,
+        "partner_balance": float(meta_row[0] or 0) if meta_row else 0.0,
+        "partner_percent": percent,
+        "partner_code": meta_row[3] if meta_row else None,
+        "payout_method": meta_row[4] if meta_row else None,
+        "invited": [
+            {
+                "tg_id": row[0],
+                "joined_at": row[1].isoformat() if isinstance(row[1], datetime) else None,
+                "balance": float(row[2] or 0),
+                "subs_count": int(row[3] or 0),
+                "payments_count": int(row[4] or 0),
+            }
+            for row in invited_rows
+        ],
+    }
+
+    return JSONResponse(content=response)
+
+
+@router.post("/{tg_id}/invited")
+async def add_partner_invited(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    joined_tg_id: int = Query(..., description="Telegram ID приглашённого"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Добавляет приглашённого пользователю партнёра."""
+
+    if joined_tg_id == tg_id:
+        return JSONResponse(
+            content={"success": False, "message": "Нельзя привязать пользователя к самому себе"},
+            status_code=400,
+        )
+
+    try:
+        partner_exists = await session.execute(
+            text("SELECT 1 FROM users WHERE tg_id = :tg_id"),
+            {"tg_id": tg_id},
+        )
+        if not partner_exists.scalar():
+            return JSONResponse(
+                content={"success": False, "message": "Партнёр не найден"},
+                status_code=404,
+            )
+
+        invited_exists = await session.execute(
+            text("SELECT 1 FROM users WHERE tg_id = :joined_tg_id"),
+            {"joined_tg_id": joined_tg_id},
+        )
+        if not invited_exists.scalar():
+            return JSONResponse(
+                content={"success": False, "message": "Приглашённый пользователь не найден"},
+                status_code=404,
+            )
+
+        existing = await session.execute(
+            text("SELECT partner_tg_id FROM partners WHERE joined_tg_id = :joined_tg_id"),
+            {"joined_tg_id": joined_tg_id},
+        )
+        existing_partner = existing.scalar()
+        if existing_partner is not None:
+            return JSONResponse(
+                content={
+                    "success": False,
+                    "message": f"Пользователь уже привязан к партнёру {existing_partner}",
+                },
+                status_code=409,
+            )
+
+        await session.execute(
+            text(
+                """
+                INSERT INTO partners (partner_tg_id, joined_tg_id)
+                VALUES (:partner_tg_id, :joined_tg_id)
+                """
+            ),
+            {"partner_tg_id": tg_id, "joined_tg_id": joined_tg_id},
+        )
+        await session.commit()
+        return JSONResponse(
+            content={
+                "success": True,
+                "message": "Приглашённый добавлен",
+                "partner_tg_id": tg_id,
+                "joined_tg_id": joined_tg_id,
+            },
+            status_code=201,
+        )
+    except Exception as e:
+        await session.rollback()
+        return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
+
+
+@router.delete("/{tg_id}/invited/{joined_tg_id}")
+async def delete_partner_invited(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    joined_tg_id: int = Path(..., description="Telegram ID приглашённого"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Удаляет приглашённого у партнёра."""
+
+    try:
+        result = await session.execute(
+            text(
+                """
+                DELETE FROM partners
+                WHERE partner_tg_id = :partner_tg_id
+                  AND joined_tg_id = :joined_tg_id
+                """
+            ),
+            {"partner_tg_id": tg_id, "joined_tg_id": joined_tg_id},
+        )
+        await session.commit()
+
+        if result.rowcount > 0:
+            return JSONResponse(
+                content={
+                    "success": True,
+                    "message": "Приглашённый удалён",
+                    "partner_tg_id": tg_id,
+                    "joined_tg_id": joined_tg_id,
+                },
+                status_code=200,
+            )
+        return JSONResponse(
+            content={"success": False, "message": "Связка партнёр-приглашённый не найдена"},
+            status_code=404,
+        )
+    except Exception as e:
+        await session.rollback()
+        return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
+
+
+@router.patch("/{tg_id}/percent")
+async def update_partner_percent(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    percent: float = Query(..., description="Новый персональный процент (0-100 или 0.0-1.0)"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Обновляет персональный процент партнёра."""
+
+    normalized = _parse_percent(percent)
+    if normalized is None:
+        return JSONResponse(
+            content={"success": False, "message": "Неверный процент. Допустимо 0-100 или 0.0-1.0"},
+            status_code=400,
+        )
+
+    try:
+        result = await session.execute(
+            text(
+                """
+                UPDATE users
+                SET partner_percent = :percent, partner_percent_custom = true
+                WHERE tg_id = :tg_id
+                """
+            ),
+            {"tg_id": tg_id, "percent": normalized},
+        )
+        await session.commit()
+
+        if result.rowcount > 0:
+            return JSONResponse(
+                content={"success": True, "message": "Процент обновлён", "percent": normalized},
+                status_code=200,
+            )
+        return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
+    except Exception as e:
+        await session.rollback()
+        return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
+
+
+@router.patch("/{tg_id}/balance")
+async def update_partner_balance(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    amount: float = Query(..., description="Сумма операции"),
+    mode: str = Query("set", description="Режим: set, add, subtract"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Изменяет баланс партнёрской программы."""
+
+    mode_normalized = (mode or "set").strip().lower()
+    if mode_normalized not in {"set", "add", "subtract"}:
+        return JSONResponse(
+            content={"success": False, "message": "Неверный режим. Используйте set, add или subtract"},
+            status_code=400,
+        )
+
+    try:
+        amount_val = float(amount)
+    except (TypeError, ValueError):
+        return JSONResponse(
+            content={"success": False, "message": "Неверная сумма"},
+            status_code=400,
+        )
+
+    if amount_val < 0:
+        return JSONResponse(
+            content={"success": False, "message": "Сумма не может быть отрицательной"},
+            status_code=400,
+        )
+
+    try:
+        current_res = await session.execute(
+            text("SELECT partner_balance FROM users WHERE tg_id = :tg_id"),
+            {"tg_id": tg_id},
+        )
+        current_balance = current_res.scalar()
+        if current_balance is None:
+            return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
+
+        current_balance = float(current_balance or 0.0)
+
+        if mode_normalized == "set":
+            new_balance = amount_val
+        elif mode_normalized == "add":
+            new_balance = current_balance + amount_val
+        else:
+            if current_balance < amount_val:
+                return JSONResponse(
+                    content={"success": False, "message": "Недостаточно средств"},
+                    status_code=400,
+                )
+            new_balance = current_balance - amount_val
+
+        await session.execute(
+            text("UPDATE users SET partner_balance = :balance WHERE tg_id = :tg_id"),
+            {"tg_id": tg_id, "balance": new_balance},
+        )
+        await session.commit()
+
+        return JSONResponse(
+            content={"success": True, "message": "Баланс обновлён", "balance": new_balance},
+            status_code=200,
+        )
+    except Exception as e:
+        await session.rollback()
+        return JSONResponse(content={"success": False, "message": str(e)}, status_code=500)
+
+
+@router.get("/{tg_id}/invited")
+async def get_partner_invited(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Возвращает список приглашённых пользователей конкретного партнёра.
+
+    Структура ответа:
+    [
+      { "tg_id": int, "joined_at": str | None, "balance": float, "subs_count": int, "payments_count": int }
+    ]
+    """
+
+    invited_sql = text(
+        """
+        SELECT 
+            pr.joined_tg_id,
+            pr.created_at,
+            COALESCE(u.balance, 0) AS user_balance,
+            (
+                SELECT COUNT(*) FROM keys k 
+                WHERE k.tg_id = pr.joined_tg_id
+            ) AS subs_count,
+            (
+                SELECT COUNT(*) FROM payments pay 
+                WHERE pay.tg_id = pr.joined_tg_id 
+                  AND lower(pay.status) = 'success'
+            ) AS payments_count
+        FROM partners pr
+        LEFT JOIN users u ON u.tg_id = pr.joined_tg_id
+        WHERE pr.partner_tg_id = :tg_id
+        ORDER BY pr.created_at DESC
+        """
+    )
+
+    invited_res = await session.execute(invited_sql, {"tg_id": tg_id})
+    invited_rows = invited_res.fetchall()
+
+    invited_list = [
+        {
+            "tg_id": row[0],
+            "joined_at": row[1].isoformat() if isinstance(row[1], datetime) else None,
+            "balance": float(row[2] or 0),
+            "subs_count": int(row[3] or 0),
+            "payments_count": int(row[4] or 0),
+        }
+        for row in invited_rows
+    ]
+
+    return JSONResponse(content=invited_list)
+
+
+@router.get("/payouts/pending")
+async def get_partner_payouts_pending(
+    limit: int = Query(50, ge=1, le=200, description="Лимит результатов"),
+    offset: int = Query(0, ge=0, description="Смещение"),
+    partner_tg_id: int | None = Query(None, description="Фильтр по TG ID партнёра"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Возвращает список ожидающих заявок на вывод."""
+
+    where_clause = "WHERE pr.status = 'pending'"
+    params = {"limit": limit, "offset": offset}
+    if partner_tg_id is not None:
+        where_clause += " AND pr.tg_id = :partner_tg_id"
+        params["partner_tg_id"] = partner_tg_id
+
+    count_sql = text(f"SELECT COUNT(*) FROM payout_requests pr {where_clause}")
+    rows_sql = text(
+        f"""
+        SELECT
+            pr.id,
+            pr.tg_id,
+            pr.amount,
+            pr.status,
+            pr.created_at,
+            COALESCE(pr.method, u.payout_method) AS method,
+            COALESCE(pr.destination, u.card_number) AS destination
+        FROM payout_requests pr
+        LEFT JOIN users u ON u.tg_id = pr.tg_id
+        {where_clause}
+        ORDER BY pr.created_at ASC, pr.id ASC
+        LIMIT :limit OFFSET :offset
+        """
+    )
+
+    total = await session.scalar(count_sql) or 0
+    result = await session.execute(rows_sql, params)
+    items = []
+    for row in result.fetchall():
+        items.append({
+            "id": int(row[0]),
+            "tg_id": int(row[1]),
+            "amount": float(row[2] or 0.0),
+            "status": row[3] or "pending",
+            "created_at": _row_dt_iso(row[4]),
+            "method": row[5] or None,
+            "destination": row[6] or None,
+        })
+
+    return JSONResponse(content={"total": int(total), "items": items})
+
+
+@router.get("/payouts/history")
+async def get_partner_payouts_history(
+    limit: int = Query(50, ge=1, le=200, description="Лимит результатов"),
+    offset: int = Query(0, ge=0, description="Смещение"),
+    partner_tg_id: int | None = Query(None, description="Фильтр по TG ID партнёра"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Возвращает историю выплат (approved/rejected)."""
+
+    where_clause = "WHERE pr.status IN ('approved','rejected')"
+    params = {"limit": limit, "offset": offset}
+    if partner_tg_id is not None:
+        where_clause += " AND pr.tg_id = :partner_tg_id"
+        params["partner_tg_id"] = partner_tg_id
+
+    count_sql = text(f"SELECT COUNT(*) FROM payout_requests pr {where_clause}")
+    rows_sql = text(
+        f"""
+        SELECT
+            pr.id,
+            pr.tg_id,
+            pr.amount,
+            pr.status,
+            pr.created_at,
+            COALESCE(pr.method, u.payout_method) AS method,
+            COALESCE(pr.destination, u.card_number) AS destination
+        FROM payout_requests pr
+        LEFT JOIN users u ON u.tg_id = pr.tg_id
+        {where_clause}
+        ORDER BY pr.created_at DESC, pr.id DESC
+        LIMIT :limit OFFSET :offset
+        """
+    )
+
+    total = await session.scalar(count_sql) or 0
+    result = await session.execute(rows_sql, params)
+    items = []
+    for row in result.fetchall():
+        items.append({
+            "id": int(row[0]),
+            "tg_id": int(row[1]),
+            "amount": float(row[2] or 0.0),
+            "status": row[3] or "—",
+            "created_at": _row_dt_iso(row[4]),
+            "method": row[5] or None,
+            "destination": row[6] or None,
+        })
+
+    return JSONResponse(content={"total": int(total), "items": items})
+
+
+@router.post("/payouts/{payout_id}/approve")
+async def approve_partner_payout(
+    payout_id: int = Path(..., description="ID заявки"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Одобряет заявку на вывод."""
+
+    req_row = await session.execute(
+        text("SELECT id, tg_id, amount FROM payout_requests WHERE id = :id AND status = 'pending'"),
+        {"id": payout_id},
+    )
+    req = req_row.fetchone()
+    if not req:
+        return JSONResponse(
+            content={"success": False, "message": "Заявка не найдена или уже обработана"},
+            status_code=404,
+        )
+
+    user_row = await session.execute(
+        text("SELECT payout_method, card_number FROM users WHERE tg_id = :tg_id"),
+        {"tg_id": req[1]},
+    )
+    user = user_row.fetchone()
+    payout_method = (user[0] if user else None) or "card"
+    destination = (user[1] if user else None) or None
+    destination = (destination or "").strip() or None
+
+    await session.execute(
+        text(
+            """
+            UPDATE payout_requests
+            SET status = 'approved', method = :method, destination = :destination
+            WHERE id = :id
+            """
+        ),
+        {"id": payout_id, "method": payout_method, "destination": destination},
+    )
+    await session.commit()
+
+    return JSONResponse(content={"success": True, "message": "Заявка одобрена"}, status_code=200)
+
+
+@router.post("/payouts/{payout_id}/reject")
+async def reject_partner_payout(
+    payout_id: int = Path(..., description="ID заявки"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Отклоняет заявку на вывод и возвращает сумму на баланс."""
+
+    req_row = await session.execute(
+        text("SELECT id, tg_id, amount FROM payout_requests WHERE id = :id AND status = 'pending'"),
+        {"id": payout_id},
+    )
+    req = req_row.fetchone()
+    if not req:
+        return JSONResponse(
+            content={"success": False, "message": "Заявка не найдена или уже обработана"},
+            status_code=404,
+        )
+
+    user_row = await session.execute(
+        text("SELECT payout_method, card_number, partner_balance FROM users WHERE tg_id = :tg_id"),
+        {"tg_id": req[1]},
+    )
+    user = user_row.fetchone()
+    payout_method = (user[0] if user else None) or "card"
+    destination = (user[1] if user else None) or None
+    destination = (destination or "").strip() or None
+
+    await session.execute(
+        text(
+            """
+            UPDATE payout_requests
+            SET status = 'rejected', method = :method, destination = :destination
+            WHERE id = :id
+            """
+        ),
+        {"id": payout_id, "method": payout_method, "destination": destination},
+    )
+
+    if user is not None:
+        current_balance = float(user[2] or 0.0)
+        await session.execute(
+            text("UPDATE users SET partner_balance = :balance WHERE tg_id = :tg_id"),
+            {"balance": current_balance + float(req[2] or 0.0), "tg_id": req[1]},
+        )
+
+    await session.commit()
+
+    return JSONResponse(content={"success": True, "message": "Заявка отклонена"}, status_code=200)
+
+
+@router.patch("/{tg_id}/percent/reset")
+async def reset_partner_percent(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Сбрасывает персональный процент партнёра к дефолту."""
+
+    result = await session.execute(
+        text(
+            """
+            UPDATE users
+            SET partner_percent = NULL, partner_percent_custom = false
+            WHERE tg_id = :tg_id
+            """
+        ),
+        {"tg_id": tg_id},
+    )
+    await session.commit()
+
+    if result.rowcount > 0:
+        return JSONResponse(content={"success": True, "message": "Процент сброшен"}, status_code=200)
+    return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
+
+
+@router.patch("/{tg_id}/code")
+async def update_partner_code(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    code: str = Query(..., description="Новый код партнёра (латиница/цифры/_)"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Обновляет код партнёрской ссылки."""
+
+    raw = (code or "").strip().lower()
+    if not raw:
+        return JSONResponse(content={"success": False, "message": "Код не может быть пустым"}, status_code=400)
+
+    import re
+
+    if not re.fullmatch(r"[a-z0-9_]{3,32}", raw):
+        return JSONResponse(
+            content={"success": False, "message": "Неверный код. Разрешены a-z, 0-9, _ (3-32 символа)"},
+            status_code=400,
+        )
+
+    exists = await session.execute(
+        text("SELECT 1 FROM users WHERE partner_code = :code AND tg_id != :tg_id"),
+        {"code": raw, "tg_id": tg_id},
+    )
+    if exists.first():
+        return JSONResponse(content={"success": False, "message": "Такой код уже занят"}, status_code=409)
+
+    result = await session.execute(
+        text("UPDATE users SET partner_code = :code WHERE tg_id = :tg_id"),
+        {"code": raw, "tg_id": tg_id},
+    )
+    await session.commit()
+
+    if result.rowcount > 0:
+        return JSONResponse(content={"success": True, "message": "Код обновлён", "code": raw}, status_code=200)
+    return JSONResponse(content={"success": False, "message": "Партнёр не найден"}, status_code=404)
+
+
+@router.post("/reset-disabled-methods")
+async def reset_disabled_payout_methods(
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Сбрасывает реквизиты для отключённых способов вывода."""
+
+    try:
+        from modules.partner_program.settings import (
+            ENABLE_PAYOUT_CARD,
+            ENABLE_PAYOUT_SBP,
+            ENABLE_PAYOUT_TON,
+            ENABLE_PAYOUT_USDT,
+        )
+        from modules.partner_program import buttons as B
+    except Exception:
+        ENABLE_PAYOUT_CARD = True
+        ENABLE_PAYOUT_USDT = True
+        ENABLE_PAYOUT_TON = True
+        ENABLE_PAYOUT_SBP = True
+        B = None
+
+    disabled = []
+    if not ENABLE_PAYOUT_CARD and B:
+        disabled.append(B.METHOD_CARD)
+    if not ENABLE_PAYOUT_USDT and B:
+        disabled.append(B.METHOD_USDT)
+    if not ENABLE_PAYOUT_TON and B:
+        disabled.append(B.METHOD_TON)
+    if not ENABLE_PAYOUT_SBP and B:
+        disabled.append(B.METHOD_SBP)
+
+    if not disabled:
+        return JSONResponse(content={"success": True, "message": "Отключённых методов нет"}, status_code=200)
+
+    await session.execute(
+        text(
+            """
+            UPDATE users
+            SET card_number = NULL
+            WHERE payout_method = ANY(:methods)
+            """
+        ),
+        {"methods": disabled},
+    )
+    await session.commit()
+
+    return JSONResponse(content={"success": True, "message": "Отключённые методы сброшены"}, status_code=200)
+
+
+@router.get("/{tg_id}/export")
+async def export_partner_invites_csv(
+    tg_id: int = Path(..., description="Telegram ID партнёра"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    """Экспортирует приглашённых партнёром в CSV."""
+
+    rows = await session.execute(
+        text(
+            """
+            SELECT joined_tg_id, created_at
+            FROM partners
+            WHERE partner_tg_id = :tg_id
+            ORDER BY created_at ASC
+            """
+        ),
+        {"tg_id": tg_id},
+    )
+    data = rows.fetchall()
+
+    if not data:
+        return JSONResponse(content={"success": False, "message": "Нет приглашённых"}, status_code=404)
+
+    buffer = StringIO()
+    writer = csv.writer(buffer, delimiter=";")
+    writer.writerow(["joined_tg_id", "created_at"])
+    for joined_tg_id, created_at in data:
+        writer.writerow([int(joined_tg_id), created_at.isoformat() if created_at else ""])
+
+    content = buffer.getvalue().encode("utf-8-sig")
+    filename = f"partner_invites_{tg_id}.csv"
+
+    return StreamingResponse(
+        iter([content]),
+        media_type="text/csv",
+        headers={"Content-Disposition": f"attachment; filename={filename}"},
+    )
@@ -1,5 +1,5 @@
 from fastapi import Depends, HTTPException, Query
-from sqlalchemy import delete, select
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession

 from api.depends import get_session, verify_admin_token
@@ -0,0 +1,153 @@
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.depends import get_session, verify_admin_token
+from api.schemas.settings import SettingResponse, SettingUpsert
+from database.models import Setting
+from database.settings import set_setting
+from core.settings.buttons_config import BUTTONS_CONFIG, update_buttons_config
+from core.settings.modes_config import MODES_CONFIG, update_modes_config
+from core.settings.money_config import MONEY_CONFIG, update_money_config
+from core.settings.notifications_config import NOTIFICATIONS_CONFIG, update_notifications_config
+from core.settings.payments_config import PAYMENTS_CONFIG, update_payments_config
+from core.settings.providers_order_config import PROVIDERS_ORDER, update_providers_order
+from core.settings.tariffs_config import TARIFFS_CONFIG, update_tariffs_config
+from pydantic import BaseModel
+
+
+router = APIRouter()
+
+
+class ConfigUpdatePayload(BaseModel):
+    value: dict[str, Any] | None = None
+
+
+@router.get("/", response_model=list[SettingResponse])
+async def get_all_settings(
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(Setting))
+    return result.scalars().all()
+
+
+@router.get("/configs")
+async def get_configs(admin=Depends(verify_admin_token)):
+    return {
+        "payments": dict(PAYMENTS_CONFIG),
+        "buttons": dict(BUTTONS_CONFIG),
+        "notifications": dict(NOTIFICATIONS_CONFIG),
+        "modes": dict(MODES_CONFIG),
+        "money": dict(MONEY_CONFIG),
+        "providers_order": dict(PROVIDERS_ORDER),
+        "tariffs": dict(TARIFFS_CONFIG),
+    }
+
+
+@router.post("/configs/{scope}")
+async def update_config_scope(
+    scope: str,
+    payload: ConfigUpdatePayload,
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    data = dict(payload.value or {})
+    normalized = scope.strip().lower().replace("-", "_")
+
+    if normalized == "payments":
+        cleaned = {key: bool(value) for key, value in data.items()}
+        await update_payments_config(session, cleaned)
+        return {"payments": dict(PAYMENTS_CONFIG)}
+
+    if normalized == "buttons":
+        cleaned = {key: bool(value) for key, value in data.items()}
+        await update_buttons_config(session, cleaned)
+        return {"buttons": dict(BUTTONS_CONFIG)}
+
+    if normalized == "notifications":
+        await update_notifications_config(session, data)
+        return {"notifications": dict(NOTIFICATIONS_CONFIG)}
+
+    if normalized == "modes":
+        cleaned = {key: bool(value) for key, value in data.items()}
+        await update_modes_config(session, cleaned)
+        return {"modes": dict(MODES_CONFIG)}
+
+    if normalized == "money":
+        await update_money_config(session, data)
+        return {"money": dict(MONEY_CONFIG)}
+
+    if normalized == "providers_order":
+        cleaned: dict[str, int] = {}
+        for key, value in data.items():
+            try:
+                cleaned[key] = int(value)
+            except (TypeError, ValueError):
+                continue
+        await update_providers_order(session, cleaned)
+        return {"providers_order": dict(PROVIDERS_ORDER)}
+
+    if normalized == "tariffs":
+        cleaned = dict(data)
+        if "ALLOW_DOWNGRADE" in cleaned:
+            cleaned["ALLOW_DOWNGRADE"] = bool(cleaned.get("ALLOW_DOWNGRADE"))
+        if "KEY_ADDONS_RECALC_PRICE" in cleaned:
+            cleaned["KEY_ADDONS_RECALC_PRICE"] = bool(cleaned.get("KEY_ADDONS_RECALC_PRICE"))
+        if "KEY_ADDONS_PACK_MODE" in cleaned:
+            mode = str(cleaned.get("KEY_ADDONS_PACK_MODE") or "").strip().lower()
+            cleaned["KEY_ADDONS_PACK_MODE"] = mode if mode in {"", "traffic", "devices", "all"} else ""
+        await update_tariffs_config(session, cleaned)
+        return {"tariffs": dict(TARIFFS_CONFIG)}
+
+    raise HTTPException(status_code=404, detail="Unsupported config scope")
+
+
+@router.get("/{key}", response_model=SettingResponse)
+async def get_setting_by_key(
+    key: str,
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(Setting).where(Setting.key == key))
+    obj = result.scalar_one_or_none()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Setting not found")
+    return obj
+
+
+@router.post("/{key}", response_model=SettingResponse)
+async def upsert_setting(
+    key: str,
+    payload: SettingUpsert,
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    obj = await set_setting(
+        session=session,
+        key=key,
+        value=payload.value,
+        description=payload.description,
+    )
+    await session.commit()
+    await session.refresh(obj)
+    return obj
+
+
+@router.delete("/{key}", response_model=dict)
+async def delete_setting(
+    key: str,
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(Setting).where(Setting.key == key))
+    obj = result.scalar_one_or_none()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Setting not found")
+    await session.delete(obj)
+    await session.commit()
+    return {"detail": "Setting deleted"}
+
+
@@ -9,7 +9,7 @@ from api.routes.base_crud import generate_crud_router
 from api.schemas.users import UserBase, UserResponse, UserUpdate
 from database import delete_user_data, get_servers
 from database.models import Key, User
-from handlers.keys.key_utils import delete_key_from_cluster
+from handlers.keys.operations import delete_key_from_cluster
 from logger import logger


@@ -11,5 +11,6 @@ from .misc import (
 )
 from .referrals import ReferralResponse
 from .servers import ServerBase, ServerResponse, ServerUpdate
+from .settings import SettingResponse, SettingUpsert
 from .tariffs import TariffBase, TariffResponse, TariffUpdate
 from .users import UserBase, UserResponse, UserUpdate
@@ -1,5 +1,4 @@
 from datetime import datetime
-from typing import Optional

 from pydantic import BaseModel, Field, model_validator

@@ -12,15 +11,34 @@ class CouponBase(BaseModel):
    is_used: bool = False
    days: int | None = Field(default=None)

+    percent: int | None = Field(default=None)
+    max_discount_amount: int | None = Field(default=None)
+    min_order_amount: int | None = Field(default=None)
+
+    new_users_only: bool = False
+
    @model_validator(mode="after")
-    def check_exactly_one_of_amount_or_days(self) -> "CouponBase":
+    def check_coupon_type(self) -> "CouponBase":
        has_amount = self.amount not in (None, 0)
        has_days = self.days is not None
+        has_percent = self.percent is not None
+
+        provided = int(has_amount) + int(has_days) + int(has_percent)
+        if provided != 1:
+            raise ValueError("Coupon must have exactly one of: 'amount', 'days', 'percent'")
+
+        if has_days and self.days is not None and self.days <= 0:
+            raise ValueError("'days' must be > 0")
+
+        if has_percent and self.percent is not None and not (1 <= self.percent <= 100):
+            raise ValueError("'percent' must be between 1 and 100")
+
+        if has_percent:
+            if self.min_order_amount is not None and self.min_order_amount < 0:
+                raise ValueError("'min_order_amount' must be >= 0")
+            if self.max_discount_amount is not None and self.max_discount_amount < 0:
+                raise ValueError("'max_discount_amount' must be >= 0")

-        if has_amount and has_days:
-            raise ValueError("Coupon must have exactly one of: 'amount' or 'days'")
-        if not has_amount and not has_days:
-            raise ValueError("Coupon must have exactly one of: 'amount' or 'days'")
        return self


@@ -39,12 +57,34 @@ class CouponUpdate(BaseModel):
    is_used: bool | None = None
    days: int | None = Field(default=None)

+    percent: int | None = None
+    max_discount_amount: int | None = None
+    min_order_amount: int | None = None
+
+    new_users_only: bool | None = None
+
    @model_validator(mode="after")
-    def validate_amount_or_days(self) -> "CouponUpdate":
-        if self.amount is None and self.days is None:
-            return self
-        if self.amount is not None and self.days is not None:
-            raise ValueError("Specify only one of: 'amount' or 'days'")
+    def validate_coupon_update(self) -> "CouponUpdate":
+        has_amount = self.amount not in (None, 0)
+        has_days = self.days is not None
+        has_percent = self.percent is not None
+
+        provided = int(has_amount) + int(has_days) + int(has_percent)
+        if provided > 1:
+            raise ValueError("Specify only one of: 'amount', 'days', 'percent'")
+
+        if has_days and self.days is not None and self.days <= 0:
+            raise ValueError("'days' must be > 0")
+
+        if has_percent and self.percent is not None and not (1 <= self.percent <= 100):
+            raise ValueError("'percent' must be between 1 and 100")
+
+        if has_percent:
+            if self.min_order_amount is not None and self.min_order_amount < 0:
+                raise ValueError("'min_order_amount' must be >= 0")
+            if self.max_discount_amount is not None and self.max_discount_amount < 0:
+                raise ValueError("'max_discount_amount' must be >= 0")
+
        return self


@@ -1,5 +1,4 @@
 from datetime import datetime
-from typing import Optional

 from pydantic import BaseModel

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pydantic import BaseModel, Field


@@ -18,6 +16,13 @@ class KeyBase(BaseModel):
    notified: bool | None = False
    notified_24h: bool | None = False

+    selected_device_limit: int | None = None
+    selected_traffic_limit: int | None = None
+    selected_price_rub: int | None = None
+
+    current_device_limit: int | None = None
+    current_traffic_limit: int | None = None
+

 class KeyResponse(KeyBase):
    class Config:
@@ -43,6 +48,13 @@ class KeyDetailsResponse(BaseModel):
    location_name: str | None
    tariff_id: int | None

+    selected_device_limit: int | None = None
+    selected_traffic_limit: int | None = None
+    selected_price_rub: int | None = None
+
+    current_device_limit: int | None = None
+    current_traffic_limit: int | None = None
+
    class Config:
        from_attributes = True

@@ -59,6 +71,13 @@ class KeyUpdate(BaseModel):
    notified: bool | None = None
    notified_24h: bool | None = None

+    selected_device_limit: int | None = None
+    selected_traffic_limit: int | None = None
+    selected_price_rub: int | None = None
+
+    current_device_limit: int | None = None
+    current_traffic_limit: int | None = None
+
    class Config:
        from_attributes = True

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class MaintenanceUpdate(BaseModel):
+    enabled: bool
+
+
+class DomainChange(BaseModel):
+    domain: str
@@ -1,5 +1,4 @@
 from datetime import datetime
-from typing import Literal, Optional, Union

 from pydantic import BaseModel

@@ -8,7 +7,7 @@ class PaymentBase(BaseModel):
    tg_id: int
    amount: float
    payment_system: str
-    status: Literal["success", "pending", "failed"]
+    status: str


 class PaymentResponse(PaymentBase):
@@ -94,6 +93,16 @@ class BlockedUserResponse(BaseModel):
        from_attributes = True


+class MonthlyStats(BaseModel):
+    month: str
+    registrations: int
+    trials: int
+    new_purchases_count: int
+    new_purchases_amount: float
+    repeat_purchases_count: int
+    repeat_purchases_amount: float
+
+
 class TrackingSourceResponse(BaseModel):
    id: int
    name: str
@@ -102,5 +111,12 @@ class TrackingSourceResponse(BaseModel):
    created_by: int
    created_at: datetime

+    registrations: int = 0
+    trials: int = 0
+    payments: int = 0
+    total_amount: float = 0.0
+
+    monthly: list[MonthlyStats] = []
+
    class Config:
        from_attributes = True
@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pydantic import BaseModel


@@ -0,0 +1,20 @@
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class SettingUpsert(BaseModel):
+    value: Any | None = None
+    description: str | None = None
+
+
+class SettingResponse(BaseModel):
+    key: str
+    value: Any | None = None
+    description: str | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    class Config:
+        from_attributes = True
@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Optional
+from typing import Any

 from pydantic import BaseModel

@@ -13,6 +13,20 @@ class TariffBase(BaseModel):
    device_limit: int | None = None
    is_active: bool = True
    subgroup_title: str | None = None
+    sort_order: int | None = None
+    vless: bool = False
+    external_squad: str | None = None
+
+    configurable: bool = False
+
+    device_options: list[int] | None = None
+    traffic_options_gb: list[int] | None = None
+
+    device_step_rub: int | None = None
+    device_overrides: dict[str, int] | None = None
+
+    traffic_step_rub: int | None = None
+    traffic_overrides: dict[str, int] | None = None


 class TariffResponse(TariffBase):
@@ -33,6 +47,20 @@ class TariffUpdate(BaseModel):
    device_limit: int | None = None
    is_active: bool | None = None
    subgroup_title: str | None = None
+    sort_order: int | None = None
+    vless: bool | None = None
+    external_squad: str | None = None
+
+    configurable: bool | None = None
+
+    device_options: list[int] | None = None
+    traffic_options_gb: list[int] | None = None
+
+    device_step_rub: int | None = None
+    device_overrides: dict[str, int] | None = None
+
+    traffic_step_rub: int | None = None
+    traffic_overrides: dict[str, int] | None = None

    class Config:
        from_attributes = True
@@ -1,5 +1,4 @@
 from datetime import datetime
-from typing import Optional

 from pydantic import BaseModel

@@ -11,8 +10,8 @@ class UserBase(BaseModel):
    last_name: str | None = None
    language_code: str | None = None
    is_bot: bool | None = False
-    balance: float = 0.0
-    trial: int = 0
+    balance: float | None = 0.0
+    trial: int | None = 0
    source_code: str | None = None


@@ -1,218 +1,31 @@
-import os
-import subprocess
-import time
-import traceback
-
-from functools import lru_cache
-
 from aiogram import Bot, Dispatcher
 from aiogram.client.default import DefaultBotProperties
 from aiogram.enums import ParseMode
-from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
-from aiogram.filters import ExceptionTypeFilter
 from aiogram.fsm.storage.memory import MemoryStorage
-from aiogram.types import BufferedInputFile, ErrorEvent
-from aiogram.utils.markdown import hbold

-from config import ADMIN_ID, API_TOKEN
+from config import API_TOKEN
 from filters.private import IsPrivateFilter
-from logger import logger
+from utils.button_icons import apply_button_icons_patch, set_button_icon_config
+from utils.custom_emojis import initialize_custom_emojis
+from utils.errors import setup_error_handlers
+from utils.modules_loader import load_modules_from_folder, modules_hub

+apply_button_icons_patch()

 bot = Bot(token=API_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
 storage = MemoryStorage()
 dp = Dispatcher(bot=bot, storage=storage)

+dp.include_router(modules_hub)

-_last_check_time = 0
-_last_git_info = ""
+load_modules_from_folder()

+from handlers.buttons import BUTTON_ICON_CONFIG

-def _get_git_commit_number_uncached() -> str:
-    repo_url = "https://github.com/Vladless/Solo_bot"
-    cwd = os.path.abspath(os.path.dirname(__file__))
-
-    if not os.path.isdir(os.path.join(cwd, ".git")):
-        cwd = "/root/Prod/Solo_bot"
-        logger.info(f"[Git] .git не найден в текущем каталоге, используем {cwd}")
-
-    env = os.environ.copy()
-    env["GIT_DIR"] = os.path.join(cwd, ".git")
-    env["GIT_WORK_TREE"] = cwd
-
-    try:
-        local_number = (
-            subprocess.check_output(["git", "rev-list", "--count", "HEAD"], cwd=cwd, env=env).decode().strip()
-        )
-        local_hash = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=cwd, env=env).decode().strip()
-        try:
-            branch = (
-                subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd, env=env).decode().strip()
-            )
-            if branch == "HEAD":
-                describe = (
-                    subprocess.check_output(
-                        ["git", "describe", "--tags", "--exact-match"],
-                        cwd=cwd,
-                        env=env,
-                        stderr=subprocess.DEVNULL,
-                    )
-                    .decode()
-                    .strip()
-                )
-                branch = "main" if describe.startswith("v") or "release" in describe.lower() else "dev"
-        except Exception:
-            branch = "dev"
-
-    except Exception as e:
-        logger.error(f"[Git] Ошибка при получении локального коммита: {e}")
-        return f"\n(Требуется обновление через CLI (команда <code>sudo solobot</code>): {e})"
-
-    try:
-        subprocess.check_output(["git", "fetch", "origin"], cwd=cwd, env=env)
-        remote_commit = subprocess.check_output(
-            ["git", "ls-remote", "origin", f"refs/heads/{branch}"], cwd=cwd, env=env
-        ).decode()
-        remote_hash = remote_commit.split()[0]
-
-        remote_number = (
-            subprocess.check_output(["git", "rev-list", "--count", remote_hash], cwd=cwd, env=env).decode().strip()
-        )
-
-        if local_hash == remote_hash:
-            logger.info("[Git] Локальная версия актуальна")
-            return "\n(Актуальная версия)"
-
-        return (
-            f'\n(commit <a href="{repo_url}/commit/{local_hash}">'
-            f"#{local_number}</a> / actual commit "
-            f'<a href="{repo_url}/commit/{remote_hash}">#{remote_number}</a>)'
-        )
-    except Exception as e:
-        logger.error(f"[Git] Ошибка при получении удалённого коммита: {e}")
-        return "\n(Требуется обновление через CLI, команда <code>sudo solobot</code>)"
-
-
-@lru_cache(maxsize=1)
-def _cached_git_info() -> str:
-    return _get_git_commit_number_uncached()
-
-
-def get_git_commit_number() -> str:
-    global _last_check_time, _last_git_info
-    now = time.time()
-    if now - _last_check_time > 3600:
-        _last_check_time = now
-        _cached_git_info.cache_clear()
-        _last_git_info = _cached_git_info()
-    return _last_git_info
-
-
-def get_version() -> str:
-    return f"v4.4-Release{get_git_commit_number()}"
-
+set_button_icon_config(BUTTON_ICON_CONFIG)

 dp.message.filter(IsPrivateFilter())
 dp.callback_query.filter(IsPrivateFilter())

-
-@dp.errors(ExceptionTypeFilter(Exception))
-async def errors_handler(event: ErrorEvent, bot: Bot) -> bool:
-    if isinstance(event.exception, TelegramForbiddenError):
-        logger.info(f"User {event.update.message.from_user.id} заблокировал бота.")
-        return True
-
-    if isinstance(event.exception, TelegramBadRequest):
-        error_message = str(event.exception)
-
-        if (
-            "query is too old and response timeout expired or query ID is invalid" in error_message
-            or "message can't be deleted for everyone" in error_message
-            or "message to delete not found" in error_message
-        ):
-            logger.warning("Отправляем стартовое меню.")
-            try:
-                from handlers.start import handle_start_callback_query, start_command
-
-                if event.update.message:
-                    fsm_context = dp.fsm.get_context(
-                        bot=bot,
-                        chat_id=event.update.message.chat.id,
-                        user_id=event.update.message.from_user.id,
-                    )
-                    await start_command(
-                        event.update.message,
-                        state=fsm_context,
-                        session=None,
-                        admin=False,
-                        captcha=False,
-                    )
-                elif event.update.callback_query:
-                    fsm_context = dp.fsm.get_context(
-                        bot=bot,
-                        chat_id=event.update.callback_query.message.chat.id,
-                        user_id=event.update.callback_query.from_user.id,
-                    )
-                    await handle_start_callback_query(
-                        event.update.callback_query,
-                        state=fsm_context,
-                        session=None,
-                        admin=False,
-                        captcha=False,
-                    )
-            except Exception as e:
-                logger.error(f"Ошибка при показе стартового меню после ошибки: {e}")
-
-            return True
-
-    logger.exception(f"Update: {event.update}\nException: {event.exception}")
-
-    if not ADMIN_ID:
-        return True
-
-    try:
-        for admin_id in ADMIN_ID:
-            await bot.send_document(
-                chat_id=admin_id,
-                document=BufferedInputFile(
-                    traceback.format_exc().encode(),
-                    filename=f"error_{event.update.update_id}.txt",
-                ),
-                caption=f"{hbold(type(event.exception).__name__)}: {str(event.exception)[:1021]}...",
-            )
-
-        from handlers.start import handle_start_callback_query, start_command
-
-        if event.update.message:
-            fsm_context = dp.fsm.get_context(
-                bot=bot,
-                chat_id=event.update.message.chat.id,
-                user_id=event.update.message.from_user.id,
-            )
-            await start_command(
-                event.update.message,
-                state=fsm_context,
-                session=None,
-                admin=False,
-                captcha=False,
-            )
-        elif event.update.callback_query:
-            fsm_context = dp.fsm.get_context(
-                bot=bot,
-                chat_id=event.update.callback_query.message.chat.id,
-                user_id=event.update.callback_query.from_user.id,
-            )
-            await handle_start_callback_query(
-                event.update.callback_query,
-                state=fsm_context,
-                session=None,
-                admin=False,
-                captcha=False,
-            )
-
-    except TelegramBadRequest as exception:
-        logger.warning(f"Не удалось отправить детали ошибки: {exception}")
-    except Exception as exception:
-        logger.error(f"Неожиданная ошибка в error handler: {exception}")
-
-    return True
+setup_error_handlers(dp)
+initialize_custom_emojis()
@@ -1,3 +1,4 @@
+import locale
 import os
 import re
 import shutil
@@ -18,22 +19,83 @@ from rich.table import Table
 from config import BOT_SERVICE


+def ensure_utf8_locale():
+    try:
+        current_locale = locale.getlocale()
+        if current_locale and current_locale[1] == "UTF-8":
+            return
+    except Exception:
+        pass
+
+    console.print("[yellow]⏳ Проверка и установка локали UTF-8...[/yellow]")
+
+    os.environ["LC_ALL"] = "en_US.UTF-8"
+    os.environ["LANG"] = "en_US.UTF-8"
+
+    result = subprocess.run(["locale", "-a"], capture_output=True, text=True)
+    if "en_US.utf8" not in result.stdout.lower():
+        console.print("[blue]Добавляю локаль en_US.UTF-8 в систему...[/blue]")
+        try:
+            subprocess.run(["sudo", "locale-gen", "en_US.UTF-8"], check=True)
+            subprocess.run(["sudo", "update-locale", "LANG=en_US.UTF-8"], check=True)
+            console.print("[green]Локаль успешно установлена.[/green]")
+        except Exception as e:
+            console.print(f"[red]❌ Ошибка при установке локали: {e}[/red]")
+    else:
+        console.print("[green]Локаль UTF-8 уже доступна в системе.[/green]")
+
+
 try:
    sys.stdin.reconfigure(encoding="utf-8")
    sys.stdout.reconfigure(encoding="utf-8")
 except Exception:
    pass

-if not os.environ.get("LC_ALL", "").endswith("UTF-8"):
-    os.environ["LC_ALL"] = "en_US.UTF-8"
-    os.environ["LANG"] = "en_US.UTF-8"
-
 console = Console()
+ensure_utf8_locale()

-BACK_DIR = os.path.expanduser("~/.solobot_backup")
+BACK_DIR = os.path.expanduser("~/.solobot_backups")
 TEMP_DIR = os.path.expanduser("~/.solobot_tmp")
 PROJECT_DIR = os.path.abspath(os.path.dirname(__file__))
 IS_ROOT_DIR = PROJECT_DIR == "/root"
+GITHUB_REPO = "https://github.com/Vladless/Solo_bot"
+SERVICE_NAME = BOT_SERVICE
+
+
+def is_ascii_only(value: str) -> bool:
+    """Проверка, что строка содержит только ASCII."""
+    return all(ord(ch) < 128 for ch in value)
+
+
+def warn_english_only():
+    """Предупреждение о необходимости английской раскладки."""
+    console.print("[red]Обнаружен ввод с неанглийской раскладкой.[/red]")
+    console.print("[yellow]Пожалуйста, переключите раскладку на ENG и введите снова.[/yellow]")
+
+
+def safe_confirm(message: str, **kwargs) -> bool:
+    """Безопасный Confirm.ask с защитой от русской раскладки."""
+    while True:
+        try:
+            result = Confirm.ask(message, **kwargs)
+            return result
+        except UnicodeDecodeError:
+            warn_english_only()
+
+
+def safe_prompt(message: str, **kwargs) -> str:
+    """Безопасный Prompt.ask с защитой от русской раскладки."""
+    while True:
+        try:
+            value = Prompt.ask(message, **kwargs)
+        except UnicodeDecodeError:
+            warn_english_only()
+            continue
+        if isinstance(value, str) and not is_ascii_only(value):
+            warn_english_only()
+            continue
+        return value
+

 if IS_ROOT_DIR:
    console.print("[bold red]КРИТИЧЕСКАЯ ОШИБКА:[/bold red]")
@@ -42,8 +104,6 @@ if IS_ROOT_DIR:
    console.print("[red]Рекомендуется перенести бота в отдельную папку, например /root/solobot[/red]")
    console.print("[red]Обновление заблокировано в целях безопасности.[/red]")
    sys.exit(1)
-GITHUB_REPO = "https://github.com/Vladless/Solo_bot"
-SERVICE_NAME = BOT_SERVICE


 def is_service_exists(service_name):
@@ -72,16 +132,99 @@ def print_logo():
    console.print(f"[bold green]Директория бота:[/bold green] [yellow]{PROJECT_DIR}[/yellow]\n")


+def list_backups():
+    if not os.path.isdir(BACK_DIR):
+        return []
+    pairs = []
+    for name in os.listdir(BACK_DIR):
+        path = os.path.join(BACK_DIR, name)
+        if os.path.isdir(path):
+            try:
+                mtime = os.path.getmtime(path)
+            except Exception:
+                mtime = 0
+            pairs.append((mtime, path))
+    pairs.sort(reverse=True)
+    return [p for _, p in pairs]
+
+
+def prune_old_backups():
+    backups = list_backups()
+    for path in backups[3:]:
+        try:
+            shutil.rmtree(path, ignore_errors=True)
+        except Exception:
+            subprocess.run(["sudo", "rm", "-rf", path])
+
+
 def backup_project():
+    from datetime import datetime
+
+    os.makedirs(BACK_DIR, exist_ok=True)
+    ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+    dst = os.path.join(BACK_DIR, f"backup-{ts}")
    console.print("[yellow]Создаётся резервная копия проекта...[/yellow]")
    with console.status("[bold cyan]Копирование файлов...[/bold cyan]"):
-        subprocess.run(["rm", "-rf", BACK_DIR])
-        subprocess.run(["cp", "-r", PROJECT_DIR, BACK_DIR])
-    console.print(f"[green]Бэкап сохранён в: {BACK_DIR}[/green]")
+        subprocess.run(["cp", "-r", PROJECT_DIR, dst])
+    console.print(f"[green]Бэкап сохранён в: {dst}[/green]")
+    prune_old_backups()
+
+
+def restore_from_backup():
+    from datetime import datetime
+
+    backups = list_backups()[:3]
+    if not backups:
+        console.print(f"[red]❌ Бэкапы не найдены: {BACK_DIR}[/red]")
+        return
+
+    console.print("\n[bold green]Доступные бэкапы:[/bold green]")
+    shown = []
+    for idx, path in enumerate(backups, 1):
+        try:
+            mtime = os.path.getmtime(path)
+            dt = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:
+            dt = "unknown"
+        console.print(f"[cyan]{idx}.[/cyan] {os.path.basename(path)}  [dim]{dt}[/dim]")
+        shown.append((idx, path))
+
+    try:
+        choice = safe_prompt(
+            "[bold blue]Выберите номер бэкапа[/bold blue]",
+            choices=[str(i) for i, _ in shown],
+        )
+    except Exception:
+        return
+
+    sel_path = shown[int(choice) - 1][1]
+
+    console.print("[red]Внимание: текущие файлы проекта будут перезаписаны выбранным бэкапом.[/red]")
+    if not safe_confirm("[yellow]Продолжить восстановление из бэкапа?[/yellow]"):
+        return
+
+    if is_service_exists(SERVICE_NAME):
+        console.print("[blue]Останавливаю службу перед восстановлением...[/blue]")
+        subprocess.run(["sudo", "systemctl", "stop", SERVICE_NAME])
+
+    install_rsync_if_needed()
+
+    console.print("[yellow]Копирую файлы из бэкапа в проект...[/yellow]")
+    rc = subprocess.run(
+        ["rsync", "-a", "--delete", f"{sel_path}/", f"{PROJECT_DIR}/"],
+        check=False,
+    ).returncode
+    if rc != 0:
+        console.print("[red]❌ Ошибка rsync при восстановлении[/red]")
+        return
+
+    install_dependencies()
+    fix_permissions()
+    restart_service()
+    console.print("[green]✅ Восстановление из бэкапа завершено[/green]")


 def auto_update_cli():
-    """Обновляет CLI, если отличается от последней версии. Перезапускает при необходимости."""
    console.print("[yellow]Проверка обновлений CLI...[/yellow]")
    try:
        url = "https://raw.githubusercontent.com/Vladless/Solo_bot/dev/cli_launcher.py"
@@ -99,7 +242,7 @@ def auto_update_cli():
            console.print("[green]Доступна новая версия CLI. Обновляю...[/green]")
            with open(current_path, "w", encoding="utf-8") as f:
                f.write(latest_text)
-            os.chmod(current_path, 0o755)
+            os.chmod(current_path, 0o644)
            console.print("[green]CLI обновлён. Перезапуск...[/green]")
            os.execv(sys.executable, [sys.executable, current_path])
        else:
@@ -109,7 +252,6 @@ def auto_update_cli():


 def fix_permissions():
-    """Устанавливает корректные права на все файлы и папки проекта"""
    console.print("[yellow]Восстанавливаю владельца и права доступа к проекту...[/yellow]")

    try:
@@ -151,19 +293,28 @@ def install_rsync_if_needed():

 def clean_project_dir_safe(update_buttons=False, update_img=False):
    console.print("[yellow]Очистка проекта перед обновлением...[/yellow]")
-    preserved_paths = {
+
+    preserved_paths = set()
+
+    preserved_paths.update([
        os.path.join(PROJECT_DIR, "config.py"),
        os.path.join(PROJECT_DIR, "handlers", "texts.py"),
        os.path.join(PROJECT_DIR, ".git"),
-    }
+        os.path.join(PROJECT_DIR, "modules"),
+    ])
+
+    for root, dirs, files in os.walk(os.path.join(PROJECT_DIR, "modules")):
+        for name in dirs + files:
+            preserved_paths.add(os.path.join(root, name))

    if not update_buttons:
        preserved_paths.add(os.path.join(PROJECT_DIR, "handlers", "buttons.py"))
+
    if not update_img:
        preserved_paths.add(os.path.join(PROJECT_DIR, "img"))
-        for root, _, files in os.walk(os.path.join(PROJECT_DIR, "img")):
-            for file in files:
-                preserved_paths.add(os.path.join(root, file))
+        for root, dirs, files in os.walk(os.path.join(PROJECT_DIR, "img")):
+            for name in dirs + files:
+                preserved_paths.add(os.path.join(root, name))

    for root, dirs, files in os.walk(PROJECT_DIR, topdown=False):
        for file in files:
@@ -179,10 +330,17 @@ def clean_project_dir_safe(update_buttons=False, update_img=False):

        for dir in dirs:
            dir_path = os.path.join(root, dir)
-            if os.path.abspath(dir_path) == os.path.join(PROJECT_DIR, "handlers"):
+
+            if os.path.abspath(dir_path) in [
+                os.path.join(PROJECT_DIR, "handlers"),
+                os.path.join(PROJECT_DIR, "img"),
+                os.path.join(PROJECT_DIR, "modules"),
+            ]:
                continue
-            if not update_img and os.path.abspath(dir_path) == os.path.join(PROJECT_DIR, "img"):
+
+            if os.path.abspath(dir_path).startswith(os.path.join(PROJECT_DIR, "modules") + os.sep):
                continue
+
            try:
                os.rmdir(dir_path)
            except Exception:
@@ -215,13 +373,13 @@ def install_dependencies():
                shutil.rmtree("venv")
                console.print("[yellow]Удалён старый venv[/yellow]")

-            subprocess.run(f"{python312_path} -m venv venv", shell=True, check=True)
+            subprocess.run([python312_path, "-m", "venv", "venv"], check=True)

            progress.update(task_id, description="Установка зависимостей...")
            subprocess.run(
-                "bash -c 'source venv/bin/activate && pip install -r requirements.txt'",
-                shell=True,
+                [os.path.join("venv", "bin", "pip"), "install", "-r", "requirements.txt"],
                check=True,
+                cwd=PROJECT_DIR,
            )

            progress.update(task_id, description="Установка завершена")
@@ -235,7 +393,7 @@ def restart_service():
    if is_service_exists(SERVICE_NAME):
        console.print("[blue]🚀 Перезапуск службы...[/blue]")
        with console.status("[bold yellow]Перезапуск...[/bold yellow]"):
-            subprocess.run(f"sudo systemctl restart {SERVICE_NAME}", shell=True)
+            subprocess.run(["sudo", "systemctl", "restart", SERVICE_NAME])
    else:
        console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")

@@ -270,21 +428,40 @@ def update_from_beta():
    local_version = get_local_version()
    remote_version = get_remote_version(branch="dev")

+    console.print(
+        Panel(
+            "[bold red]Обновление на DEV / BETA-ветку[/bold red]\n\n"
+            "[white]"
+            "• Dev-ветка может содержать изменения, которые ещё находятся в доработке.\n"
+            "• Возможны ошибки и непредсказуемое поведение отдельных функций, особенно режима стран.\n\n"
+            "• BETA-версии бота в первую очередь ориентированы на опытных пользователей, "
+            "готовых протестировать новые возможности и осознанно работать с обновлённым функционалом.\n"
+            "[/white]\n\n"
+            "[yellow]Перед началом обновления CLI автоматически создаёт резервную копию проекта, "
+            "что позволит при необходимости безопасно восстановиться из бэкапа.[/yellow]",
+            border_style="red",
+            title="[bold red]Нестабильная ветка разработки[/bold red]",
+            padding=(1, 2),
+        )
+    )
+
    if local_version and remote_version:
        console.print(f"[cyan]Локальная версия: {local_version} | Последняя в dev: {remote_version}[/cyan]")
        if local_version == remote_version:
-            if not Confirm.ask("[yellow]Версия актуальна. Обновить всё равно?[/yellow]"):
+            if not safe_confirm("[yellow]Версия актуальна. Обновить всё равно?[/yellow]"):
                return

-    if not Confirm.ask("[yellow]Подтвердите обновление Solobot с ветки DEV[/yellow]"):
+    if not safe_confirm(
+        "[bold red]Продолжить обновление на dev-ветку с учётом возможных особенностей работы?[/bold red]"
+    ):
        return

    console.print("[red]ВНИМАНИЕ! Папка бота будет перезаписана![/red]")
-    if not Confirm.ask("[red]Продолжить обновление?[/red]"):
+    if not safe_confirm("[red]Продолжить обновление?[/red]"):
        return

-    update_buttons = Confirm.ask("[yellow]Обновлять файл buttons.py?[/yellow]", default=False)
-    update_img = Confirm.ask("[yellow]Обновлять папку img?[/yellow]", default=False)
+    update_buttons = safe_confirm("[yellow]Обновлять файл buttons.py?[/yellow]", default=False)
+    update_img = safe_confirm("[yellow]Обновлять папку img?[/yellow]", default=False)

    backup_project()
    install_git_if_needed()
@@ -306,8 +483,19 @@ def update_from_beta():
        exclude_options += "--exclude=img "
    if not update_buttons:
        exclude_options += "--exclude=handlers/buttons.py "
+    exclude_options += "--exclude=modules "

-    subprocess.run(f"rsync -a {exclude_options} {TEMP_DIR}/ {PROJECT_DIR}/", shell=True)
+    rsync_cmd = ["rsync", "-a"] + [x for x in exclude_options.split() if x] + [f"{TEMP_DIR}/", f"{PROJECT_DIR}/"]
+    subprocess.run(rsync_cmd)
+
+    modules_path = os.path.join(PROJECT_DIR, "modules")
+    if not os.path.exists(modules_path):
+        console.print("[yellow]Папка modules отсутствует — создаю вручную...[/yellow]")
+        try:
+            os.makedirs(modules_path, exist_ok=True)
+            console.print("[green]Папка modules успешно создана.[/green]")
+        except Exception as e:
+            console.print(f"[red]❌ Не удалось создать папку modules: {e}[/red]")

    if os.path.exists(os.path.join(TEMP_DIR, ".git")):
        subprocess.run(["cp", "-r", os.path.join(TEMP_DIR, ".git"), PROJECT_DIR])
@@ -321,16 +509,16 @@ def update_from_beta():


 def update_from_release():
-    if not Confirm.ask("[yellow]Подтвердите обновление Solobot до одного из последних релизов[/yellow]"):
+    if not safe_confirm("[yellow]Подтвердите обновление Solobot до одного из последних релизов[/yellow]"):
        return

    console.print("[red]ВНИМАНИЕ! Папка бота будет полностью перезаписана![/red]")
    console.print("[red]  Исключения: папка img и файл handlers/buttons.py[/red]")
-    if not Confirm.ask("[red]Вы точно хотите продолжить?[/red]"):
+    if not safe_confirm("[red]Вы точно хотите продолжить?[/red]"):
        return

-    update_buttons = Confirm.ask("[yellow]Обновлять файл buttons.py?[/yellow]", default=False)
-    update_img = Confirm.ask("[yellow]Обновлять папку img?[/yellow]", default=False)
+    update_buttons = safe_confirm("[yellow]Обновлять файл buttons.py?[/yellow]", default=False)
+    update_img = safe_confirm("[yellow]Обновлять папку img?[/yellow]", default=False)

    backup_project()
    install_git_if_needed()
@@ -348,20 +536,19 @@ def update_from_release():
        for idx, tag in enumerate(tag_choices, 1):
            console.print(f"[cyan]{idx}.[/cyan] {tag}")

-        selected = Prompt.ask(
+        selected = safe_prompt(
            "[bold blue]Выберите номер релиза[/bold blue]",
            choices=[str(i) for i in range(1, len(tag_choices) + 1)],
        )
        tag_name = tag_choices[int(selected) - 1]

-        if not Confirm.ask(f"[yellow]Подтвердите установку релиза {tag_name}[/yellow]"):
+        if not safe_confirm(f"[yellow]Подтвердите установку релиза {tag_name}[/yellow]"):
            return

        console.print(f"[cyan]Клонируем релиз {tag_name} во временную папку...[/cyan]")
        subprocess.run(["rm", "-rf", TEMP_DIR])
        subprocess.run(
-            f"git clone --branch {tag_name} {GITHUB_REPO} {TEMP_DIR}",
-            shell=True,
+            ["git", "clone", "--branch", tag_name, GITHUB_REPO, TEMP_DIR],
            check=True,
        )

@@ -374,8 +561,19 @@ def update_from_release():
            exclude_options += "--exclude=img "
        if not update_buttons:
            exclude_options += "--exclude=handlers/buttons.py "
+        exclude_options += "--exclude=modules "

-        subprocess.run(f"rsync -a {exclude_options} {TEMP_DIR}/ {PROJECT_DIR}/", shell=True)
+        rsync_cmd = ["rsync", "-a"] + exclude_options.split() + [f"{TEMP_DIR}/", f"{PROJECT_DIR}/"]
+        subprocess.run(rsync_cmd)
+
+        modules_path = os.path.join(PROJECT_DIR, "modules")
+        if not os.path.exists(modules_path):
+            console.print("[yellow]Папка modules отсутствует — создаю вручную...[/yellow]")
+            try:
+                os.makedirs(modules_path, exist_ok=True)
+                console.print("[green]Папка modules успешно создана.[/green]")
+            except Exception as e:
+                console.print(f"[red]❌ Не удалось создать папку modules: {e}[/red]")

        if os.path.exists(os.path.join(TEMP_DIR, ".git")):
            subprocess.run(["cp", "-r", os.path.join(TEMP_DIR, ".git"), PROJECT_DIR])
@@ -405,7 +603,7 @@ def show_update_menu():
    table.add_row("3", "Назад в меню")

    console.print(table)
-    choice = Prompt.ask("[bold blue]Введите номер[/bold blue]", choices=["1", "2", "3"])
+    choice = safe_prompt("[bold blue]Введите номер[/bold blue]", choices=["1", "2", "3"])

    if choice == "1":
        update_from_beta()
@@ -414,7 +612,7 @@ def show_update_menu():


 def show_menu():
-    table = Table(title="Solobot CLI v0.2.8", title_style="bold magenta", header_style="bold blue")
+    table = Table(title="Solobot CLI v0.3.9", title_style="bold magenta", header_style="bold blue")
    table.add_column("№", justify="center", style="cyan", no_wrap=True)
    table.add_column("Операция", style="white")
    table.add_row("1", "Запустить бота (systemd)")
@@ -424,7 +622,8 @@ def show_menu():
    table.add_row("5", "Показать логи (80 строк)")
    table.add_row("6", "Показать статус")
    table.add_row("7", "Обновить Solobot")
-    table.add_row("8", "Выход")
+    table.add_row("8", "Восстановить из бэкапа")
+    table.add_row("9", "Выход")
    console.print(table)


@@ -435,9 +634,9 @@ def main():
    try:
        while True:
            show_menu()
-            choice = Prompt.ask(
+            choice = safe_prompt(
                "[bold blue]👉 Введите номер действия[/bold blue]",
-                choices=[str(i) for i in range(1, 9)],
+                choices=[str(i) for i in range(1, 10)],
                show_choices=False,
            )
            if choice == "1":
@@ -446,17 +645,17 @@ def main():
                else:
                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
            elif choice == "2":
-                if Confirm.ask("[green]Вы действительно хотите запустить main.py вручную?[/green]"):
+                if safe_confirm("[green]Вы действительно хотите запустить main.py вручную?[/green]"):
                    subprocess.run(["venv/bin/python", "main.py"])
            elif choice == "3":
                if is_service_exists(SERVICE_NAME):
-                    if Confirm.ask("[yellow]Вы действительно хотите перезапустить бота?[/yellow]"):
+                    if safe_confirm("[yellow]Вы действительно хотите перезапустить бота?[/yellow]"):
                        subprocess.run(["sudo", "systemctl", "restart", SERVICE_NAME])
                else:
                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
            elif choice == "4":
                if is_service_exists(SERVICE_NAME):
-                    if Confirm.ask("[red]Вы уверены, что хотите остановить бота?[/red]"):
+                    if safe_confirm("[red]Вы уверены, что хотите остановить бота?[/red]"):
                        subprocess.run(["sudo", "systemctl", "stop", SERVICE_NAME])
                else:
                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
@@ -481,6 +680,8 @@ def main():
            elif choice == "7":
                show_update_menu()
            elif choice == "8":
+                restore_from_backup()
+            elif choice == "9":
                console.print("[bold cyan]Выход из CLI. Удачного дня![/bold cyan]")
                break
    except KeyboardInterrupt:
@@ -0,0 +1,27 @@
+from database import async_session_maker
+from database.db import warm_pool
+from database.tariffs import initialize_all_tariff_weights
+
+from .settings.buttons_config import BUTTONS_CONFIG, load_buttons_config, update_buttons_config
+from .settings.management_config import MANAGEMENT_CONFIG, load_management_config, update_management_config
+from .settings.modes_config import MODES_CONFIG, load_modes_config, update_modes_config
+from .settings.money_config import MONEY_CONFIG, load_money_config, update_money_config
+from .settings.notifications_config import NOTIFICATIONS_CONFIG, load_notifications_config, update_notifications_config
+from .settings.payments_config import PAYMENTS_CONFIG, load_payments_config, update_payments_config
+from .settings.providers_order_config import PROVIDERS_ORDER, load_providers_order, update_providers_order
+from .settings.tariffs_config import TARIFFS_CONFIG, load_tariffs_config, update_tariffs_config
+
+
+async def bootstrap() -> None:
+    await warm_pool()
+    async with async_session_maker() as session:
+        await initialize_all_tariff_weights(session)
+        await load_buttons_config(session)
+        await load_notifications_config(session)
+        await load_modes_config(session)
+        await load_payments_config(session)
+        await load_providers_order(session)
+        await load_money_config(session)
+        await load_management_config(session)
+        await load_tariffs_config(session)
+        await session.commit()
@@ -0,0 +1 @@
+PAYMENT_SYSTEMS_EXCLUDED = ("referral", "coupon", "cashback", "admin")
@@ -0,0 +1,65 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+from ..defaults import DEFAULT_BUTTONS_CONFIG
+
+
+BUTTONS_CONFIG: dict[str, bool] = DEFAULT_BUTTONS_CONFIG.copy()
+BUTTONS_CONFIG.setdefault("ANDROID_TV_BUTTON_ENABLE", False)
+BUTTONS_CONFIG.setdefault("COUPON_BUTTON_ENABLE", True)
+
+
+async def load_buttons_config(session: AsyncSession) -> None:
+    stmt = select(Setting).where(Setting.key == "BUTTONS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        buttons_config = DEFAULT_BUTTONS_CONFIG.copy()
+        buttons_config.setdefault("ANDROID_TV_BUTTON_ENABLE", False)
+        buttons_config.setdefault("COUPON_BUTTON_ENABLE", True)
+        setting = Setting(
+            key="BUTTONS_CONFIG",
+            value=buttons_config,
+            description="Конфигурация кнопок бота",
+        )
+        session.add(setting)
+    else:
+        stored = setting.value or {}
+        buttons_config = DEFAULT_BUTTONS_CONFIG.copy()
+        buttons_config.update(stored)
+        buttons_config.setdefault("ANDROID_TV_BUTTON_ENABLE", False)
+        buttons_config.setdefault("COUPON_BUTTON_ENABLE", True)
+        setting.value = buttons_config
+
+    BUTTONS_CONFIG.clear()
+    BUTTONS_CONFIG.update(buttons_config)
+    await session.flush()
+
+
+async def update_buttons_config(session: AsyncSession, new_values: dict[str, bool]) -> None:
+    stmt = select(Setting).where(Setting.key == "BUTTONS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key="BUTTONS_CONFIG",
+            value=new_values,
+            description="Конфигурация кнопок бота",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_values
+
+    await session.commit()
+
+    buttons_config = DEFAULT_BUTTONS_CONFIG.copy()
+    buttons_config.update(new_values)
+    buttons_config.setdefault("ANDROID_TV_BUTTON_ENABLE", False)
+    buttons_config.setdefault("COUPON_BUTTON_ENABLE", True)
+
+    BUTTONS_CONFIG.clear()
+    BUTTONS_CONFIG.update(buttons_config)
@@ -0,0 +1,60 @@
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+from ..defaults import DEFAULT_MANAGEMENT_CONFIG
+
+
+MANAGEMENT_CONFIG: dict[str, Any] = DEFAULT_MANAGEMENT_CONFIG.copy()
+MANAGEMENT_SETTING_KEY = "MANAGEGENT_CONFIG"
+
+
+async def load_management_config(session: AsyncSession) -> None:
+    stmt = select(Setting).where(Setting.key == MANAGEMENT_SETTING_KEY)
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        management_config = DEFAULT_MANAGEMENT_CONFIG.copy()
+        setting = Setting(
+            key=MANAGEMENT_SETTING_KEY,
+            value=management_config,
+            description="Конфигурация управления ботом",
+        )
+        session.add(setting)
+    else:
+        stored = setting.value or {}
+        management_config = DEFAULT_MANAGEMENT_CONFIG.copy()
+        management_config.update(stored)
+        setting.value = management_config
+
+    MANAGEMENT_CONFIG.clear()
+    MANAGEMENT_CONFIG.update(management_config)
+    await session.flush()
+
+
+async def update_management_config(session: AsyncSession, new_values: dict[str, Any]) -> None:
+    stmt = select(Setting).where(Setting.key == MANAGEMENT_SETTING_KEY)
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key=MANAGEMENT_SETTING_KEY,
+            value=new_values,
+            description="Конфигурация управления ботом",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_values
+
+    await session.commit()
+
+    management_config = DEFAULT_MANAGEMENT_CONFIG.copy()
+    management_config.update(new_values)
+
+    MANAGEMENT_CONFIG.clear()
+    MANAGEMENT_CONFIG.update(management_config)
@@ -0,0 +1,57 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+from ..defaults import DEFAULT_MODES_CONFIG
+
+
+MODES_CONFIG: dict[str, bool] = DEFAULT_MODES_CONFIG.copy()
+
+
+async def load_modes_config(session: AsyncSession) -> None:
+    stmt = select(Setting).where(Setting.key == "MODES_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        modes_config = DEFAULT_MODES_CONFIG.copy()
+        setting = Setting(
+            key="MODES_CONFIG",
+            value=modes_config,
+            description="Конфигурация режимов работы бота",
+        )
+        session.add(setting)
+    else:
+        stored = setting.value or {}
+        modes_config = DEFAULT_MODES_CONFIG.copy()
+        modes_config.update(stored)
+        setting.value = modes_config
+
+    MODES_CONFIG.clear()
+    MODES_CONFIG.update(modes_config)
+    await session.flush()
+
+
+async def update_modes_config(session: AsyncSession, new_values: dict[str, bool]) -> None:
+    stmt = select(Setting).where(Setting.key == "MODES_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key="MODES_CONFIG",
+            value=new_values,
+            description="Конфигурация режимов работы бота",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_values
+
+    await session.commit()
+
+    modes_config = DEFAULT_MODES_CONFIG.copy()
+    modes_config.update(new_values)
+
+    MODES_CONFIG.clear()
+    MODES_CONFIG.update(modes_config)
@@ -0,0 +1,75 @@
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+from ..defaults import DEFAULT_MONEY_CONFIG
+
+
+MONEY_CONFIG: dict[str, Any] = DEFAULT_MONEY_CONFIG.copy()
+
+
+def get_currency_mode() -> tuple[str, bool]:
+    mode_cfg = MONEY_CONFIG.get("CURRENCY_MODE", "RUB")
+    raw = str(mode_cfg or "RUB").upper()
+
+    if raw not in ("RUB", "USD", "RUB+USD", "RUB+USD_ONE_SCREEN"):
+        raw = "RUB"
+
+    one_screen = raw == "RUB+USD_ONE_SCREEN"
+    if raw in ("RUB+USD", "RUB+USD_ONE_SCREEN"):
+        base_mode = "RUB+USD"
+    else:
+        base_mode = raw
+
+    return base_mode, one_screen
+
+
+async def load_money_config(session: AsyncSession) -> None:
+    stmt = select(Setting).where(Setting.key == "MONEY_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        money_config = DEFAULT_MONEY_CONFIG.copy()
+        setting = Setting(
+            key="MONEY_CONFIG",
+            value=money_config,
+            description="Конфигурация валютных настроек",
+        )
+        session.add(setting)
+    else:
+        stored = setting.value or {}
+        money_config = DEFAULT_MONEY_CONFIG.copy()
+        money_config.update(stored)
+        setting.value = money_config
+
+    MONEY_CONFIG.clear()
+    MONEY_CONFIG.update(money_config)
+    await session.flush()
+
+
+async def update_money_config(session: AsyncSession, new_values: dict[str, Any]) -> None:
+    stmt = select(Setting).where(Setting.key == "MONEY_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key="MONEY_CONFIG",
+            value=new_values,
+            description="Конфигурация валютных настроек",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_values
+
+    await session.commit()
+
+    money_config = DEFAULT_MONEY_CONFIG.copy()
+    money_config.update(new_values)
+
+    MONEY_CONFIG.clear()
+    MONEY_CONFIG.update(money_config)
@@ -0,0 +1,59 @@
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+from ..defaults import DEFAULT_NOTIFICATIONS_CONFIG
+
+
+NOTIFICATIONS_CONFIG: dict[str, Any] = DEFAULT_NOTIFICATIONS_CONFIG.copy()
+
+
+async def load_notifications_config(session: AsyncSession) -> None:
+    stmt = select(Setting).where(Setting.key == "NOTIFICATIONS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        notifications_config = DEFAULT_NOTIFICATIONS_CONFIG.copy()
+        setting = Setting(
+            key="NOTIFICATIONS_CONFIG",
+            value=notifications_config,
+            description="Конфигурация уведомлений",
+        )
+        session.add(setting)
+    else:
+        stored = setting.value or {}
+        notifications_config = DEFAULT_NOTIFICATIONS_CONFIG.copy()
+        notifications_config.update(stored)
+        setting.value = notifications_config
+
+    NOTIFICATIONS_CONFIG.clear()
+    NOTIFICATIONS_CONFIG.update(notifications_config)
+    await session.flush()
+
+
+async def update_notifications_config(session: AsyncSession, new_values: dict[str, Any]) -> None:
+    stmt = select(Setting).where(Setting.key == "NOTIFICATIONS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key="NOTIFICATIONS_CONFIG",
+            value=new_values,
+            description="Конфигурация уведомлений",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_values
+
+    await session.commit()
+
+    notifications_config = DEFAULT_NOTIFICATIONS_CONFIG.copy()
+    notifications_config.update(new_values)
+
+    NOTIFICATIONS_CONFIG.clear()
+    NOTIFICATIONS_CONFIG.update(notifications_config)
@@ -0,0 +1,57 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+from ..defaults import DEFAULT_PAYMENTS_CONFIG
+
+
+PAYMENTS_CONFIG: dict[str, bool] = DEFAULT_PAYMENTS_CONFIG.copy()
+
+
+async def load_payments_config(session: AsyncSession) -> None:
+    stmt = select(Setting).where(Setting.key == "PAYMENTS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        payments_config = DEFAULT_PAYMENTS_CONFIG.copy()
+        setting = Setting(
+            key="PAYMENTS_CONFIG",
+            value=payments_config,
+            description="Конфигурация платёжных провайдеров",
+        )
+        session.add(setting)
+    else:
+        stored = setting.value or {}
+        payments_config = DEFAULT_PAYMENTS_CONFIG.copy()
+        payments_config.update(stored)
+        setting.value = payments_config
+
+    PAYMENTS_CONFIG.clear()
+    PAYMENTS_CONFIG.update(payments_config)
+    await session.flush()
+
+
+async def update_payments_config(session: AsyncSession, new_values: dict[str, bool]) -> None:
+    stmt = select(Setting).where(Setting.key == "PAYMENTS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key="PAYMENTS_CONFIG",
+            value=new_values,
+            description="Конфигурация платёжных провайдеров",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_values
+
+    await session.commit()
+
+    payments_config = DEFAULT_PAYMENTS_CONFIG.copy()
+    payments_config.update(new_values)
+
+    PAYMENTS_CONFIG.clear()
+    PAYMENTS_CONFIG.update(payments_config)
@@ -0,0 +1,38 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+PROVIDERS_ORDER: dict[str, int] = {}
+
+
+async def load_providers_order(session: AsyncSession) -> None:
+    stmt = select(Setting).where(Setting.key == "PROVIDERS_ORDER")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    PROVIDERS_ORDER.clear()
+    if setting and isinstance(setting.value, dict):
+        PROVIDERS_ORDER.update({k: int(v) for k, v in setting.value.items()})
+    await session.flush()
+
+
+async def update_providers_order(session: AsyncSession, new_order: dict[str, int]) -> None:
+    stmt = select(Setting).where(Setting.key == "PROVIDERS_ORDER")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key="PROVIDERS_ORDER",
+            value=new_order,
+            description="Порядок отображения платёжных провайдеров",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_order
+
+    await session.commit()
+
+    PROVIDERS_ORDER.clear()
+    PROVIDERS_ORDER.update(new_order)
@@ -0,0 +1,193 @@
+from math import ceil
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Setting
+
+
+TARIFFS_CONFIG: dict[str, Any] = {
+    "ALLOW_DOWNGRADE": True,
+    "KEY_ADDONS_PACK_MODE": "all",
+    "KEY_ADDONS_PRICE_BASE_MODE": "current",
+}
+
+
+async def load_tariffs_config(session: AsyncSession) -> None:
+    """Загружает конфиг тарифов из БД."""
+    stmt = select(Setting).where(Setting.key == "TARIFFS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        tariffs_config = TARIFFS_CONFIG.copy()
+        setting = Setting(
+            key="TARIFFS_CONFIG",
+            value=tariffs_config,
+            description="Конфигурация тарифов",
+        )
+        session.add(setting)
+    else:
+        stored = setting.value or {}
+        tariffs_config = TARIFFS_CONFIG.copy()
+        tariffs_config.update(stored)
+        setting.value = tariffs_config
+
+    TARIFFS_CONFIG.clear()
+    TARIFFS_CONFIG.update(tariffs_config)
+    await session.flush()
+
+
+async def update_tariffs_config(session: AsyncSession, new_values: dict[str, Any]) -> None:
+    """Обновляет конфиг тарифов."""
+    stmt = select(Setting).where(Setting.key == "TARIFFS_CONFIG")
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(
+            key="TARIFFS_CONFIG",
+            value=new_values,
+            description="Конфигурация тарифов",
+        )
+        session.add(setting)
+    else:
+        setting.value = new_values
+
+    await session.commit()
+
+    tariffs_config = TARIFFS_CONFIG.copy()
+    tariffs_config.update(new_values)
+
+    TARIFFS_CONFIG.clear()
+    TARIFFS_CONFIG.update(tariffs_config)
+
+
+def calc_extra_devices_price(tariff: dict[str, Any], device_limit: int) -> int:
+    base_device_limit = int(tariff.get("device_limit") or 1)
+    extra_devices = max(0, device_limit - base_device_limit)
+    if extra_devices <= 0:
+        return 0
+
+    step_price = int(tariff.get("device_step_rub") or 0)
+    overrides = tariff.get("device_overrides") or {}
+
+    override_total = overrides.get(str(device_limit))
+    if override_total is not None:
+        return int(ceil(float(override_total)))
+
+    return int(ceil(extra_devices * step_price))
+
+
+def calc_extra_traffic_price(tariff: dict[str, Any], traffic_gb: int | None) -> int:
+    if traffic_gb is None:
+        return 0
+
+    traffic_limit_bytes = tariff.get("traffic_limit")
+    if traffic_limit_bytes:
+        base_traffic_gb = ceil(traffic_limit_bytes / 1024 / 1024 / 1024)
+    else:
+        base_traffic_gb = 0
+
+    step_price = int(tariff.get("traffic_step_rub") or 0)
+    overrides = tariff.get("traffic_overrides") or {}
+
+    override_total = overrides.get(str(traffic_gb))
+    if override_total is not None:
+        return int(ceil(float(override_total)))
+
+    if traffic_gb == 0:
+        return 0
+
+    extra_gb = max(0, traffic_gb - base_traffic_gb)
+    if extra_gb <= 0:
+        return 0
+
+    return int(ceil(extra_gb * step_price))
+
+
+def calculate_config_price(
+    tariff: dict[str, Any],
+    duration_days: int,
+    device_limit: int,
+    traffic_gb: int | None,
+) -> int:
+    base_duration = int(tariff.get("duration_days") or 0) or duration_days or 30
+    if base_duration <= 0:
+        base_duration = duration_days or 30
+
+    base_price = int(tariff.get("price_rub") or 0)
+
+    duration_multiplier = duration_days / base_duration
+    base_price_scaled = base_price * duration_multiplier
+
+    extra_devices_price = calc_extra_devices_price(tariff, device_limit)
+    extra_traffic_price = calc_extra_traffic_price(tariff, traffic_gb)
+
+    total = base_price_scaled + extra_devices_price + extra_traffic_price
+    return int(ceil(total))
+
+
+def normalize_tariff_config(tariff: dict[str, Any]) -> dict[str, Any]:
+    raw_duration_options = tariff.get("duration_options") or []
+    duration_options: list[int] = []
+    for value in raw_duration_options:
+        try:
+            v = int(value)
+        except (TypeError, ValueError):
+            continue
+        if v > 0:
+            duration_options.append(v)
+    if not duration_options:
+        base_duration = int(tariff.get("duration_days") or 0) or 30
+        duration_options = [base_duration]
+    duration_options = sorted(set(duration_options))
+
+    raw_device_options = tariff.get("device_options") or []
+    device_options: list[int] = []
+    for value in raw_device_options:
+        try:
+            v = int(value)
+        except (TypeError, ValueError):
+            continue
+        if v > 0:
+            device_options.append(v)
+    if not device_options:
+        base_device_limit = int(tariff.get("device_limit") or 0)
+        if base_device_limit > 0:
+            device_options = [base_device_limit]
+        else:
+            device_options = []
+    device_options = sorted(set(device_options))
+
+    raw_traffic_options = tariff.get("traffic_options_gb")
+    traffic_options_gb: list[int] | None
+    if raw_traffic_options is None:
+        traffic_options_gb = None
+    else:
+        traffic_values: list[int] = []
+        has_unlimited = False
+        for value in raw_traffic_options:
+            try:
+                v = int(value)
+            except (TypeError, ValueError):
+                continue
+            if v == 0:
+                has_unlimited = True
+            elif v > 0:
+                traffic_values.append(v)
+        if not traffic_values and not has_unlimited:
+            traffic_options_gb = None
+        else:
+            unique_values = sorted(set(traffic_values))
+            if has_unlimited:
+                traffic_options_gb = [0] + unique_values
+            else:
+                traffic_options_gb = unique_values
+
+    return {
+        "duration_options": duration_options,
+        "device_options": device_options,
+        "traffic_options_gb": traffic_options_gb,
+    }
@@ -8,21 +8,50 @@ from database.models import Coupon, CouponUsage
 from logger import logger


-async def create_coupon(session: AsyncSession, code: str, amount: int, usage_limit: int, days: int = None) -> bool:
+async def create_coupon(
+    session: AsyncSession,
+    code: str,
+    amount: int | None,
+    usage_limit: int,
+    days: int | None = None,
+    new_users_only: bool = False,
+    percent: int | None = None,
+    max_discount_amount: int | None = None,
+    min_order_amount: int | None = None,
+) -> bool:
    try:
        exists = await session.scalar(select(Coupon.id).where(Coupon.code == code))
        if exists:
            logger.warning(f"[Coupon] ⚠️ Купон с кодом {code} уже существует.")
            return False

+        if percent is not None:
+            try:
+                percent_value = int(percent)
+            except (TypeError, ValueError):
+                logger.warning(f"[Coupon] ⚠️ Некорректный процент для купона {code}.")
+                return False
+
+            if percent_value <= 0 or percent_value > 100:
+                logger.warning(f"[Coupon] ⚠️ процент должен быть в диапазоне 1..100 для купона {code}.")
+                return False
+
+            if (amount or 0) > 0 or (days or 0) > 0:
+                logger.warning(f"[Coupon] ⚠️ Купон {code} не может одновременно иметь percent и amount/days.")
+                return False
+
        await session.execute(
            insert(Coupon).values(
                code=code,
-                amount=amount,
+                amount=int(amount) if amount is not None else 0,
                usage_limit=usage_limit,
                usage_count=0,
                is_used=False,
                days=days,
+                new_users_only=new_users_only,
+                percent=percent,
+                max_discount_amount=max_discount_amount,
+                min_order_amount=min_order_amount,
            )
        )
        await session.commit()
@@ -84,6 +113,7 @@ async def create_coupon_usage(session: AsyncSession, coupon_id: int, user_id: in
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при сохранении использования купона: {e}")
        await session.rollback()
+        raise


 async def check_coupon_usage(session: AsyncSession, coupon_id: int, user_id: int) -> bool:
@@ -107,3 +137,24 @@ async def update_coupon_usage_count(session: AsyncSession, coupon_id: int):
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при обновлении купона {coupon_id}: {e}")
        await session.rollback()
+        raise
+
+
+def apply_percent_coupon(price_rub: int, coupon: Coupon) -> tuple[int, int]:
+    percent = coupon.percent
+    if percent is None:
+        return price_rub, 0
+
+    if coupon.min_order_amount is not None and price_rub < int(coupon.min_order_amount):
+        return price_rub, 0
+
+    discount = (price_rub * int(percent)) // 100
+
+    if coupon.max_discount_amount is not None:
+        discount = min(discount, int(coupon.max_discount_amount))
+
+    final_price = price_rub - discount
+    if final_price < 0:
+        final_price = 0
+
+    return final_price, discount
@@ -1,11 +1,50 @@
+import asyncio
+
+from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 from sqlalchemy.orm import declarative_base

-from config import DATABASE_URL
+from config import DATABASE_URL, DB_MAX_OVERFLOW, DB_POOL_SIZE


-engine = create_async_engine(DATABASE_URL, echo=False, future=True, pool_size=20, max_overflow=30, pool_timeout=15)
+CONCURRENT_UPDATES_LIMIT = DB_POOL_SIZE + DB_MAX_OVERFLOW
+MAX_UPDATE_AGE_SEC = 28
+CONCURRENT_UPDATES_WAIT_TIMEOUT_SEC = 8
+CONCURRENT_UPDATES_GATE_LIMIT = 150
+CONCURRENT_UPDATES_GATE_WAIT_SEC = 2

-async_session_maker = async_sessionmaker(bind=engine, expire_on_commit=False, class_=AsyncSession)
+engine = create_async_engine(
+    DATABASE_URL,
+    echo=False,
+    future=True,
+    pool_size=DB_POOL_SIZE,
+    max_overflow=DB_MAX_OVERFLOW,
+    pool_timeout=60,
+    pool_pre_ping=True,
+    pool_recycle=300,
+)
+
+async_session_maker = async_sessionmaker(
+    bind=engine,
+    expire_on_commit=False,
+    class_=AsyncSession,
+)

 Base = declarative_base()
+
+WARM_POOL_COUNT = 10
+
+
+async def warm_pool() -> None:
+    """
+    Прогревает пул соединений при старте.
+    """
+
+    async def _one() -> None:
+        async with async_session_maker() as session:
+            await session.execute(text("SELECT 1"))
+
+    count = min(WARM_POOL_COUNT, DB_POOL_SIZE)
+    if count <= 0:
+        return
+    await asyncio.gather(*[asyncio.create_task(_one()) for _ in range(count)])
@@ -18,6 +18,9 @@ async def store_gift_link(
    tariff_id: int | None = None,
    is_unlimited: bool = False,
    max_usages: int | None = None,
+    selected_device_limit: int | None = None,
+    selected_traffic_gb: int | None = None,
+    selected_price_rub: int | None = None,
 ):
    try:
        stmt = insert(Gift).values(
@@ -32,12 +35,19 @@ async def store_gift_link(
            tariff_id=tariff_id,
            is_unlimited=is_unlimited,
            max_usages=max_usages,
+            selected_device_limit=selected_device_limit,
+            selected_traffic_gb=selected_traffic_gb,
+            selected_price_rub=selected_price_rub,
        )
        await session.execute(stmt)
        await session.commit()
-        logger.info(f"🎁 Подарок {gift_id} сохранён (tariff_id={tariff_id}, max_usages={max_usages})")
+        logger.info(
+            f"🎁 Подарок {gift_id} сохранён "
+            f"(tariff_id={tariff_id}, max_usages={max_usages}, "
+            f"device={selected_device_limit}, traffic={selected_traffic_gb}, price={selected_price_rub})"
+        )
        return True
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при сохранении подарка {gift_id}: {e}")
        await session.rollback()
-        return False
+        raise
@@ -1,23 +1,25 @@
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession

-from database.models import Key, Payment
+from core.constants import PAYMENT_SYSTEMS_EXCLUDED
+from database.models import Key, Payment, User


 async def get_hot_leads(session: AsyncSession):
-    """
-    Возвращает пользователей, у которых есть успешные оплаты, но нет активных ключей.
-    """
-    subquery = select(Key.tg_id).where(Key.expiry_time > func.extract("epoch", func.now()) * 1000).distinct()
+    now_ms = func.extract("epoch", func.now()) * 1000
+
+    sub_active = select(Key.tg_id).where(Key.expiry_time > now_ms).distinct()

    stmt = (
        select(Payment.tg_id)
+        .join(User, User.tg_id == Payment.tg_id)
        .distinct()
+        .where(User.trial == 1)
        .where(Payment.amount > 0)
        .where(Payment.status == "success")
-        .where(Payment.payment_system.notin_(["referral", "coupon", "cashback"]))
-        .where(~Payment.tg_id.in_(subquery))
+        .where(Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED))
+        .where(~Payment.tg_id.in_(sub_active))
    )

    result = await session.execute(stmt)
-    return [row.tg_id for row in result]
+    return result.scalars().all()
@@ -10,6 +10,7 @@ from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

 from config import USE_COUNTRY_SELECTION
+from core.bootstrap import MODES_CONFIG
 from database.models import Key, Server, User


@@ -17,12 +18,16 @@ async def import_keys_from_3xui_db(db_path: str, session: AsyncSession) -> tuple
    imported = 0
    skipped = 0

-    if USE_COUNTRY_SELECTION:
-        result = await session.execute(select(Server.name).where(Server.enabled is True, Server.panel_type == "3x-ui"))
+    use_country_selection = bool(MODES_CONFIG.get("COUNTRY_SELECTION_ENABLED", USE_COUNTRY_SELECTION))
+
+    if use_country_selection:
+        result = await session.execute(
+            select(Server.server_name).where(Server.enabled.is_(True), Server.panel_type == "3x-ui")
+        )
    else:
        result = await session.execute(
            select(Server.cluster_name)
-            .where(Server.enabled is True, Server.panel_type == "3x-ui", Server.cluster_name.isnot(None))
+            .where(Server.enabled.is_(True), Server.panel_type == "3x-ui", Server.cluster_name.isnot(None))
            .distinct()
        )

@@ -87,8 +92,9 @@ async def import_keys_from_3xui_db(db_path: str, session: AsyncSession) -> tuple
                        updated_at=datetime.utcnow(),
                    )
                )
-            except SQLAlchemyError:
-                continue
+            except SQLAlchemyError as e:
+                await session.rollback()
+                raise RuntimeError(f"Ошибка при импорте пользователя tg_id={tg_id}") from e

        key_exists = await session.execute(select(Key).where(Key.client_id == client_id))
        if key_exists.scalar():
@@ -114,8 +120,9 @@ async def import_keys_from_3xui_db(db_path: str, session: AsyncSession) -> tuple
                )
            )
            imported += 1
-        except SQLAlchemyError:
-            continue
+        except SQLAlchemyError as e:
+            await session.rollback()
+            raise RuntimeError(f"Ошибка при импорте ключа client_id={client_id}") from e

    await session.commit()
    return imported, skipped
@@ -17,33 +17,75 @@ async def store_key(
    key: str,
    server_id: str,
    remnawave_link: str = None,
-    tariff_id: int = None,
-    alias: str = None,
+    tariff_id: int | None = None,
+    alias: str | None = None,
+    selected_device_limit: int | None = None,
+    selected_traffic_limit: int | None = None,
+    selected_price_rub: int | None = None,
+    current_device_limit: int | None = None,
+    current_traffic_limit: int | None = None,
 ):
+    """Сохраняет или обновляет ключ подписки."""
    try:
        exists = await session.execute(select(Key).where(Key.tg_id == tg_id, Key.client_id == client_id))
-        if exists.scalar_one_or_none():
-            logger.info(f"[Store Key] Ключ уже существует — пропускаем: tg_id={tg_id}, client_id={client_id}")
-            return
+        existing_key = exists.scalar_one_or_none()
+
+        if existing_key:
+            values: dict = {
+                "email": email,
+                "expiry_time": expiry_time,
+                "key": key,
+                "server_id": server_id,
+                "remnawave_link": remnawave_link,
+                "tariff_id": tariff_id,
+                "alias": alias,
+            }
+
+            if selected_device_limit is not None:
+                values["selected_device_limit"] = selected_device_limit
+            if selected_traffic_limit is not None:
+                values["selected_traffic_limit"] = selected_traffic_limit
+            if selected_price_rub is not None:
+                values["selected_price_rub"] = selected_price_rub
+            if current_device_limit is not None:
+                values["current_device_limit"] = current_device_limit
+            if current_traffic_limit is not None:
+                values["current_traffic_limit"] = current_traffic_limit
+
+            await session.execute(update(Key).where(Key.tg_id == tg_id, Key.client_id == client_id).values(**values))
+            logger.info(f"[Store Key] Ключ обновлён: tg_id={tg_id}, client_id={client_id}, server_id={server_id}")
+        else:
+            if current_device_limit is None:
+                current_device_limit = selected_device_limit
+            if current_traffic_limit is None:
+                current_traffic_limit = selected_traffic_limit
+
+            new_key = Key(
+                tg_id=tg_id,
+                client_id=client_id,
+                email=email,
+                created_at=int(datetime.utcnow().timestamp() * 1000),
+                expiry_time=expiry_time,
+                key=key,
+                server_id=server_id,
+                remnawave_link=remnawave_link,
+                tariff_id=tariff_id,
+                alias=alias,
+                selected_device_limit=selected_device_limit,
+                selected_traffic_limit=selected_traffic_limit,
+                selected_price_rub=selected_price_rub,
+                current_device_limit=current_device_limit,
+                current_traffic_limit=current_traffic_limit,
+            )
+            session.add(new_key)
+            logger.info(f"[Store Key] Ключ создан: tg_id={tg_id}, client_id={client_id}, server_id={server_id}")

-        new_key = Key(
-            tg_id=tg_id,
-            client_id=client_id,
-            email=email,
-            created_at=int(datetime.utcnow().timestamp() * 1000),
-            expiry_time=expiry_time,
-            key=key,
-            server_id=server_id,
-            remnawave_link=remnawave_link,
-            tariff_id=tariff_id,
-            alias=alias,
-        )
-        session.add(new_key)
        await session.commit()
-        logger.info(f"✅ Ключ сохранён: tg_id={tg_id}, client_id={client_id}, server_id={server_id}")
+
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при сохранении ключа: {e}")
        await session.rollback()
+        raise


 async def get_keys(session: AsyncSession, tg_id: int):
@@ -63,6 +105,7 @@ async def get_key_by_server(session: AsyncSession, tg_id: int, client_id: str):


 async def get_key_details(session: AsyncSession, email: str) -> dict | None:
+    """Возвращает подробную информацию о ключе по email."""
    stmt = select(Key, User).join(User, Key.tg_id == User.tg_id).where(Key.email == email)
    result = await session.execute(stmt)
    row = result.first()
@@ -100,6 +143,11 @@ async def get_key_details(session: AsyncSession, email: str) -> dict | None:
        "cluster_name": key.server_id,
        "location_name": key.server_id,
        "tariff_id": key.tariff_id,
+        "selected_device_limit": key.selected_device_limit,
+        "selected_traffic_limit": key.selected_traffic_limit,
+        "selected_price_rub": key.selected_price_rub,
+        "current_device_limit": key.current_device_limit,
+        "current_traffic_limit": key.current_traffic_limit,
    }


@@ -108,19 +156,16 @@ async def get_key_count(session: AsyncSession, tg_id: int) -> int:
    return result.scalar() or 0


-async def delete_key(session: AsyncSession, identifier: int | str):
+async def delete_key(session: AsyncSession, identifier: int | str, commit: bool = True):
    stmt = delete(Key).where(Key.tg_id == identifier if str(identifier).isdigit() else Key.client_id == identifier)
    await session.execute(stmt)
-    await session.commit()
+    if commit:
+        await session.commit()
    logger.info(f"Ключ с идентификатором {identifier} удалён")


 async def update_key_expiry(session: AsyncSession, client_id: str, new_expiry_time: int):
-    await session.execute(
-        update(Key)
-        .where(Key.client_id == client_id)
-        .values(expiry_time=new_expiry_time, notified=False, notified_24h=False)
-    )
+    await session.execute(update(Key).where(Key.client_id == client_id).values(expiry_time=new_expiry_time))
    await session.commit()
    logger.info(f"Срок действия ключа {client_id} обновлён до {new_expiry_time}")

@@ -144,13 +189,18 @@ async def mark_key_as_frozen(session: AsyncSession, tg_id: int, client_id: str,
                is_frozen = TRUE
            WHERE tg_id = :tg_id
              AND client_id = :client_id
-        """
+            """
        ),
        {"expiry": time_left, "tg_id": tg_id, "client_id": client_id},
    )


-async def mark_key_as_unfrozen(session: AsyncSession, tg_id: int, client_id: str, new_expiry_time: int):
+async def mark_key_as_unfrozen(
+    session: AsyncSession,
+    tg_id: int,
+    client_id: str,
+    new_expiry_time: int,
+):
    await session.execute(
        text(
            """
@@ -159,7 +209,7 @@ async def mark_key_as_unfrozen(session: AsyncSession, tg_id: int, client_id: str
                is_frozen = FALSE
            WHERE tg_id = :tg_id
              AND client_id = :client_id
-        """
+            """
        ),
        {"expiry": new_expiry_time, "tg_id": tg_id, "client_id": client_id},
    )
@@ -169,3 +219,71 @@ async def update_key_tariff(session: AsyncSession, client_id: str, tariff_id: in
    await session.execute(update(Key).where(Key.client_id == client_id).values(tariff_id=tariff_id))
    await session.commit()
    logger.info(f"Тариф ключа {client_id} обновлён на {tariff_id}")
+
+
+async def get_subscription_link(session: AsyncSession, email: str) -> str | None:
+    result = await session.execute(select(func.coalesce(Key.key, Key.remnawave_link)).where(Key.email == email))
+    return result.scalar_one_or_none()
+
+
+async def update_key_client_id(session: AsyncSession, email: str, new_client_id: str):
+    await session.execute(update(Key).where(Key.email == email).values(client_id=new_client_id))
+    await session.commit()
+    logger.info(f"client_id обновлён для {email} -> {new_client_id}")
+
+
+async def update_key_link(session: AsyncSession, email: str, link: str) -> bool:
+    q = update(Key).where(Key.email == email).values(key=link).returning(Key.client_id)
+    res = await session.execute(q)
+    await session.commit()
+    return res.scalar_one_or_none() is not None
+
+
+async def save_key_config_with_mode(
+    session: AsyncSession,
+    email: str,
+    selected_devices: int | None,
+    selected_traffic_gb: int | None,
+    total_price: int,
+    has_device_choice: bool,
+    has_traffic_choice: bool,
+    config_mode: str,
+) -> None:
+    values: dict = {}
+
+    if config_mode == "pack":
+        if has_device_choice and selected_devices is not None:
+            values["current_device_limit"] = int(selected_devices)
+        if has_traffic_choice and selected_traffic_gb is not None:
+            values["current_traffic_limit"] = int(selected_traffic_gb)
+    else:
+        device_val = int(selected_devices) if selected_devices is not None and has_device_choice else None
+        traffic_val = int(selected_traffic_gb) if selected_traffic_gb is not None and has_traffic_choice else None
+
+        values["selected_device_limit"] = device_val
+        values["selected_traffic_limit"] = traffic_val
+        values["selected_price_rub"] = int(total_price)
+        values["current_device_limit"] = device_val
+        values["current_traffic_limit"] = traffic_val
+
+    if not values:
+        return
+
+    await session.execute(update(Key).where(Key.email == email).values(**values))
+
+
+async def reset_key_current_limits_to_selected(session: AsyncSession, client_id: str):
+    """Сбрасывает текущие лимиты к выбранным для ключа."""
+    await session.execute(
+        text(
+            """
+            UPDATE keys
+            SET current_device_limit = selected_device_limit,
+                current_traffic_limit = selected_traffic_limit
+            WHERE client_id = :client_id
+            """
+        ),
+        {"client_id": client_id},
+    )
+    await session.commit()
+    logger.info(f"Текущие лимиты ключа {client_id} сброшены к выбранным")
@@ -12,10 +12,14 @@ from sqlalchemy import (
    Float,
    ForeignKey,
    Integer,
+    Numeric,
    String,
    Text,
+    UniqueConstraint,
+    text,
 )
-from sqlalchemy.orm import Mapped, declarative_base, mapped_column
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, declarative_base, mapped_column, relationship


 Base = declarative_base()
@@ -43,7 +47,16 @@ class User(DictLikeMixin, Base):
    is_bot = Column(Boolean, default=False)
    balance = Column(Float, default=0.0)
    trial = Column(Integer, default=0)
-    source_code = Column(String, ForeignKey("tracking_sources.code"))
+    preferred_currency = Column(String(10), nullable=False, server_default="RUB", index=True)
+    source_code = Column(
+        String,
+        ForeignKey(
+            "tracking_sources.code",
+            ondelete="SET NULL",
+            onupdate="CASCADE",
+        ),
+        nullable=True,
+    )
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow)

@@ -65,6 +78,13 @@ class Key(DictLikeMixin, Base):
    notified = Column(Boolean, default=False)
    notified_24h = Column(Boolean, default=False)

+    selected_device_limit = Column(Integer, nullable=True)
+    selected_traffic_limit = Column(BigInteger, nullable=True)
+    selected_price_rub = Column(Integer, nullable=True)
+
+    current_device_limit = Column(Integer, nullable=True)
+    current_traffic_limit = Column(BigInteger, nullable=True)
+

 class Tariff(DictLikeMixin, Base):
    __tablename__ = "tariffs"
@@ -80,6 +100,20 @@ class Tariff(DictLikeMixin, Base):
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow)
    subgroup_title = Column(String, nullable=True)
+    sort_order = Column(Integer, nullable=True)
+    vless = Column(Boolean, default=False)
+    external_squad: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+    configurable = Column(Boolean, nullable=False, server_default="false")
+
+    device_options = Column(JSONB, nullable=True)
+    traffic_options_gb = Column(JSONB, nullable=True)
+
+    device_step_rub = Column(Integer, nullable=True)
+    device_overrides = Column(JSONB, nullable=True)
+
+    traffic_step_rub = Column(Integer, nullable=True)
+    traffic_overrides = Column(JSONB, nullable=True)


 class Server(DictLikeMixin, Base):
@@ -96,6 +130,34 @@ class Server(DictLikeMixin, Base):
    tariff_group = Column(String)
    enabled = Column(Boolean, default=True)

+    subgroups = relationship("ServerSubgroup", back_populates="server", cascade="all, delete-orphan")
+    groups = relationship("ServerSpecialgroup", back_populates="server", cascade="all, delete-orphan")
+
+
+class ServerSubgroup(DictLikeMixin, Base):
+    __tablename__ = "server_subgroups"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    server_id = Column(Integer, ForeignKey("servers.id", ondelete="CASCADE"), index=True, nullable=False)
+    group_code = Column(String, nullable=False)
+    subgroup_title = Column(String, nullable=False)
+
+    server = relationship("Server", back_populates="subgroups")
+
+    __table_args__ = (UniqueConstraint("server_id", "subgroup_title", name="uq_server_subgroup"),)
+
+
+class ServerSpecialgroup(DictLikeMixin, Base):
+    __tablename__ = "server_specialgroups"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    server_id = Column(Integer, ForeignKey("servers.id", ondelete="CASCADE"), index=True, nullable=False)
+    group_code = Column(String, nullable=False)
+
+    server = relationship("Server")
+
+    __table_args__ = (UniqueConstraint("server_id", "group_code", name="uq_server_group"),)
+

 class Payment(DictLikeMixin, Base):
    __tablename__ = "payments"
@@ -106,6 +168,10 @@ class Payment(DictLikeMixin, Base):
    payment_system = Column(String)
    status = Column(String)
    created_at = Column(DateTime, default=datetime.utcnow)
+    original_amount = Column(Numeric(18, 8), nullable=True)
+    currency = Column(String(10), nullable=False, server_default="RUB")
+    payment_id = Column(String(128), nullable=True, index=True)
+    metadata_ = Column("metadata", JSONB, nullable=True)


 class Coupon(DictLikeMixin, Base):
@@ -118,12 +184,17 @@ class Coupon(DictLikeMixin, Base):
    usage_count = Column(Integer, default=0)
    is_used = Column(Boolean, default=False)
    days = Column(Integer, nullable=True)
+    new_users_only = Column(Boolean, nullable=False, server_default=text("false"))
+
+    percent = Column(Integer, nullable=True)
+    max_discount_amount = Column(Integer, nullable=True)
+    min_order_amount = Column(Integer, nullable=True)


 class CouponUsage(DictLikeMixin, Base):
    __tablename__ = "coupon_usages"

-    coupon_id = Column(Integer, ForeignKey("coupons.id"), primary_key=True)
+    coupon_id = Column(Integer, ForeignKey("coupons.id", ondelete="CASCADE"), primary_key=True)
    user_id = Column(BigInteger, primary_key=True)
    used_at = Column(DateTime, default=datetime.utcnow)

@@ -159,6 +230,10 @@ class Gift(DictLikeMixin, Base):
    max_usages = Column(Integer, nullable=True)
    tariff_id: Mapped[int | None] = mapped_column(ForeignKey("tariffs.id"))

+    selected_device_limit = Column(Integer, nullable=True)
+    selected_traffic_gb = Column(Integer, nullable=True)
+    selected_price_rub = Column(Integer, nullable=True)
+

 class GiftUsage(DictLikeMixin, Base):
    __tablename__ = "gift_usages"
@@ -216,3 +291,13 @@ class Admin(Base):
    @staticmethod
    def generate_token() -> str:
        return secrets.token_urlsafe(32)
+
+
+class Setting(DictLikeMixin, Base):
+    __tablename__ = "settings"
+
+    key = Column(String, primary_key=True)
+    value = Column(JSONB, nullable=True)
+    description = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@@ -5,6 +5,8 @@ from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

+from config import DISCOUNT_ACTIVE_HOURS
+from core.bootstrap import NOTIFICATIONS_CONFIG
 from database.models import Key, Notification, User
 from logger import logger

@@ -29,6 +31,7 @@ async def add_notification(session: AsyncSession, tg_id: int, notification_type:
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при добавлении уведомления: {e}")
        await session.rollback()
+        raise


 async def delete_notification(session: AsyncSession, tg_id: int, notification_type: str):
@@ -39,7 +42,7 @@ async def delete_notification(session: AsyncSession, tg_id: int, notification_ty
        )
    )
    await session.commit()
-    logger.info(f"🗑 Уведомление {notification_type} для пользователя {tg_id} удалено")
+    logger.debug(f"🗑 Уведомление {notification_type} для пользователя {tg_id} удалено")


 async def check_notification_time(session: AsyncSession, tg_id: int, notification_type: str, hours: int = 12) -> bool:
@@ -64,6 +67,45 @@ async def get_last_notification_time(session: AsyncSession, tg_id: int, notifica
    return None


+async def check_hot_lead_discount(session: AsyncSession, tg_id: int) -> dict:
+    try:
+        result = await session.execute(
+            select(Notification.notification_type, Notification.last_notification_time)
+            .where(Notification.tg_id == tg_id)
+            .where(Notification.notification_type.in_(["hot_lead_step_2", "hot_lead_step_3"]))
+            .order_by(Notification.last_notification_time.desc())
+            .limit(1)
+        )
+
+        row = result.first()
+        if not row:
+            return {"available": False}
+
+        notification_type, last_time = row
+
+        hours = int(NOTIFICATIONS_CONFIG.get("DISCOUNT_ACTIVE_HOURS", DISCOUNT_ACTIVE_HOURS))
+
+        expires_at = last_time + timedelta(hours=hours)
+        current_time = datetime.utcnow()
+
+        if current_time > expires_at:
+            return {"available": False}
+
+        tariff_group = "discounts" if notification_type == "hot_lead_step_2" else "discounts_max"
+
+        return {
+            "available": True,
+            "type": notification_type,
+            "tariff_group": tariff_group,
+            "expires_at": expires_at,
+        }
+
+    except Exception as e:
+        logger.error(f"❌ Ошибка при проверке скидки горячего лида для {tg_id}: {e}")
+        await session.rollback()
+        return {"available": False}
+
+
 async def check_notifications_bulk(
    session: AsyncSession,
    notification_type: str,
@@ -125,7 +167,7 @@ async def check_notifications_bulk(
                    "username": row.username,
                    "first_name": row.first_name,
                    "last_name": row.last_name,
-                    "last_notification_time": (int(last_time.timestamp() * 1000) if last_time else None),
+                    "last_notification_time": int(last_time.timestamp() * 1000) if last_time else None,
                })

        logger.info(f"Найдено {len(users)} пользователей, готовых к уведомлению типа {notification_type}")
@@ -133,4 +175,5 @@ async def check_notifications_bulk(

    except Exception as e:
        logger.error(f"Ошибка при массовой проверке уведомлений типа {notification_type}: {e}")
+        await session.rollback()
        return []
@@ -1,7 +1,7 @@
-from datetime import datetime
+from datetime import datetime, timedelta

 from pytz import timezone
-from sqlalchemy import insert, select
+from sqlalchemy import and_, insert, select, update
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

@@ -12,33 +12,203 @@ from logger import logger
 MOSCOW_TZ = timezone("Europe/Moscow")


-async def add_payment(session: AsyncSession, tg_id: int, amount: float, payment_system: str):
+async def add_payment(
+    session: AsyncSession,
+    tg_id: int,
+    amount: float,
+    payment_system: str,
+    *,
+    status: str = "success",
+    currency: str = "RUB",
+    payment_id: str | None = None,
+    metadata: dict | None = None,
+    original_amount: float | None = None,
+) -> int:
    try:
        now_moscow = datetime.now(MOSCOW_TZ).replace(tzinfo=None)
-        stmt = insert(Payment).values(
-            tg_id=tg_id,
-            amount=amount,
-            payment_system=payment_system,
-            status="success",
-            created_at=now_moscow,
+        stmt = (
+            insert(Payment)
+            .values(
+                tg_id=tg_id,
+                amount=amount,
+                payment_system=payment_system,
+                status=status,
+                created_at=now_moscow,
+                currency=currency,
+                payment_id=payment_id,
+                metadata_=metadata,
+                original_amount=original_amount,
+            )
+            .returning(Payment.id)
        )
-        await session.execute(stmt)
-        await session.commit()
-        logger.info(f"✅ Успешно добавлен платёж: {tg_id}, {amount}₽ через {payment_system}")
+        result = await session.execute(stmt)
+        internal_id = result.scalar_one()
+        logger.info(
+            f"Добавлен платёж id={internal_id}: tg_id={tg_id}, amount={amount}, system={payment_system}, status={status}"
+        )
+        return internal_id
    except SQLAlchemyError as e:
-        logger.error(f"❌ Ошибка при добавлении платежа: {e}")
        await session.rollback()
+        logger.error(f"Ошибка при добавлении платежа: {e}")
        raise


-async def get_last_payments(session: AsyncSession, tg_id: int, limit: int = 3):
+async def get_last_payments(
+    session: AsyncSession,
+    tg_id: int,
+    limit: int = 3,
+    statuses: list[str] | None = None,
+):
+    query = select(Payment).where(Payment.tg_id == tg_id)
+
+    if statuses:
+        query = query.where(Payment.status.in_(statuses))
+
+    query = query.order_by(Payment.created_at.desc()).limit(limit)
+
+    result = await session.execute(query)
+    payments = result.scalars().all()
+    return [
+        {
+            "id": p.id,
+            "tg_id": p.tg_id,
+            "amount": p.amount,
+            "currency": p.currency,
+            "status": p.status,
+            "payment_system": p.payment_system,
+            "payment_id": p.payment_id,
+            "created_at": p.created_at,
+            "metadata": p.metadata_,
+            "original_amount": p.original_amount,
+        }
+        for p in payments
+    ]
+
+
+async def get_payment_by_id(session: AsyncSession, internal_id: int) -> dict | None:
    try:
-        result = await session.execute(
-            select(Payment).where(Payment.tg_id == tg_id).order_by(Payment.created_at.desc()).limit(limit)
-        )
-        payments = result.scalars().all()
-        logger.info(f"✅ Получены последние платежи пользователя {tg_id}, всего: {len(payments)}")
-        return [dict(p.__dict__) for p in payments]
+        result = await session.execute(select(Payment).where(Payment.id == internal_id).limit(1))
+        payment = result.scalar_one_or_none()
+        if not payment:
+            return None
+        return {
+            "id": payment.id,
+            "tg_id": payment.tg_id,
+            "amount": payment.amount,
+            "currency": payment.currency,
+            "status": payment.status,
+            "payment_system": payment.payment_system,
+            "payment_id": payment.payment_id,
+            "created_at": payment.created_at,
+            "metadata": payment.metadata_,
+            "original_amount": payment.original_amount,
+        }
    except SQLAlchemyError as e:
-        logger.error(f"❌ Ошибка при получении платежей пользователя {tg_id}: {e}")
-        return []
+        logger.error(f"Ошибка при поиске платежа id={internal_id}: {e}")
+        await session.rollback()
+        return None
+
+
+async def update_payment_status(
+    session: AsyncSession,
+    internal_id: int,
+    new_status: str,
+    *,
+    payment_id: str | None = None,
+    metadata_patch: dict | None = None,
+) -> bool:
+    try:
+        result = await session.execute(select(Payment).where(Payment.id == internal_id).limit(1))
+        payment = result.scalar_one_or_none()
+        if not payment:
+            logger.info(f"Не удалось сменить статус: платёж id={internal_id} не найден")
+            return False
+
+        payment.status = new_status
+        if payment_id is not None:
+            payment.payment_id = payment_id
+        if metadata_patch:
+            base = payment.metadata_ or {}
+            base.update(metadata_patch)
+            payment.metadata_ = base
+
+        await session.commit()
+        logger.info(f"Статус платежа id={internal_id} изменён на {new_status}")
+        return True
+    except SQLAlchemyError as e:
+        await session.rollback()
+        logger.error(f"Ошибка при смене статуса платежа id={internal_id}: {e}")
+        return False
+
+
+async def get_payment_by_payment_id(session: AsyncSession, pid: str) -> dict | None:
+    try:
+        result = await session.execute(select(Payment).where(Payment.payment_id == pid).limit(1))
+        payment = result.scalar_one_or_none()
+        if not payment:
+            return None
+        return {
+            "id": payment.id,
+            "tg_id": payment.tg_id,
+            "amount": payment.amount,
+            "currency": payment.currency,
+            "status": payment.status,
+            "payment_system": payment.payment_system,
+            "payment_id": payment.payment_id,
+            "created_at": payment.created_at,
+            "metadata": payment.metadata_,
+            "original_amount": payment.original_amount,
+        }
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при поиске платежа payment_id={pid}: {e}")
+        await session.rollback()
+        return None
+
+
+async def cancel_expired_pending_payments(session: AsyncSession) -> int:
+    cutoff = datetime.now(MOSCOW_TZ).replace(tzinfo=None) - timedelta(minutes=60)
+    stmt = (
+        update(Payment)
+        .where(
+            and_(
+                Payment.status.in_(("pending", "issued", "processing", "awaiting_choice")),
+                Payment.created_at < cutoff,
+            )
+        )
+        .values(status="cancelled")
+    )
+    res = await session.execute(stmt)
+    await session.commit()
+    affected = res.rowcount or 0
+    return affected
+
+
+async def get_all_payments(
+    session: AsyncSession,
+    tg_id: int,
+    statuses: list[str] | None = None,
+) -> list[dict]:
+    query = select(Payment).where(Payment.tg_id == tg_id)
+
+    if statuses:
+        query = query.where(Payment.status.in_(statuses))
+
+    query = query.order_by(Payment.created_at.desc())
+
+    result = await session.execute(query)
+    payments = result.scalars().all()
+    return [
+        {
+            "id": p.id,
+            "tg_id": p.tg_id,
+            "amount": p.amount,
+            "currency": p.currency,
+            "status": p.status,
+            "payment_system": p.payment_system,
+            "payment_id": p.payment_id,
+            "created_at": p.created_at,
+            "metadata": p.metadata_,
+            "original_amount": p.original_amount,
+        }
+        for p in payments
+    ]
@@ -3,6 +3,7 @@ from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

 from config import CHECK_REFERRAL_REWARD_ISSUED, REFERRAL_BONUS_PERCENTAGES
+from core.bootstrap import BUTTONS_CONFIG
 from database.models import Referral
 from logger import logger

@@ -57,6 +58,11 @@ async def mark_referral_reward_issued(session: AsyncSession, referred_tg_id: int


 async def get_total_referral_bonus(session: AsyncSession, referrer_tg_id: int, max_levels: int) -> float:
+    referral_enabled = bool(BUTTONS_CONFIG.get("REFERRAL_BUTTON_ENABLED", True))
+    if not referral_enabled:
+        logger.debug("Реферальная программа отключена, бонусы не начисляются")
+        return 0.0
+
    if CHECK_REFERRAL_REWARD_ISSUED:
        bonus_cte = """
            WITH RECURSIVE
@@ -81,7 +87,8 @@ async def get_total_referral_bonus(session: AsyncSession, referrer_tg_id: int, m
            earliest_payments AS (
                SELECT DISTINCT ON (tg_id) tg_id, amount, created_at
                FROM payments
-                WHERE status = 'success'
+                WHERE status = 'success' 
+                  AND payment_system NOT IN ('coupon', 'admin', 'referral')
                ORDER BY tg_id, created_at
            )
        """
@@ -148,11 +155,16 @@ async def get_total_referral_bonus(session: AsyncSession, referrer_tg_id: int, m
                ), 0) AS total_bonus
            FROM referral_levels rl
            JOIN payments p ON rl.referred_tg_id = p.tg_id
-            WHERE p.status = 'success' AND rl.level <= :max_levels
+            WHERE p.status = 'success' 
+              AND p.payment_system NOT IN ('coupon', 'admin', 'referral')
+              AND rl.level <= :max_levels
        """
        )

-    result = await session.execute(text(bonus_query), {"tg_id": referrer_tg_id, "max_levels": max_levels})
+    result = await session.execute(
+        text(bonus_query),  # nosemgrep: python.sqlalchemy.security.audit.avoid-sqlalchemy-text.avoid-sqlalchemy-text
+        {"tg_id": referrer_tg_id, "max_levels": max_levels},
+    )
    total_bonus_raw = result.scalar()
    total_bonus = round(float(total_bonus_raw or 0), 2)

@@ -180,7 +192,10 @@ async def get_referrals_by_level(session: AsyncSession, referrer_tg_id: int, max
        GROUP BY level
        ORDER BY level
    """
-    result = await session.execute(text(query), {"referrer_tg_id": referrer_tg_id, "max_levels": max_levels})
+    result = await session.execute(
+        text(query),  # nosemgrep: python.sqlalchemy.security.audit.avoid-sqlalchemy-text.avoid-sqlalchemy-text
+        {"referrer_tg_id": referrer_tg_id, "max_levels": max_levels},
+    )
    return {
        row["level"]: {
            "total": row["level_count"],
@@ -209,6 +224,7 @@ async def get_referral_stats(session: AsyncSession, referrer_tg_id: int):

    except Exception as e:
        logger.error(f"[ReferralStats] Ошибка при получении статистики для пользователя {referrer_tg_id}: {e}")
+        await session.rollback()
        raise


@@ -2,7 +2,7 @@ from sqlalchemy import delete, func, insert, select, update
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

-from database.models import Key, Server
+from database.models import Key, Server, ServerSpecialgroup, ServerSubgroup, Tariff
 from logger import logger


@@ -44,16 +44,44 @@ async def delete_server(session: AsyncSession, server_name: str):


 async def get_servers(session: AsyncSession, include_enabled: bool = False) -> dict:
+    from handlers.utils import ALLOWED_GROUP_CODES
+
    try:
        stmt = select(Server)
        result = await session.execute(stmt)
        servers = result.scalars().all()

+        ids = [s.id for s in servers]
+        subs_map = {}
+        tariffs_map = {}
+        if ids:
+            r = await session.execute(
+                select(ServerSubgroup.server_id, ServerSubgroup.subgroup_title).where(ServerSubgroup.server_id.in_(ids))
+            )
+            for sid, sg in r.all():
+                if sg and sg.isdigit():
+                    tariffs_map.setdefault(sid, []).append(int(sg))
+                else:
+                    subs_map.setdefault(sid, []).append(sg)
+
+        groups_map = {}
+        if ids:
+            r2 = await session.execute(
+                select(ServerSpecialgroup.server_id, ServerSpecialgroup.group_code).where(
+                    ServerSpecialgroup.server_id.in_(ids)
+                )
+            )
+            for sid, gc in r2.all():
+                groups_map.setdefault(sid, []).append(gc)
+
+        allowed = set(ALLOWED_GROUP_CODES)
+
        grouped = {}
        for s in servers:
            if not include_enabled and not s.enabled:
                continue
            cluster = s.cluster_name
+            special = sorted({g for g in groups_map.get(s.id, []) if g in allowed})
            grouped.setdefault(cluster, []).append({
                "server_name": s.server_name,
                "api_url": s.api_url,
@@ -63,12 +91,16 @@ async def get_servers(session: AsyncSession, include_enabled: bool = False) -> d
                "enabled": s.enabled,
                "max_keys": s.max_keys,
                "tariff_group": s.tariff_group,
+                "tariff_subgroups": subs_map.get(s.id, []),
+                "tariff_ids": tariffs_map.get(s.id, []),
+                "special_groups": special,
                "cluster_name": cluster,
+                "server_id": s.id,
            })
-
        return grouped
    except SQLAlchemyError as e:
        logger.error(f"Ошибка при получении серверов: {e}")
+        await session.rollback()
        return {}


@@ -93,6 +125,7 @@ async def check_server_name_by_cluster(session: AsyncSession, server_name: str)
        return {"cluster_name": row[0]} if row else None
    except SQLAlchemyError as e:
        logger.error(f"Ошибка при поиске кластера для сервера {server_name}: {e}")
+        await session.rollback()
        return None


@@ -130,6 +163,7 @@ async def get_server_by_name(session: AsyncSession, server_name: str) -> dict |
        return None
    except SQLAlchemyError as e:
        logger.error(f"Ошибка при получении сервера {server_name}: {e}")
+        await session.rollback()
        return None


@@ -178,6 +212,7 @@ async def get_available_clusters(session: AsyncSession) -> list[str]:
        return [row[0] for row in result.all()]
    except SQLAlchemyError as e:
        logger.error(f"Ошибка при получении списка кластеров: {e}")
+        await session.rollback()
        return []


@@ -203,17 +238,169 @@ async def update_server_cluster(session: AsyncSession, server_name: str, new_clu
        result = await session.execute(stmt_new_cluster)
        new_tariff_group = result.scalar_one_or_none()

-        stmt_update = (
+        await session.execute(
            update(Server)
            .where(Server.server_name == server_name)
            .values(cluster_name=new_cluster, tariff_group=new_tariff_group)
        )
-        await session.execute(stmt_update)
-        await session.commit()

-        logger.info(f"✅ Сервер {server_name} перемещен в кластер {new_cluster} с обновлением тарифной группы")
+        if server_data.get("id") is None:
+            rid = await session.execute(select(Server.id).where(Server.server_name == server_name).limit(1))
+            server_id = rid.scalar_one_or_none()
+        else:
+            server_id = server_data["id"]
+
+        if server_id is not None and new_tariff_group is not None:
+            await session.execute(
+                update(ServerSubgroup).where(ServerSubgroup.server_id == server_id).values(group_code=new_tariff_group)
+            )
+
+        await session.commit()
+        logger.info(
+            f"✅ Сервер {server_name} перемещен в кластер {new_cluster} с обновлением тарифной группы и привязок подгрупп"
+        )
        return True
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при обновлении кластера сервера {server_name}: {e}")
        await session.rollback()
        return False
+
+
+async def resolve_device_limit_from_group(session: AsyncSession, server_id: str) -> int | None:
+    r = await session.execute(select(Server.tariff_group).where(Server.server_name == server_id))
+    group = r.scalar_one_or_none()
+    if not group:
+        return None
+    q = await session.execute(
+        select(Tariff.device_limit)
+        .where(Tariff.group_code == group, Tariff.is_active.is_(True))
+        .order_by(Tariff.duration_days.desc())
+        .limit(1)
+    )
+    dl = q.scalar_one_or_none()
+    return int(dl) if dl is not None else None
+
+
+async def filter_cluster_by_subgroup(
+    session: AsyncSession,
+    cluster: list,
+    target_subgroup: str,
+    cluster_id: str,
+    tariff_id: int | None = None,
+) -> list:
+    names = [s.get("server_name") for s in cluster if s.get("server_name")]
+    if not names:
+        return []
+
+    if tariff_id:
+        tariff_id_str = str(tariff_id)
+        q_by_tariff = await session.execute(
+            select(Server.server_name)
+            .join(ServerSubgroup, ServerSubgroup.server_id == Server.id)
+            .where(
+                Server.server_name.in_(names),
+                Server.enabled.is_(True),
+                ServerSubgroup.subgroup_title == tariff_id_str,
+            )
+        )
+        allowed_by_tariff = {n for (n,) in q_by_tariff.all()}
+        if allowed_by_tariff:
+            logger.debug(f"Найдены серверы по tariff_id={tariff_id}: {allowed_by_tariff}")
+            return [s for s in cluster if s.get("server_name") in allowed_by_tariff]
+
+    q_allowed = await session.execute(
+        select(Server.server_name)
+        .join(ServerSubgroup, ServerSubgroup.server_id == Server.id)
+        .where(
+            Server.server_name.in_(names),
+            Server.enabled.is_(True),
+            ServerSubgroup.subgroup_title == target_subgroup,
+        )
+    )
+    allowed = {n for (n,) in q_allowed.all()}
+    if allowed:
+        return [s for s in cluster if s.get("server_name") in allowed]
+
+    check_values = [target_subgroup]
+    if tariff_id:
+        check_values.append(str(tariff_id))
+
+    total_bindings = await session.scalar(
+        select(func.count()).select_from(ServerSubgroup).where(ServerSubgroup.subgroup_title.in_(check_values))
+    )
+    if not total_bindings:
+        logger.info(f"Для подгруппы/тарифа нет привязок. Используем весь кластер {cluster_id}.")
+        return cluster
+
+    q_any = await session.execute(
+        select(Server.server_name)
+        .join(ServerSubgroup, ServerSubgroup.server_id == Server.id)
+        .where(
+            Server.server_name.in_(names),
+            Server.enabled.is_(True),
+        )
+    )
+    any_bound = {n for (n,) in q_any.all()}
+    if any_bound:
+        logger.warning(f"Нет серверов под подгруппу {target_subgroup} в кластере {cluster_id}.")
+        return []
+
+    logger.info(f"В кластере {cluster_id} нет привязок. Используем весь кластер.")
+    return cluster
+
+
+async def filter_cluster_by_tariff(session: AsyncSession, cluster: list, tariff_id: int, cluster_id: str) -> list:
+    names = [s.get("server_name") for s in cluster if s.get("server_name")]
+    if not names:
+        return []
+
+    tariff_id_str = str(tariff_id)
+
+    q_allowed = await session.execute(
+        select(Server.server_name)
+        .join(ServerSubgroup, ServerSubgroup.server_id == Server.id)
+        .where(
+            Server.server_name.in_(names),
+            Server.enabled.is_(True),
+            ServerSubgroup.subgroup_title == tariff_id_str,
+        )
+    )
+    allowed = {n for (n,) in q_allowed.all()}
+    if allowed:
+        return [s for s in cluster if s.get("server_name") in allowed]
+
+    total_for_tariff = await session.scalar(
+        select(func.count()).select_from(ServerSubgroup).where(ServerSubgroup.subgroup_title == tariff_id_str)
+    )
+    if not total_for_tariff:
+        logger.info(f"Для тарифа {tariff_id} нет привязок серверов. Используем весь кластер {cluster_id}.")
+        return cluster
+
+    q_any = await session.execute(
+        select(Server.server_name)
+        .join(ServerSubgroup, ServerSubgroup.server_id == Server.id)
+        .where(
+            Server.server_name.in_(names),
+            Server.enabled.is_(True),
+        )
+    )
+    any_bound = {n for (n,) in q_any.all()}
+    if any_bound:
+        logger.warning(f"Нет серверов под тариф {tariff_id} в кластере {cluster_id}.")
+        return []
+
+    logger.info(f"В кластере {cluster_id} нет привязок тарифов. Используем весь кластер.")
+    return cluster
+
+
+async def has_legacy_subgroup_bindings(session: AsyncSession, server_ids: list[int]) -> bool:
+    if not server_ids:
+        return False
+
+    result = await session.execute(
+        select(ServerSubgroup.subgroup_title).where(ServerSubgroup.server_id.in_(server_ids))
+    )
+    for (title,) in result.all():
+        if title and not title.isdigit():
+            return True
+    return False
@@ -0,0 +1,37 @@
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from .models import Setting
+
+
+async def get_setting(session: AsyncSession, key: str, default: Any = None) -> Any:
+    stmt = select(Setting).where(Setting.key == key)
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+    if setting is None or setting.value is None:
+        return default
+    return setting.value
+
+
+async def set_setting(
+    session: AsyncSession,
+    key: str,
+    value: Any,
+    description: str | None = None,
+) -> Setting:
+    stmt = select(Setting).where(Setting.key == key)
+    result = await session.execute(stmt)
+    setting = result.scalar_one_or_none()
+
+    if setting is None:
+        setting = Setting(key=key, value=value, description=description)
+        session.add(setting)
+    else:
+        setting.value = value
+        if description is not None:
+            setting.description = description
+
+    await session.flush()
+    return setting
@@ -3,6 +3,7 @@ from datetime import date, datetime
 from sqlalchemy import and_, exists, func, not_, select
 from sqlalchemy.ext.asyncio import AsyncSession

+from core.constants import PAYMENT_SYSTEMS_EXCLUDED
 from database.models import Key, Payment, Referral, Tariff, User


@@ -33,12 +34,28 @@ async def count_active_keys(session: AsyncSession) -> int:
    return await session.scalar(select(func.count()).select_from(Key).where(Key.expiry_time > current_time_ms))


-async def count_trial_keys(session: AsyncSession) -> int:
-    subquery_success_payments = (
-        select(Payment.tg_id).where(and_(Payment.tg_id == Key.tg_id, Payment.status == "success")).exists()
+async def count_active_paid_keys(session: AsyncSession) -> int:
+    current_time_ms = int(datetime.utcnow().timestamp() * 1000)
+    trial_tariffs_subquery = select(Tariff.id).where(Tariff.group_code == "trial")
+
+    return await session.scalar(
+        select(func.count())
+        .select_from(Key)
+        .where(Key.expiry_time > current_time_ms)
+        .where(~Key.tariff_id.in_(trial_tariffs_subquery))
    )

-    return await session.scalar(select(func.count()).select_from(Key).where(not_(subquery_success_payments)))
+
+async def count_active_trial_keys(session: AsyncSession) -> int:
+    current_time_ms = int(datetime.utcnow().timestamp() * 1000)
+    trial_tariffs_subquery = select(Tariff.id).where(Tariff.group_code == "trial")
+
+    return await session.scalar(
+        select(func.count())
+        .select_from(Key)
+        .where(Key.expiry_time > current_time_ms)
+        .where(Key.tariff_id.in_(trial_tariffs_subquery))
+    )


 async def get_tariff_distribution(
@@ -82,6 +99,14 @@ async def get_tariff_durations(session: AsyncSession, tariff_ids: list[int]) ->
    return dict(result.all())


+async def get_tariff_subgroups(session: AsyncSession, tariff_ids: list[int]) -> dict[int, str | None]:
+    if not tariff_ids:
+        return {}
+
+    result = await session.execute(select(Tariff.id, Tariff.subgroup_title).where(Tariff.id.in_(tariff_ids)))
+    return dict(result.all())
+
+
 async def count_total_referrals(session: AsyncSession) -> int:
    return await session.scalar(select(func.count()).select_from(Referral))

@@ -89,7 +114,11 @@ async def count_total_referrals(session: AsyncSession) -> int:
 async def sum_payments_since(session: AsyncSession, since: date) -> float:
    result = await session.scalar(
        select(func.coalesce(func.sum(Payment.amount), 0)).where(
-            and_(Payment.created_at >= since, Payment.payment_system.notin_(["referral", "coupon", "cashback"]))
+            and_(
+                Payment.created_at >= since,
+                Payment.status == "success",
+                Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED),
+            )
        )
    )
    return round(float(result), 2)
@@ -101,7 +130,8 @@ async def sum_payments_between(session: AsyncSession, start: date, end: date) ->
            and_(
                Payment.created_at >= start,
                Payment.created_at < end,
-                Payment.payment_system.notin_(["referral", "coupon", "cashback"]),
+                Payment.status == "success",
+                Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED),
            )
        )
    )
@@ -111,7 +141,10 @@ async def sum_payments_between(session: AsyncSession, start: date, end: date) ->
 async def sum_total_payments(session: AsyncSession) -> float:
    result = await session.scalar(
        select(func.coalesce(func.sum(Payment.amount), 0)).where(
-            Payment.payment_system.notin_(["referral", "coupon", "cashback"])
+            and_(
+                Payment.status == "success",
+                Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED),
+            )
        )
    )
    return round(float(result), 2)
@@ -126,7 +159,7 @@ async def count_hot_leads(session: AsyncSession) -> int:
        select(Payment.tg_id)
        .where(Payment.amount > 0)
        .where(Payment.status == "success")
-        .where(Payment.payment_system.notin_(["referral", "coupon", "cashback"]))
+        .where(Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED))
        .where(not_(exists(subquery_active_keys.where(Key.tg_id == Payment.tg_id))))
        .distinct()
    )
@@ -1,8 +1,9 @@
 import hashlib

+from collections import defaultdict
 from datetime import datetime

-from sqlalchemy import delete, insert, select, update
+from sqlalchemy import delete, func, insert, select, update
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

@@ -34,18 +35,45 @@ async def find_subgroup_by_hash(session: AsyncSession, subgroup_hash: str, group
    return None


-async def get_tariffs(session: AsyncSession, tariff_id: int = None, group_code: str = None):
+async def get_tariffs(
+    session: AsyncSession, tariff_id: int = None, group_code: str = None, with_subgroup_weights: bool = False
+):
    try:
        if tariff_id:
            result = await session.execute(select(Tariff).where(Tariff.id == tariff_id))
        elif group_code:
-            result = await session.execute(select(Tariff).where(Tariff.group_code == group_code).order_by(Tariff.id))
+            result = await session.execute(
+                select(Tariff).where(Tariff.group_code == group_code).order_by(Tariff.sort_order, Tariff.id)
+            )
        else:
-            result = await session.execute(select(Tariff))
+            result = await session.execute(select(Tariff).order_by(Tariff.sort_order, Tariff.id))

-        return [dict(r.__dict__) for r in result.scalars().all()]
+        tariffs = [dict(r.__dict__) for r in result.scalars().all()]
+
+        if with_subgroup_weights and group_code:
+            tariffs_without_order = [t for t in tariffs if t.get("sort_order") is None]
+            if tariffs_without_order:
+                for tariff in tariffs_without_order:
+                    tariff["sort_order"] = 1
+                    await session.execute(update(Tariff).where(Tariff.id == tariff["id"]).values(sort_order=1))
+                await session.commit()
+
+            grouped = defaultdict(list)
+            for t in tariffs:
+                grouped[t.get("subgroup_title")].append(t)
+
+            subgroup_weights = {}
+            for subgroup, tariffs_list in grouped.items():
+                if subgroup:
+                    total_weight = sum(t.get("sort_order", 1) for t in tariffs_list)
+                    subgroup_weights[subgroup] = total_weight
+
+            return {"tariffs": tariffs, "subgroup_weights": subgroup_weights}
+
+        return tariffs
    except SQLAlchemyError as e:
        logger.error(f"[TARIFF] Ошибка при получении тарифов: {e}")
+        await session.rollback()
        return []


@@ -56,6 +84,7 @@ async def get_tariff_by_id(session: AsyncSession, tariff_id: int):
        return dict(tariff.__dict__) if tariff else None
    except SQLAlchemyError as e:
        logger.error(f"[TARIFF] Ошибка при получении тарифа по ID {tariff_id}: {e}")
+        await session.rollback()
        return None


@@ -77,7 +106,9 @@ async def get_tariffs_for_cluster(session: AsyncSession, cluster_name: str):

        group_code = row[0]
        result = await session.execute(
-            select(Tariff).where(Tariff.group_code == group_code, Tariff.is_active.is_(True)).order_by(Tariff.id)
+            select(Tariff)
+            .where(Tariff.group_code == group_code, Tariff.is_active.is_(True))
+            .order_by(Tariff.sort_order, Tariff.id)
        )
        return [dict(r.__dict__) for r in result.scalars().all()]
    except SQLAlchemyError as e:
@@ -90,6 +121,21 @@ async def create_tariff(session: AsyncSession, data: dict):
        data["created_at"] = datetime.utcnow()
        data["updated_at"] = datetime.utcnow()

+        if "sort_order" not in data:
+            group_code = data.get("group_code")
+            if group_code:
+                result = await session.execute(
+                    select(func.max(Tariff.sort_order)).where(
+                        Tariff.group_code == group_code, Tariff.sort_order.isnot(None)
+                    )
+                )
+                max_order = result.scalar() or 0
+            else:
+                result = await session.execute(select(func.max(Tariff.sort_order)).where(Tariff.sort_order.isnot(None)))
+                max_order = result.scalar() or 0
+
+            data["sort_order"] = max_order + 1
+
        stmt = insert(Tariff).values(**data).returning(Tariff)
        result = await session.execute(stmt)
        await session.commit()
@@ -135,4 +181,90 @@ async def check_tariff_exists(session: AsyncSession, tariff_id: int):
        return False
    except SQLAlchemyError as e:
        logger.error(f"[TARIFF] Ошибка при проверке тарифа {tariff_id}: {e}")
+        await session.rollback()
+        return False
+
+
+async def get_tariff_sort_order(session: AsyncSession, tariff_id: int) -> int:
+    try:
+        result = await session.execute(select(Tariff.sort_order).where(Tariff.id == tariff_id))
+        sort_order = result.scalar_one_or_none()
+
+        if sort_order is None:
+            await session.execute(update(Tariff).where(Tariff.id == tariff_id).values(sort_order=1))
+            await session.commit()
+            return 1
+
+        return sort_order
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при получении sort_order для тарифа {tariff_id}: {e}")
+        await session.rollback()
+        return None
+
+
+async def move_tariff_up(session: AsyncSession, tariff_id: int) -> bool:
+    try:
+        current_order = await get_tariff_sort_order(session, tariff_id)
+        new_order = max(1, current_order - 1)
+
+        await session.execute(update(Tariff).where(Tariff.id == tariff_id).values(sort_order=new_order))
+        await session.commit()
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при перемещении тарифа {tariff_id} вверх: {e}")
+        await session.rollback()
+        return False
+
+
+async def move_tariff_down(session: AsyncSession, tariff_id: int) -> bool:
+    try:
+        current_order = await get_tariff_sort_order(session, tariff_id)
+        new_order = current_order + 1
+
+        await session.execute(update(Tariff).where(Tariff.id == tariff_id).values(sort_order=new_order))
+        await session.commit()
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при перемещении тарифа {tariff_id} вниз: {e}")
+        await session.rollback()
+        return False
+
+
+async def initialize_tariff_sort_orders(session: AsyncSession, group_code: str) -> bool:
+    try:
+        result = await session.execute(select(Tariff).where(Tariff.group_code == group_code).order_by(Tariff.id))
+        tariffs = result.scalars().all()
+
+        if not tariffs:
+            return True
+
+        for i, tariff in enumerate(tariffs):
+            new_sort_order = 1 + i
+            await session.execute(update(Tariff).where(Tariff.id == tariff.id).values(sort_order=new_sort_order))
+
+        await session.commit()
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при инициализации sort_order для группы {group_code}: {e}")
+        await session.rollback()
+        return False
+
+
+async def initialize_all_tariff_weights(session: AsyncSession) -> bool:
+    try:
+        result = await session.execute(select(Tariff).where(Tariff.sort_order.is_(None)))
+        tariffs_without_weight = result.scalars().all()
+
+        if not tariffs_without_weight:
+            return True
+
+        for tariff in tariffs_without_weight:
+            await session.execute(update(Tariff).where(Tariff.id == tariff.id).values(sort_order=1))
+
+        await session.commit()
+        return True
+
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при инициализации весов тарифов: {e}")
+        await session.rollback()
        return False
@@ -25,6 +25,7 @@ async def create_temporary_data(session: AsyncSession, tg_id: int, state: str, d
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при сохранении временных данных для {tg_id}: {e}")
        await session.rollback()
+        raise


 async def get_temporary_data(session: AsyncSession, tg_id: int) -> dict | None:
@@ -1,7 +1,8 @@
-from sqlalchemy import func, insert, not_, select
+from sqlalchemy import and_, func, insert, not_, select
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

+from core.constants import PAYMENT_SYSTEMS_EXCLUDED
 from database.models import Payment, TrackingSource, User
 from logger import logger

@@ -20,6 +21,7 @@ async def create_tracking_source(session: AsyncSession, name: str, code: str, ty
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при создании источника {code}: {e}")
        await session.rollback()
+        raise


 async def get_all_tracking_sources(session: AsyncSession) -> list[dict]:
@@ -40,7 +42,11 @@ async def get_all_tracking_sources(session: AsyncSession) -> list[dict]:
    payments_subq = (
        select(func.count(func.distinct(Payment.tg_id)))
        .join(User, Payment.tg_id == User.tg_id)
-        .where((User.source_code == TrackingSource.code) & (Payment.status == "success"))
+        .where(
+            (User.source_code == TrackingSource.code)
+            & (Payment.status == "success")
+            & Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED)
+        )
        .correlate(TrackingSource)
        .scalar_subquery()
    )
@@ -70,12 +76,17 @@ async def get_all_tracking_sources(session: AsyncSession) -> list[dict]:


 async def get_tracking_source_stats(session: AsyncSession, code: str) -> dict | None:
-    source_result = await session.execute(select(TrackingSource.created_at).where(TrackingSource.code == code))
-    created_at_row = source_result.first()
-    if not created_at_row:
+    def _month_key(dt) -> str:
+        return dt.strftime("%Y-%m")
+
+    src_row = await session.execute(
+        select(TrackingSource.name, TrackingSource.code, TrackingSource.created_at).where(TrackingSource.code == code)
+    )
+    src = src_row.first()
+    if not src:
        return None

-    created_at = created_at_row[0]
+    _src_name, _src_code, created_at = src

    reg_subq = (
        select(func.count(func.distinct(User.tg_id)))
@@ -95,25 +106,25 @@ async def get_tracking_source_stats(session: AsyncSession, code: str) -> dict |
        .where(
            (User.source_code == code)
            & (Payment.status == "success")
-            & not_(Payment.payment_system.in_(["coupon", "referral", "cashback"]))
+            & Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED)
            & (Payment.created_at >= created_at)
        )
        .scalar_subquery()
    )

    amount_subq = (
-        select(func.coalesce(func.sum(Payment.amount), 0))
+        select(func.coalesce(func.sum(Payment.amount), 0.0))
        .join(User, Payment.tg_id == User.tg_id)
        .where(
            (User.source_code == code)
            & (Payment.status == "success")
-            & not_(Payment.payment_system.in_(["coupon", "referral", "cashback"]))
+            & Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED)
            & (Payment.created_at >= created_at)
        )
        .scalar_subquery()
    )

-    query = select(
+    header_q = select(
        TrackingSource.name,
        TrackingSource.code,
        TrackingSource.created_at,
@@ -123,11 +134,115 @@ async def get_tracking_source_stats(session: AsyncSession, code: str) -> dict |
        amount_subq.label("total_amount"),
    ).where(TrackingSource.code == code)

-    result = await session.execute(query)
-    row = result.first()
+    header_res = await session.execute(header_q)
+    row = header_res.first()
    if not row:
        return None

+    payments_base = (
+        select(
+            Payment.tg_id.label("tg_id"),
+            Payment.amount.label("amount"),
+            Payment.created_at.label("dt"),
+        )
+        .join(User, Payment.tg_id == User.tg_id)
+        .where(
+            (User.source_code == code)
+            & (Payment.status == "success")
+            & Payment.payment_system.notin_(PAYMENT_SYSTEMS_EXCLUDED)
+            & (Payment.created_at >= created_at)
+        )
+        .subquery()
+    )
+
+    first_pay = (
+        select(
+            payments_base.c.tg_id.label("tg_id"),
+            func.min(payments_base.c.dt).label("first_dt"),
+        )
+        .group_by(payments_base.c.tg_id)
+        .subquery()
+    )
+
+    month_expr_new = func.date_trunc("month", payments_base.c.dt).label("month")
+    new_rows = await session.execute(
+        select(
+            month_expr_new,
+            func.count().label("cnt"),
+            func.coalesce(func.sum(payments_base.c.amount), 0.0).label("amt"),
+        )
+        .join(
+            first_pay,
+            and_(
+                payments_base.c.tg_id == first_pay.c.tg_id,
+                payments_base.c.dt == first_pay.c.first_dt,
+            ),
+        )
+        .group_by(month_expr_new)
+        .order_by(month_expr_new)
+    )
+    new_by_month = {r.month: (int(r.cnt), float(r.amt)) for r in new_rows.all()}
+
+    month_expr_rep = func.date_trunc("month", payments_base.c.dt).label("month")
+    repeat_rows = await session.execute(
+        select(
+            month_expr_rep,
+            func.count().label("cnt"),
+            func.coalesce(func.sum(payments_base.c.amount), 0.0).label("amt"),
+        )
+        .join(first_pay, payments_base.c.tg_id == first_pay.c.tg_id)
+        .where(payments_base.c.dt > first_pay.c.first_dt)
+        .group_by(month_expr_rep)
+        .order_by(month_expr_rep)
+    )
+    repeat_by_month = {r.month: (int(r.cnt), float(r.amt)) for r in repeat_rows.all()}
+
+    month_expr_regs = func.date_trunc("month", User.created_at).label("month")
+    regs_rows = await session.execute(
+        select(
+            month_expr_regs,
+            func.count(func.distinct(User.tg_id)).label("cnt"),
+        )
+        .where((User.source_code == code) & (User.created_at >= created_at))
+        .group_by(month_expr_regs)
+        .order_by(month_expr_regs)
+    )
+    regs_by_month = {r.month: int(r.cnt) for r in regs_rows.all()}
+
+    month_expr_trials = func.date_trunc("month", User.created_at).label("month")
+    trials_rows = await session.execute(
+        select(
+            month_expr_trials,
+            func.count(func.distinct(User.tg_id)).label("cnt"),
+        )
+        .where((User.source_code == code) & (User.trial == 1) & (User.created_at >= created_at))
+        .group_by(month_expr_trials)
+        .order_by(month_expr_trials)
+    )
+    trials_by_month = {r.month: int(r.cnt) for r in trials_rows.all()}
+
+    months = set()
+    months.update(regs_by_month.keys())
+    months.update(trials_by_month.keys())
+    months.update(new_by_month.keys())
+    months.update(repeat_by_month.keys())
+
+    monthly = []
+    for m in sorted(months):
+        regs = regs_by_month.get(m, 0)
+        trls = trials_by_month.get(m, 0)
+        new_cnt, new_amt = new_by_month.get(m, (0, 0.0))
+        rep_cnt, rep_amt = repeat_by_month.get(m, (0, 0.0))
+        monthly.append({
+            "month": _month_key(m),
+            "registrations": regs,
+            "trials": trls,
+            "new_purchases_count": new_cnt,
+            "new_purchases_amount": new_amt,
+            "repeat_purchases_count": rep_cnt,
+            "repeat_purchases_amount": rep_amt,
+        })
+
    return {
        "name": row.name,
        "code": row.code,
@@ -136,4 +251,5 @@ async def get_tracking_source_stats(session: AsyncSession, code: str) -> dict |
        "trials": row.trials or 0,
        "payments": row.payments or 0,
        "total_amount": float(row.total_amount or 0),
+        "monthly": monthly,
    }
@@ -1,6 +1,6 @@
 from datetime import datetime

-from sqlalchemy import delete, exists, or_, select, update
+from sqlalchemy import delete, exists, func, or_, select, update
 from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -11,6 +11,7 @@ from database.models import (
    CouponUsage,
    Gift,
    GiftUsage,
+    Key,
    Notification,
    Payment,
    Referral,
@@ -29,7 +30,8 @@ async def add_user(
    language_code: str = None,
    is_bot: bool = False,
    source_code: str = None,
-):
+    commit: bool = True,
+) -> bool:
    try:
        stmt = (
            insert(User)
@@ -42,12 +44,17 @@ async def add_user(
                is_bot=is_bot,
                source_code=source_code,
            )
-            .on_conflict_do_nothing(index_elements=[User.tg_id])
+            .on_conflict_do_nothing(index_elements=["tg_id"])
+            .returning(User.tg_id)
        )
-
-        await session.execute(stmt)
-        await session.commit()
+        res = await session.execute(stmt)
+        inserted_tg_id = res.scalar_one_or_none()
+        if inserted_tg_id is None:
+            return False
+        if commit:
+            await session.commit()
        logger.info(f"[DB] Новый пользователь добавлен: {tg_id} (source: {source_code})")
+        return True
    except SQLAlchemyError as e:
        logger.error(f"[DB] Ошибка при добавлении пользователя {tg_id}: {e}")
        await session.rollback()
@@ -56,12 +63,25 @@ async def add_user(

 async def update_balance(session: AsyncSession, tg_id: int, amount: float) -> None:
    try:
-        result = await session.execute(select(User.balance).where(User.tg_id == tg_id))
-        current = result.scalar_one_or_none() or 0
-        new_balance = current + amount
-        await session.execute(update(User).where(User.tg_id == tg_id).values(balance=new_balance))
+        if amount < 0:
+            current = await get_balance(session, tg_id)
+            if current + amount < 0:
+                logger.warning(f"[DB] Недостаточно средств: tg_id={tg_id} balance={current} списание={amount}")
+                await session.rollback()
+                raise ValueError(f"Недостаточно средств: баланс {current}, списание {amount}")
+        res = await session.execute(
+            update(User)
+            .where(User.tg_id == tg_id)
+            .values(balance=func.coalesce(User.balance, 0) + amount)
+            .returning(User.balance)
+        )
+        new_balance = res.scalar_one_or_none()
        await session.commit()
-        logger.info(f"[DB] Баланс пользователя {tg_id} обновлён: {current} → {new_balance}")
+        if new_balance is not None:
+            old_balance = new_balance - amount
+            logger.info(f"[DB] Баланс пользователя {tg_id} обновлён: {old_balance} → {new_balance}")
+        else:
+            logger.info(f"[DB] Баланс пользователя {tg_id} не изменён: пользователь не найден")
    except SQLAlchemyError as e:
        logger.error(f"[DB] Ошибка при обновлении баланса пользователя {tg_id}: {e}")
        await session.rollback()
@@ -74,9 +94,9 @@ async def check_user_exists(session: AsyncSession, tg_id: int) -> bool:


 async def get_balance(session: AsyncSession, tg_id: int) -> float:
-    result = await session.execute(select(User.balance).where(User.tg_id == tg_id))
+    result = await session.execute(select(func.coalesce(User.balance, 0.0)).where(User.tg_id == tg_id))
    balance = result.scalar_one_or_none()
-    return round(balance, 1) if balance is not None else 0.0
+    return round(float(balance or 0.0), 1)


 async def set_user_balance(session: AsyncSession, tg_id: int, balance: float) -> None:
@@ -86,6 +106,7 @@ async def set_user_balance(session: AsyncSession, tg_id: int, balance: float) ->
    except SQLAlchemyError as e:
        logger.error(f"Ошибка при установке баланса для пользователя {tg_id}: {e}")
        await session.rollback()
+        raise


 async def update_trial(session: AsyncSession, tg_id: int, status: int):
@@ -96,12 +117,13 @@ async def update_trial(session: AsyncSession, tg_id: int, status: int):
    except SQLAlchemyError as e:
        logger.error(f"[DB] Ошибка при обновлении триала пользователя {tg_id}: {e}")
        await session.rollback()
+        raise


 async def get_trial(session: AsyncSession, tg_id: int) -> int:
-    result = await session.execute(select(User.trial).where(User.tg_id == tg_id))
+    result = await session.execute(select(func.coalesce(User.trial, 0)).where(User.tg_id == tg_id))
    trial = result.scalar_one_or_none()
-    return trial or 0
+    return int(trial or 0)


 async def upsert_user(
@@ -114,53 +136,64 @@ async def upsert_user(
    is_bot: bool = False,
    only_if_exists: bool = False,
 ) -> dict | None:
+    """Создаёт пользователя или обновляет поля профиля."""
    try:
-        if only_if_exists:
-            result = await session.execute(select(User).where(User.tg_id == tg_id))
-            user = result.scalar_one_or_none()
-            if not user:
-                return None
+        now = datetime.utcnow()
+        returning_cols = list(User.__table__.c)

-            await session.execute(
+        if only_if_exists:
+            username_value = username if username else User.username
+            first_name_value = first_name if first_name else User.first_name
+            last_name_value = last_name if last_name else User.last_name
+            language_code_value = language_code if language_code else User.language_code
+
+            res = await session.execute(
                update(User)
                .where(User.tg_id == tg_id)
                .values(
-                    username=username or user.username,
-                    first_name=first_name or user.first_name,
-                    last_name=last_name or user.last_name,
-                    language_code=language_code or user.language_code,
+                    username=username_value,
+                    first_name=first_name_value,
+                    last_name=last_name_value,
+                    language_code=language_code_value,
                    is_bot=is_bot,
-                    updated_at=datetime.utcnow(),
+                    updated_at=now,
                )
+                .returning(*returning_cols)
            )
-        else:
-            await session.execute(
-                insert(User)
-                .values(
-                    tg_id=tg_id,
-                    username=username,
-                    first_name=first_name,
-                    last_name=last_name,
-                    language_code=language_code,
-                    is_bot=is_bot,
-                    created_at=datetime.utcnow(),
-                    updated_at=datetime.utcnow(),
-                )
-                .on_conflict_do_update(
-                    index_elements=[User.tg_id],
-                    set_={
-                        "username": username,
-                        "first_name": first_name,
-                        "last_name": last_name,
-                        "language_code": language_code,
-                        "is_bot": is_bot,
-                        "updated_at": datetime.utcnow(),
-                    },
-                )
+            row = res.mappings().one_or_none()
+            if row is None:
+                return None
+            await session.commit()
+            return dict(row)
+
+        res = await session.execute(
+            insert(User)
+            .values(
+                tg_id=tg_id,
+                username=username,
+                first_name=first_name,
+                last_name=last_name,
+                language_code=language_code,
+                is_bot=is_bot,
+                created_at=now,
+                updated_at=now,
            )
+            .on_conflict_do_update(
+                index_elements=[User.tg_id],
+                set_={
+                    "username": username,
+                    "first_name": first_name,
+                    "last_name": last_name,
+                    "language_code": language_code,
+                    "is_bot": is_bot,
+                    "updated_at": now,
+                },
+            )
+            .returning(*returning_cols)
+        )
+        row = res.mappings().one()
        await session.commit()
-        result = await session.execute(select(User).where(User.tg_id == tg_id))
-        return dict(result.scalar_one().__dict__)
+        return dict(row)
    except SQLAlchemyError as e:
        logger.error(f"[DB] Ошибка при UPSERT пользователя {tg_id}: {e}")
        await session.rollback()
@@ -170,29 +203,22 @@ async def upsert_user(
 async def delete_user_data(session: AsyncSession, tg_id: int):
    try:
        await session.execute(delete(Notification).where(Notification.tg_id == tg_id))
-
-        result = await session.execute(select(Gift.gift_id).where(Gift.sender_tg_id == tg_id))
-        gift_ids = [row[0] for row in result.all()]
-        if gift_ids:
-            await session.execute(delete(GiftUsage).where(GiftUsage.gift_id.in_(gift_ids)))
-
+        await session.execute(
+            delete(GiftUsage).where(GiftUsage.gift_id.in_(select(Gift.gift_id).where(Gift.sender_tg_id == tg_id)))
+        )
        await session.execute(delete(Gift).where(Gift.sender_tg_id == tg_id))
-
        await session.execute(update(Gift).where(Gift.recipient_tg_id == tg_id).values(recipient_tg_id=None))
-
        await session.execute(delete(Payment).where(Payment.tg_id == tg_id))
        await session.execute(
            delete(Referral).where(or_(Referral.referrer_tg_id == tg_id, Referral.referred_tg_id == tg_id))
        )
        await session.execute(delete(CouponUsage).where(CouponUsage.user_id == tg_id))
-        await delete_key(session, tg_id)
+        await delete_key(session, tg_id, commit=False)
        await session.execute(delete(TemporaryData).where(TemporaryData.tg_id == tg_id))
        await session.execute(delete(BlockedUser).where(BlockedUser.tg_id == tg_id))
        await session.execute(delete(User).where(User.tg_id == tg_id))
-
        await session.commit()
        logger.info(f"[DB] Данные пользователя {tg_id} полностью удалены")
-
    except SQLAlchemyError as e:
        await session.rollback()
        logger.error(f"[DB] Ошибка при удалении данных пользователя {tg_id}: {e}")
@@ -202,3 +228,40 @@ async def delete_user_data(session: AsyncSession, tg_id: int):
 async def mark_trial_extended(tg_id: int, session: AsyncSession):
    await session.execute(update(User).where(User.tg_id == tg_id).values(trial=-1))
    await session.commit()
+
+
+async def get_user_snapshot(session: AsyncSession, tg_id: int) -> tuple[int, int] | None:
+    keys_count_sq = select(func.count(Key.client_id)).where(Key.tg_id == tg_id).scalar_subquery()
+
+    res = await session.execute(select(func.coalesce(User.trial, 0), keys_count_sq).where(User.tg_id == tg_id))
+    row = res.first()
+    if row is None:
+        return None
+    return int(row[0]), int(row[1])
+
+
+async def upsert_source_if_empty(
+    session: AsyncSession,
+    tg_id: int,
+    source_code: str,
+    commit: bool = True,
+) -> bool:
+    if not source_code:
+        return False
+    stmt = (
+        insert(User)
+        .values(tg_id=tg_id, source_code=source_code)
+        .on_conflict_do_update(
+            index_elements=["tg_id"],
+            set_={"source_code": insert(User).excluded.source_code},
+            where=(User.source_code.is_(None)),
+        )
+        .returning(User.tg_id)
+    )
+    res = await session.execute(stmt)
+    changed_tg_id = res.scalar_one_or_none()
+    if changed_tg_id is None:
+        return False
+    if commit:
+        await session.commit()
+    return True
@@ -0,0 +1,9 @@
+services:
+  bot:
+    container_name: solobot
+    build: .
+    restart: unless-stopped
+    network_mode: host
+    volumes:
+      - /:/host:ro
+
@@ -1,17 +1,70 @@
+import time
+
 from aiogram.filters import BaseFilter
 from aiogram.types import CallbackQuery, Message
 from sqlalchemy import select

+from config import ADMIN_ID
 from database.db import async_session_maker
 from database.models import Admin


+_ADMIN_CACHE: dict[int, tuple[float, bool, bool]] = {}
+_ADMIN_CACHE_TTL = 60
+
+
+def _get_cached_admin(user_id: int) -> tuple[bool, bool] | None:
+    now = time.time()
+    entry = _ADMIN_CACHE.get(user_id)
+    if entry and entry[0] > now:
+        return entry[1], entry[2]
+    return None
+
+
+def _set_cached_admin(user_id: int, is_admin: bool, is_superadmin: bool) -> None:
+    _ADMIN_CACHE[user_id] = (time.time() + _ADMIN_CACHE_TTL, is_admin, is_superadmin)
+
+
 class IsAdminFilter(BaseFilter):
    async def __call__(self, event: Message | CallbackQuery) -> bool:
+        if not event.from_user:
+            return False
+
+        user_id = event.from_user.id
+        cached = _get_cached_admin(user_id)
+        if cached is not None:
+            return cached[0]
+
        try:
            async with async_session_maker() as session:
-                result = await session.execute(select(Admin).where(Admin.tg_id == event.from_user.id))
-                admin = result.scalar_one_or_none()
-                return admin is not None
-        except Exception:
+                admin = (await session.execute(select(Admin).where(Admin.tg_id == user_id))).scalar_one_or_none()
+                admin_ids = (ADMIN_ID,) if isinstance(ADMIN_ID, int) else ADMIN_ID
+                is_admin = admin is not None or user_id in admin_ids
+                is_super = admin.role != "moderator" if admin else (user_id in admin_ids)
+                _set_cached_admin(user_id, is_admin, is_super)
+                return is_admin
+        except (Exception,):
+            return False
+
+
+class IsSuperAdminFilter(BaseFilter):
+    async def __call__(self, event: Message | CallbackQuery) -> bool:
+        if not event.from_user:
+            return False
+
+        user_id = event.from_user.id
+        cached = _get_cached_admin(user_id)
+        if cached is not None:
+            return cached[1]
+
+        try:
+            async with async_session_maker() as session:
+                admin = (await session.execute(select(Admin).where(Admin.tg_id == user_id))).scalar_one_or_none()
+                if not admin:
+                    _set_cached_admin(user_id, False, False)
+                    return False
+                is_super = admin.role != "moderator"
+                _set_cached_admin(user_id, True, is_super)
+                return is_super
+        except (Exception,):
            return False
@@ -9,11 +9,11 @@ from .donate import router as donate_router
 from .instructions import router as instructions_router
 from .keys import router as keys_router
 from .notifications import router as notifications_router
-from .pay import router as pay_router
 from .payments import router as payments_router
 from .profile import router as profile_router
 from .refferal import router as refferal_router
 from .start import router as start_router
+from .tariffs import router as tariff_router


 router = Router(name="handlers_main_router")
@@ -22,7 +22,6 @@ router.include_routers(
    start_router,
    captcha_router,
    profile_router,
-    pay_router,
    donate_router,
    coupons_router,
    notifications_router,
@@ -31,4 +30,5 @@ router.include_routers(
    instructions_router,
    admin_router,
    refferal_router,
+    tariff_router,
 )
@@ -7,12 +7,15 @@ from .backups import router as backups_router
 from .bans import router as bans_router
 from .clusters import router as clusters_router
 from .coupons import router as coupons_router
+from .emoji import router as emoji_router
 from .gifts import router as gifts_router
 from .management import router as management_router
+from .module import router as modules_router
 from .panel import router as panel_router
 from .restart import router as restart_router
 from .sender import router as sender_router
 from .servers import router as servers_router
+from .settings import router as settings_router
 from .stats import router as stats_router
 from .tariffs import router as tariffs_router
 from .users import router as users_router
@@ -21,6 +24,7 @@ from .users import router as users_router
 router = Router(name="admins_main_router")

 router.include_routers(
+    modules_router,
    panel_router,
    management_router,
    servers_router,
@@ -30,9 +34,11 @@ router.include_routers(
    backups_router,
    sender_router,
    coupons_router,
+    emoji_router,
    restart_router,
    bans_router,
    ads_router,
    tariffs_router,
    gifts_router,
+    settings_router,
 )
@@ -3,6 +3,7 @@ from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder

 from ..panel.keyboard import build_admin_back_btn
+from handlers.buttons import BACK


 class AdminAdsCallback(CallbackData, prefix="admin_ads"):
@@ -43,7 +44,7 @@ def build_ads_list_kb(ads: list, current_page: int, total_pages: int) -> InlineK
    if current_page > 1:
        pagination_buttons.append(
            InlineKeyboardButton(
-                text="⬅️ Назад",
+                text=BACK,
                callback_data=AdminAdsCallback(action="list", code=f"{current_page - 1}").pack(),
            )
        )
@@ -1,8 +1,8 @@
 from aiogram import F, Router
 from aiogram.types import CallbackQuery

-from backup import backup_database
 from filters.admin import IsAdminFilter
+from utils.backup import backup_database

 from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb

@@ -7,17 +7,23 @@ from aiogram import F, Router
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
 from aiogram.types import BufferedInputFile, CallbackQuery, Message
-from sqlalchemy import delete, text
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from sqlalchemy import delete, func, or_, select
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.ext.asyncio import AsyncSession

 from database import delete_user_data
-from database.models import ManualBan
+from database.models import BlockedUser, Key, ManualBan
 from filters.admin import IsAdminFilter
 from logger import logger

-from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
-from .keyboard import build_bans_kb
+from ..panel.keyboard import AdminPanelCallback
+from .keyboard import (
+    build_bans_kb,
+    build_blocked_users_kb,
+    build_manual_bans_kb,
+    build_shadow_bans_kb,
+)


 router = Router()
@@ -32,25 +38,59 @@ async def handle_bans(callback_query: CallbackQuery):
    text_ = (
        "🚫 <b>Управление банами</b>\n\n"
        "📛 <b>Забанившие бота</b> — пользователи, которые заблокировали бота вручную.\n"
-        "🔒 <b>Ручной бан</b> — пользователи, которых вы забанили через админку.\n\n"
+        "👻 <b>Теневые баны</b> — пользователи, действия которых игнорируются.\n"
+        "🔒 <b>Ручные баны</b> — пользователи, которых вы забанили через админку.\n\n"
        "⬇ Выберите нужный раздел:"
    )
    await callback_query.message.edit_text(text=text_, reply_markup=build_bans_kb())


+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_blocked_menu"), IsAdminFilter())
+async def handle_blocked_users_menu(callback_query: CallbackQuery):
+    text_ = (
+        "📛 <b>Забанившие бота</b>\n\n"
+        "Пользователи, которые заблокировали бота вручную или удалили чат.\n"
+        "⬇ Выберите действие:"
+    )
+    await callback_query.message.edit_text(text=text_, reply_markup=build_blocked_users_kb())
+
+
+def get_shadow_bans_menu_text() -> str:
+    return (
+        "👻 <b>Теневые баны</b>\n\n"
+        "Пользователи, действия которых игнорируются ботом.\n"
+        "Они не получают уведомлений о бане.\n\n"
+        "💡 <b>Можно добавить несколько пользователей за раз:</b>\n"
+        "Отправьте список Telegram ID (один на строке).\n"
+        "Пример:\n<code>123456789\n987654321\n555666777</code>\n\n"
+        "⬇ Выберите действие:"
+    )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_shadow_menu"), IsAdminFilter())
+async def handle_shadow_bans_menu(callback_query: CallbackQuery):
+    await callback_query.message.edit_text(text=get_shadow_bans_menu_text(), reply_markup=build_shadow_bans_kb())
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_manual_menu"), IsAdminFilter())
+async def handle_manual_bans_menu(callback_query: CallbackQuery):
+    text_ = "🔒 <b>Ручные баны</b>\n\nПользователи, которых вы забанили через админку.\n⬇ Выберите действие:"
+    await callback_query.message.edit_text(text=text_, reply_markup=build_manual_bans_kb())
+
+
@router.callback_query(AdminPanelCallback.filter(F.action == "bans_export"), IsAdminFilter())
 async def handle_bans_export(callback_query: CallbackQuery, session: AsyncSession):
-    kb = build_admin_back_kb("management")
+    kb = build_blocked_users_kb()
    try:
-        result = await session.execute(text("SELECT tg_id FROM blocked_users"))
-        banned_users = result.all()
+        result = await session.execute(select(BlockedUser.tg_id))
+        banned_users = result.scalars().all()

        csv_output = io.StringIO()
        writer = csv.writer(csv_output)
        writer.writerow(["tg_id"])

-        for user in banned_users:
-            writer.writerow([user.tg_id])
+        for tg_id in banned_users:
+            writer.writerow([tg_id])

        csv_output.seek(0)
        document = BufferedInputFile(file=csv_output.getvalue().encode("utf-8"), filename="banned_users.csv")
@@ -68,11 +108,11 @@ async def handle_bans_export(callback_query: CallbackQuery, session: AsyncSessio

@router.callback_query(AdminPanelCallback.filter(F.action == "bans_delete_banned"), IsAdminFilter())
 async def handle_bans_delete_banned(callback_query: CallbackQuery, session: AsyncSession):
-    kb = build_admin_back_kb("bans")
+    kb = build_blocked_users_kb()
    try:
-        result = await session.execute(text("SELECT tg_id FROM blocked_users"))
-        blocked_users = result.all()
-        blocked_ids = [user.tg_id for user in blocked_users]
+        stmt = select(BlockedUser.tg_id).outerjoin(Key, BlockedUser.tg_id == Key.tg_id).where(Key.tg_id.is_(None))
+        result = await session.execute(stmt)
+        blocked_ids = [row[0] for row in result.all()]

        if not blocked_ids:
            await callback_query.message.answer(
@@ -84,12 +124,6 @@ async def handle_bans_delete_banned(callback_query: CallbackQuery, session: Asyn
        for tg_id in blocked_ids:
            await delete_user_data(session, tg_id)

-        await session.execute(
-            text("DELETE FROM blocked_users WHERE tg_id = ANY(:blocked_ids)"),
-            {"blocked_ids": blocked_ids},
-        )
-        await session.commit()
-
        await callback_query.message.answer(
            text=f"🗑️ Удалены данные о {len(blocked_ids)} пользователях и связанных записях.",
            reply_markup=kb,
@@ -101,58 +135,188 @@ async def handle_bans_delete_banned(callback_query: CallbackQuery, session: Asyn
        )


-@router.callback_query(AdminPanelCallback.filter(F.action == "manual_bans_export"), IsAdminFilter())
-async def handle_manual_bans_export(callback_query: CallbackQuery, session: AsyncSession):
-    build_admin_back_kb("bans")
+@router.callback_query(AdminPanelCallback.filter(F.action == "shadow_bans_export"), IsAdminFilter())
+async def handle_shadow_bans_export(callback_query: CallbackQuery, session: AsyncSession):
+    kb = build_shadow_bans_kb()
    try:
-        result = await session.execute(text("SELECT tg_id, banned_at, reason, until FROM manual_bans"))
+        result = await session.execute(
+            select(ManualBan.tg_id, ManualBan.banned_at, ManualBan.banned_by, ManualBan.until).where(
+                ManualBan.reason == "shadow"
+            )
+        )
        rows = result.all()

        csv_output = io.StringIO()
        writer = csv.writer(csv_output)
-        writer.writerow(["tg_id", "banned_at", "reason", "until"])
+        writer.writerow(["tg_id", "banned_at", "banned_by", "until"])

        for user in rows:
-            writer.writerow([user.tg_id, user.banned_at, user.reason, user.until])
+            writer.writerow([user.tg_id, user.banned_at, user.banned_by, user.until])
+
+        csv_output.seek(0)
+        document = BufferedInputFile(file=csv_output.getvalue().encode("utf-8"), filename="shadow_bans.csv")
+
+        await callback_query.message.answer_document(
+            document=document,
+            caption="📥 Экспорт теневых банов (CSV)",
+        )
+    except Exception as e:
+        await callback_query.message.answer(
+            text=f"❗ Ошибка при экспорте: {e}",
+            reply_markup=kb,
+        )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "manual_bans_export"), IsAdminFilter())
+async def handle_manual_bans_export(callback_query: CallbackQuery, session: AsyncSession):
+    kb = build_manual_bans_kb()
+    try:
+        result = await session.execute(
+            select(ManualBan.tg_id, ManualBan.banned_at, ManualBan.reason, ManualBan.until, ManualBan.banned_by).where(
+                or_(ManualBan.reason != "shadow", ManualBan.reason.is_(None))
+            )
+        )
+        rows = result.all()
+
+        csv_output = io.StringIO()
+        writer = csv.writer(csv_output)
+        writer.writerow(["tg_id", "banned_at", "reason", "until", "banned_by"])
+
+        for user in rows:
+            writer.writerow([user.tg_id, user.banned_at, user.reason, user.until, user.banned_by])

        csv_output.seek(0)
        document = BufferedInputFile(file=csv_output.getvalue().encode("utf-8"), filename="manual_bans.csv")

        await callback_query.message.answer_document(
            document=document,
-            caption="📥 Экспорт вручную забаненных пользователей",
+            caption="📥 Экспорт вручную забаненных пользователей (CSV)",
        )
    except Exception as e:
        await callback_query.message.answer(
            text=f"❗ Ошибка при экспорте: {e}",
-            reply_markup=build_admin_back_kb("bans"),
+            reply_markup=kb,
        )


-@router.callback_query(AdminPanelCallback.filter(F.action == "bans_delete_manual"), IsAdminFilter())
-async def handle_delete_manual_banned(callback_query: CallbackQuery, session: AsyncSession):
+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_clear_blocked"), IsAdminFilter())
+async def handle_clear_blocked_users(callback_query: CallbackQuery, session: AsyncSession):
+    kb = build_blocked_users_kb()
    try:
-        await session.execute(delete(ManualBan))
+        count_result = await session.execute(select(func.count()).select_from(BlockedUser))
+        total_count = count_result.scalar() or 0
+
+        if total_count == 0:
+            await callback_query.message.answer(
+                text="📂 Нет забанивших пользователей для очистки.",
+                reply_markup=kb,
+            )
+            return
+
+        await session.execute(delete(BlockedUser))
        await session.commit()
-        await callback_query.message.edit_text(
-            "🗑️ Вручную забаненные пользователи удалены.",
-            reply_markup=build_bans_kb(),
+
+        await callback_query.message.answer(
+            text=f"🗑️ Очищено {total_count} записей забанивших пользователей из базы данных.",
+            reply_markup=kb,
        )
-        logger.info("[BANS] Очищены записи из manual_bans")
+        logger.info(f"[BANS] Очищено {total_count} записей из blocked_users")
    except Exception as e:
-        logger.error(f"[BANS] Ошибка при очистке manual_bans: {e}")
-        await callback_query.message.edit_text("❌ Ошибка при удалении вручную забаненных пользователей.")
+        logger.error(f"[BANS] Ошибка при очистке blocked_users: {e}")
+        await callback_query.message.answer(
+            text=f"❗ Ошибка при очистке забанивших пользователей: {e}",
+            reply_markup=kb,
+        )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_clear_shadow"), IsAdminFilter())
+async def handle_clear_shadow_bans(callback_query: CallbackQuery, session: AsyncSession):
+    kb = build_shadow_bans_kb()
+    try:
+        count_result = await session.execute(
+            select(func.count()).select_from(ManualBan).where(ManualBan.reason == "shadow")
+        )
+        total_count = count_result.scalar() or 0
+
+        if total_count == 0:
+            await callback_query.message.answer(
+                text="📂 Нет теневых банов для очистки.",
+                reply_markup=kb,
+            )
+            return
+
+        await session.execute(delete(ManualBan).where(ManualBan.reason == "shadow"))
+        await session.commit()
+
+        await callback_query.message.answer(
+            text=f"🗑️ Очищено {total_count} записей теневых банов из базы данных.",
+            reply_markup=kb,
+        )
+        logger.info(f"[BANS] Очищено {total_count} записей теневых банов из manual_bans")
+    except Exception as e:
+        logger.error(f"[BANS] Ошибка при очистке теневых банов: {e}")
+        await callback_query.message.answer(
+            text=f"❗ Ошибка при очистке теневых банов: {e}",
+            reply_markup=kb,
+        )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_clear_manual"), IsAdminFilter())
+async def handle_clear_manual_bans(callback_query: CallbackQuery, session: AsyncSession):
+    kb = build_manual_bans_kb()
+    try:
+        count_result = await session.execute(
+            select(func.count())
+            .select_from(ManualBan)
+            .where(or_(ManualBan.reason != "shadow", ManualBan.reason.is_(None)))
+        )
+        total_count = count_result.scalar() or 0
+
+        if total_count == 0:
+            await callback_query.message.answer(
+                text="📂 Нет ручных банов для очистки.",
+                reply_markup=kb,
+            )
+            return
+
+        await session.execute(delete(ManualBan).where(or_(ManualBan.reason != "shadow", ManualBan.reason.is_(None))))
+        await session.commit()
+
+        await callback_query.message.answer(
+            text=f"🗑️ Очищено {total_count} записей ручных банов из базы данных.",
+            reply_markup=kb,
+        )
+        logger.info(f"[BANS] Очищено {total_count} записей ручных банов из manual_bans")
+    except Exception as e:
+        logger.error(f"[BANS] Ошибка при очистке ручных банов: {e}")
+        await callback_query.message.answer(
+            text=f"❗ Ошибка при очистке ручных банов: {e}",
+            reply_markup=kb,
+        )


@router.callback_query(AdminPanelCallback.filter(F.action == "bans_preemptive"), IsAdminFilter())
 async def handle_preemptive_ban_start(callback: CallbackQuery, state: FSMContext):
    await state.set_state(PreemptiveBanStates.waiting_for_preemptive_ids)
+
+    builder = InlineKeyboardBuilder()
+    builder.button(
+        text="❌ Отмена",
+        callback_data=AdminPanelCallback(action="bans_cancel_preemptive").pack(),
+    )
    await callback.message.edit_text(
        "📥 Отправьте список Telegram ID (один на строке), которых нужно заранее забанить (теневой бан).\n\n"
-        "Пример:\n<code>123456789\n987654321</code>"
+        "Пример:\n<code>123456789\n987654321</code>",
+        reply_markup=builder.as_markup(),
    )


+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_cancel_preemptive"), IsAdminFilter())
+async def handle_cancel_preemptive_ban(callback: CallbackQuery, state: FSMContext):
+    await state.clear()
+    await callback.message.edit_text(text=get_shadow_bans_menu_text(), reply_markup=build_shadow_bans_kb())
+
+
@router.message(PreemptiveBanStates.waiting_for_preemptive_ids, IsAdminFilter())
 async def handle_preemptive_ids_input(message: Message, state: FSMContext, session: AsyncSession):
    lines = message.text.strip().splitlines()
@@ -195,5 +359,8 @@ async def handle_preemptive_ids_input(message: Message, state: FSMContext, sessi
    await session.execute(stmt)
    await session.commit()

-    await message.answer(f"✅ Успешно добавлено в теневой бан: <b>{len(tg_ids)}</b> пользователей.")
+    await message.answer(
+        f"✅ Успешно добавлено в теневой бан: <b>{len(tg_ids)}</b> пользователей.",
+        reply_markup=build_shadow_bans_kb(),
+    )
    await state.clear()
@@ -1,7 +1,7 @@
-from aiogram.types import InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder

-from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
+from ..panel.keyboard import AdminPanelCallback
+from handlers.buttons import BACK


 def build_bans_kb():
@@ -9,27 +9,87 @@ def build_bans_kb():

    builder.button(
        text="📛 Забанившие бота",
+        callback_data=AdminPanelCallback(action="bans_blocked_menu").pack(),
+    )
+    builder.button(
+        text="👻 Теневые баны",
+        callback_data=AdminPanelCallback(action="bans_shadow_menu").pack(),
+    )
+    builder.button(
+        text="🔒 Ручные баны",
+        callback_data=AdminPanelCallback(action="bans_manual_menu").pack(),
+    )
+    builder.button(
+        text=BACK,
+        callback_data=AdminPanelCallback(action="management").pack(),
+    )
+
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_blocked_users_kb():
+    builder = InlineKeyboardBuilder()
+
+    builder.button(
+        text="📥 Экспорт",
        callback_data=AdminPanelCallback(action="bans_export").pack(),
    )
-    builder.button(
-        text="📛 Забаненные вручную",
-        callback_data=AdminPanelCallback(action="manual_bans_export").pack(),
-    )
-    builder.button(
-        text="Забанить заранее",
-        callback_data=AdminPanelCallback(action="bans_preemptive").pack(),
-    )
    builder.button(
        text="🗑️ Удалить забанивших",
        callback_data=AdminPanelCallback(action="bans_delete_banned").pack(),
    )
    builder.button(
-        text="🗑️ Очистить забаненных",
-        callback_data=AdminPanelCallback(action="bans_delete_manual").pack(),
+        text="🗑️ Очистить забанивших",
+        callback_data=AdminPanelCallback(action="bans_clear_blocked").pack(),
    )
    builder.button(
-        text="🔙 Назад",
-        callback_data=AdminPanelCallback(action="management").pack(),
+        text=BACK,
+        callback_data=AdminPanelCallback(action="bans").pack(),
+    )
+
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_shadow_bans_kb():
+    builder = InlineKeyboardBuilder()
+
+    builder.button(
+        text="📥 Экспорт",
+        callback_data=AdminPanelCallback(action="shadow_bans_export").pack(),
+    )
+    builder.button(
+        text="➕ Забанить заранее",
+        callback_data=AdminPanelCallback(action="bans_preemptive").pack(),
+    )
+    builder.button(
+        text="🗑️ Очистить теневые баны",
+        callback_data=AdminPanelCallback(action="bans_clear_shadow").pack(),
+    )
+    builder.button(
+        text=BACK,
+        callback_data=AdminPanelCallback(action="bans").pack(),
+    )
+
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_manual_bans_kb():
+    builder = InlineKeyboardBuilder()
+
+    builder.button(
+        text="📥 Экспорт",
+        callback_data=AdminPanelCallback(action="manual_bans_export").pack(),
+    )
+    builder.button(
+        text="🗑️ Очистить ручные баны",
+        callback_data=AdminPanelCallback(action="bans_clear_manual").pack(),
+    )
+    builder.button(
+        text=BACK,
+        callback_data=AdminPanelCallback(action="bans").pack(),
    )

    builder.adjust(1)
@@ -1,3 +1,5 @@
-__all__ = ("router",)
+from . import cluster_manage, cluster_sync, cluster_tariffs, cluster_transfers, cluster_wizard  # noqa
+from .base import AdminClusterStates, router

-from .clusters_handler import router
+
+__all__ = ["router", "AdminClusterStates"]
@@ -0,0 +1,18 @@
+from aiogram import Router
+from aiogram.fsm.state import State, StatesGroup
+
+
+router = Router()
+
+
+class AdminClusterStates(StatesGroup):
+    waiting_for_cluster_name = State()
+    waiting_for_api_url = State()
+    waiting_for_inbound_id = State()
+    waiting_for_server_name = State()
+    waiting_for_subscription_url = State()
+    waiting_for_days_input = State()
+    waiting_for_new_cluster_name = State()
+    waiting_for_new_server_name = State()
+    waiting_for_server_transfer = State()
+    waiting_for_cluster_transfer = State()
@@ -0,0 +1,452 @@
+from datetime import datetime
+
+from aiogram import F, types
+from aiogram.fsm.context import FSMContext
+from aiogram.types import CallbackQuery, Message
+from sqlalchemy import func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database import get_servers, update_key_expiry
+from database.models import Key, Server, Tariff
+from filters.admin import IsAdminFilter
+from handlers.keys.operations import renew_key_in_cluster
+from logger import logger
+
+from ..panel.keyboard import build_admin_back_kb
+from .base import AdminClusterStates, router
+from .keyboard import (
+    AdminClusterCallback,
+    AdminServerCallback,
+    build_cluster_management_kb,
+    build_manage_cluster_kb,
+)
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "manage"), IsAdminFilter())
+async def handle_clusters_manage(
+    callback_query: types.CallbackQuery,
+    callback_data: AdminClusterCallback,
+    session: AsyncSession,
+):
+    cluster_name = callback_data.data
+
+    result = await session.execute(
+        select(Server.tariff_group)
+        .where(
+            Server.cluster_name == cluster_name,
+            Server.tariff_group.isnot(None),
+        )
+        .limit(1)
+    )
+    row = result.first()
+    tariff_group = row[0] if row else "—"
+
+    result = await session.execute(select(Server.server_name).where(Server.cluster_name == cluster_name))
+    server_names = [row[0] for row in result.all()]
+    result = await session.execute(
+        select(func.count(func.distinct(Key.tg_id))).where(
+            (Key.server_id == cluster_name) | (Key.server_id.in_(server_names))
+        )
+    )
+    user_count = result.scalar() or 0
+
+    result = await session.execute(
+        select(func.count()).where((Key.server_id == cluster_name) | (Key.server_id.in_(server_names)))
+    )
+    subscription_count = result.scalar() or 0
+
+    text = (
+        f"<b>🔧 Управление кластером <code>{cluster_name}</code></b>\n\n"
+        f"📁 <b>Тарифная группа:</b> <code>{tariff_group}</code>\n"
+        f"👥 <b>Пользователей на кластере:</b> <code>{user_count}</code>\n"
+        f"🔑 <b>Всего подписок:</b> <code>{subscription_count}</code>"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_cluster_management_kb(cluster_name),
+    )
+
+
+@router.callback_query(F.data.startswith("cluster_servers|"), IsAdminFilter())
+async def handle_cluster_servers(callback: CallbackQuery, session: AsyncSession):
+    cluster_name = callback.data.split("|", 1)[1]
+    servers = await get_servers(session=session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+
+    from handlers.utils import ALLOWED_GROUP_CODES
+
+    allowed = set(ALLOWED_GROUP_CODES)
+    lines = []
+    for s in cluster_servers:
+        tids = s.get("tariff_ids") or []
+        subs = s.get("tariff_subgroups") or []
+        if tids:
+            subs_str = f"{len(tids)} тариф(ов)"
+        elif subs:
+            subs_str = ", ".join(sorted(subs))
+        else:
+            subs_str = "—"
+
+        grps = s.get("special_groups") or []
+        grps = [g for g in grps if g in allowed]
+        grps_str = ", ".join(sorted(grps)) if grps else "—"
+
+        lines.append(f"• {s.get('server_name', '?')} — {subs_str} | {grps_str}")
+
+    details = "\n".join(lines) if lines else "нет серверов"
+
+    await callback.message.edit_text(
+        text=(
+            f"<b>📡 Серверы в кластере {cluster_name}</b>\n<i>подгруппы | спецгруппы:</i>\n"
+            f"<blockquote>{details}</blockquote>"
+        ),
+        reply_markup=build_manage_cluster_kb(cluster_servers, cluster_name),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "add_time"), IsAdminFilter())
+async def handle_add_time(
+    callback_query: CallbackQuery,
+    callback_data: AdminClusterCallback,
+    state: FSMContext,
+):
+    cluster_name = callback_data.data
+    await state.set_state(AdminClusterStates.waiting_for_days_input)
+    await state.update_data(cluster_name=cluster_name)
+
+    await callback_query.message.edit_text(
+        f"⏳ Введите количество дней, на которое хотите продлить все подписки в кластере <b>{cluster_name}</b>:",
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+
+
+@router.message(AdminClusterStates.waiting_for_days_input, IsAdminFilter())
+async def handle_days_input(message: Message, state: FSMContext, session: AsyncSession):
+    try:
+        days = int(message.text.strip())
+        if days <= 0:
+            raise ValueError
+
+        user_data = await state.get_data()
+        cluster_name = user_data.get("cluster_name")
+        add_ms = days * 86400 * 1000
+
+        logger.info(f"[Cluster Extend] Добавляем {days} дней для кластера: {cluster_name}")
+
+        server_stmt = select(Server.server_name).where(Server.cluster_name == cluster_name)
+        server_rows = await session.execute(server_stmt)
+        server_names = [row[0] for row in server_rows.all()]
+        server_names.append(cluster_name)
+
+        result = await session.execute(select(Key).where(Key.server_id.in_(server_names)))
+        keys = result.scalars().all()
+
+        if not keys:
+            await message.answer("❌ Нет подписок в этом кластере или сервере.")
+            await state.clear()
+            return
+
+        servers = await get_servers(session=session)
+        cluster_servers = servers.get(cluster_name, [])
+
+        if not cluster_servers:
+            await message.answer("❌ Не найдены серверы в кластере.")
+            await state.clear()
+            return
+
+        is_full_remnawave = all(str(s.get("panel_type", "")).lower() == "remnawave" for s in cluster_servers)
+
+        if is_full_remnawave:
+            uuids = [key.client_id for key in keys if key.client_id]
+
+            if not uuids:
+                await message.answer("❌ Нет валидных подписок для продления.")
+                await state.clear()
+                return
+
+            api_url = cluster_servers[0].get("api_url", "")
+            if not api_url:
+                await message.answer("❌ Не найден URL панели для кластера.")
+                await state.clear()
+                return
+
+            from panels.remnawave import RemnawaveAPI
+
+            remna = RemnawaveAPI(api_url)
+
+            try:
+                result_bulk = await remna.bulk_extend_expiration_date(uuids, days)
+            finally:
+                await remna.aclose()
+
+            if result_bulk is None:
+                await message.answer("❌ Ошибка при обращении к API панели.")
+                await state.clear()
+                return
+
+            affected = result_bulk.get("affectedRows", 0)
+            logger.info(f"[Cluster Extend] Bulk API: продлено {affected} подписок на {days} дней")
+
+            for key in keys:
+                new_expiry = key.expiry_time + add_ms
+                await update_key_expiry(session, key.client_id, new_expiry)
+
+            await session.commit()
+
+            await message.answer(
+                f"✅ Время подписки продлено на <b>{days} дней</b> для <b>{affected}</b> пользователей в кластере <b>{cluster_name}</b>."
+            )
+        else:
+            for key in keys:
+                new_expiry = key.expiry_time + add_ms
+
+                traffic_limit = 0
+                device_limit = 0
+                key_subgroup = None
+                if key.tariff_id:
+                    tariff_result = await session.execute(
+                        select(Tariff.traffic_limit, Tariff.device_limit, Tariff.subgroup_title).where(
+                            Tariff.id == key.tariff_id,
+                            Tariff.is_active.is_(True),
+                        )
+                    )
+                    tariff = tariff_result.first()
+                    if tariff:
+                        traffic_limit = int(tariff[0]) if tariff[0] is not None else 0
+                        device_limit = int(tariff[1]) if tariff[1] is not None else 0
+                        key_subgroup = tariff[2]
+
+                await renew_key_in_cluster(
+                    cluster_name,
+                    email=key.email,
+                    client_id=key.client_id,
+                    new_expiry_time=new_expiry,
+                    total_gb=traffic_limit,
+                    session=session,
+                    hwid_device_limit=device_limit,
+                    reset_traffic=False,
+                    target_subgroup=key_subgroup,
+                    old_subgroup=key_subgroup,
+                    plan=key.tariff_id,
+                )
+                await update_key_expiry(session, key.client_id, new_expiry)
+
+                logger.info(f"[Cluster Extend] {key.email} +{days}д → {datetime.utcfromtimestamp(new_expiry / 1000)}")
+
+            await message.answer(
+                f"✅ Время подписки продлено на <b>{days} дней</b> всем пользователям в кластере <b>{cluster_name}</b>."
+            )
+
+    except ValueError:
+        await message.answer("❌ Введите корректное число дней.")
+    except Exception as e:
+        logger.error(f"[Cluster Extend] Ошибка при добавлении дней: {e}")
+        await message.answer("❌ Произошла ошибка при продлении времени.")
+    finally:
+        await state.clear()
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "rename"), IsAdminFilter())
+async def handle_rename_cluster(
+    callback_query: CallbackQuery,
+    callback_data: AdminClusterCallback,
+    state: FSMContext,
+):
+    cluster_name = callback_data.data
+    await state.update_data(old_cluster_name=cluster_name)
+
+    text = (
+        f"✏️ <b>Введите новое имя для кластера '{cluster_name}':</b>\n\n"
+        "▸ Имя должно быть уникальным.\n"
+        "▸ Имя не должно превышать 12 символов.\n\n"
+        "📌 <i>Пример:</i> <code>new_cluster</code>"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+    await state.set_state(AdminClusterStates.waiting_for_new_cluster_name)
+
+
+@router.message(AdminClusterStates.waiting_for_new_cluster_name, IsAdminFilter())
+async def handle_new_cluster_name_input(message: Message, state: FSMContext, session: AsyncSession):
+    if not message.text:
+        await message.answer(
+            text="❌ Имя кластера не может быть пустым! Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    new_cluster_name = message.text.strip()
+    if len(new_cluster_name) > 12:
+        await message.answer(
+            text="❌ Имя кластера не должно превышать 12 символов! Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    user_data = await state.get_data()
+    old_cluster_name = user_data.get("old_cluster_name")
+
+    try:
+        result = await session.execute(
+            select(Server.cluster_name).where(Server.cluster_name == new_cluster_name).limit(1)
+        )
+        existing_cluster = result.scalar()
+
+        if existing_cluster:
+            await message.answer(
+                text=f"❌ Кластер с именем '{new_cluster_name}' уже существует. Введите другое имя.",
+                reply_markup=build_admin_back_kb("clusters"),
+            )
+            return
+
+        keys_count_result = await session.execute(
+            select(func.count()).select_from(Key).where(Key.server_id == old_cluster_name)
+        )
+        keys_count = keys_count_result.scalar()
+
+        await session.execute(
+            update(Server).where(Server.cluster_name == old_cluster_name).values(cluster_name=new_cluster_name)
+        )
+
+        if keys_count > 0:
+            await session.execute(
+                update(Key).where(Key.server_id == old_cluster_name).values(server_id=new_cluster_name)
+            )
+
+        await session.commit()
+
+        await message.answer(
+            text=f"✅ Название кластера успешно изменено с '{old_cluster_name}' на '{new_cluster_name}'!",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    except Exception as e:
+        await session.rollback()
+        logger.error(f"Ошибка при смене имени кластера {old_cluster_name} на {new_cluster_name}: {e}")
+        await message.answer(
+            text=f"❌ Произошла ошибка при смене имени кластера: {e}",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    finally:
+        await state.clear()
+
+
+@router.callback_query(AdminServerCallback.filter(F.action == "rename"), IsAdminFilter())
+async def handle_rename_server(
+    callback_query: CallbackQuery,
+    callback_data: AdminServerCallback,
+    state: FSMContext,
+    session: AsyncSession,
+):
+    old_server_name = callback_data.data
+
+    servers = await get_servers(session=session)
+    cluster_name = None
+    for c_name, server_list in servers.items():
+        for server in server_list:
+            if server["server_name"] == old_server_name:
+                cluster_name = c_name
+                break
+        if cluster_name:
+            break
+
+    if not cluster_name:
+        await callback_query.message.edit_text(
+            text=f"❌ Не удалось найти кластер для сервера '{old_server_name}'.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    await state.update_data(old_server_name=old_server_name, cluster_name=cluster_name)
+
+    text = (
+        f"✏️ <b>Введите новое имя для сервера '{old_server_name}' в кластере '{cluster_name}':</b>\n\n"
+        "▸ Имя должно быть уникальным в пределах кластера.\n"
+        "▸ Имя не должно превышать 12 символов.\n\n"
+        "📌 <i>Пример:</i> <code>new_server</code>"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+    await state.set_state(AdminClusterStates.waiting_for_new_server_name)
+
+
+@router.message(AdminClusterStates.waiting_for_new_server_name, IsAdminFilter())
+async def handle_new_server_name_input(message: Message, state: FSMContext, session: AsyncSession):
+    if not message.text:
+        await message.answer(
+            text="❌ Имя сервера не может быть пустым! Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    new_server_name = message.text.strip()
+    if len(new_server_name) > 12:
+        await message.answer(
+            text="❌ Имя сервера не должно превышать 12 символов! Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    user_data = await state.get_data()
+    old_server_name = user_data.get("old_server_name")
+    cluster_name = user_data.get("cluster_name")
+
+    try:
+        result = await session.execute(
+            select(Server)
+            .where(
+                Server.cluster_name == cluster_name,
+                Server.server_name == new_server_name,
+            )
+            .limit(1)
+        )
+        existing_server = result.scalar()
+        if existing_server:
+            await message.answer(
+                text=(
+                    f"❌ Сервер с именем '{new_server_name}' уже существует в кластере '{cluster_name}'. "
+                    f"Введите другое имя."
+                ),
+                reply_markup=build_admin_back_kb("clusters"),
+            )
+            return
+
+        result = await session.execute(select(func.count()).select_from(Key).where(Key.server_id == old_server_name))
+        keys_count = result.scalar()
+
+        await session.execute(
+            update(Server)
+            .where(
+                Server.cluster_name == cluster_name,
+                Server.server_name == old_server_name,
+            )
+            .values(server_name=new_server_name)
+        )
+
+        if keys_count > 0:
+            await session.execute(update(Key).where(Key.server_id == old_server_name).values(server_id=new_server_name))
+
+        await session.commit()
+
+        await message.answer(
+            text=(
+                f"✅ Название сервера успешно изменено с '{old_server_name}' на '{new_server_name}' "
+                f"в кластере '{cluster_name}'!"
+            ),
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    except Exception as e:
+        await session.rollback()
+        logger.error(f"Ошибка при смене имени сервера {old_server_name} на {new_server_name}: {e}")
+        await message.answer(
+            text=f"❌ Произошла ошибка при смене имени сервера: {e}",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    finally:
+        await state.clear()
@@ -0,0 +1,820 @@
+import asyncio
+
+from datetime import datetime, timezone
+from typing import Any
+
+from aiogram import F, types
+from aiogram.types import CallbackQuery
+from py3xui import AsyncApi
+from sqlalchemy import delete, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config import (
+    ADMIN_PASSWORD,
+    ADMIN_USERNAME,
+    REMNAWAVE_LOGIN,
+    REMNAWAVE_PASSWORD,
+    USE_COUNTRY_SELECTION,
+)
+from core.bootstrap import MODES_CONFIG
+from database import get_servers
+from database.models import Key, Server, Tariff
+from filters.admin import IsAdminFilter
+from handlers.keys.operations import (
+    create_client_on_server,
+    create_key_on_cluster,
+    delete_key_from_cluster,
+)
+from handlers.keys.operations.aggregated_links import make_aggregated_link
+from handlers.utils import ALLOWED_GROUP_CODES
+from logger import logger
+from panels.remnawave import RemnawaveAPI
+from utils.backup import create_backup_and_send_to_admins
+
+from ..panel.keyboard import build_admin_back_kb
+from .base import router
+from .keyboard import AdminClusterCallback, build_availability_kb, build_sync_cluster_kb
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "availability"), IsAdminFilter())
+async def handle_cluster_availability(
+    callback_query: types.CallbackQuery,
+    callback_data: AdminClusterCallback,
+    session: Any,
+):
+    cluster_name = callback_data.data
+    servers = await get_servers(session)
+    cluster_servers = servers.get(cluster_name, [])
+
+    if not cluster_servers:
+        await callback_query.message.edit_text(text=f"Кластер '{cluster_name}' не содержит серверов.")
+        return
+
+    await callback_query.message.edit_text(
+        text=(
+            f"🖥️ Проверка доступности серверов для кластера {cluster_name}.\n\n"
+            "Это может занять до 1 минуты, пожалуйста, подождите..."
+        )
+    )
+
+    total_online_users = 0
+    result_text = f"<b>🖥️ Проверка доступности серверов</b>\n\n⚙️ Кластер: <b>{cluster_name}</b>\n\n"
+
+    for server in cluster_servers:
+        server_name = server["server_name"]
+        panel_type = server.get("panel_type", "3x-ui").lower()
+        prefix = "[3x]" if panel_type == "3x-ui" else "[Re]"
+
+        try:
+            if panel_type == "3x-ui":
+                xui = AsyncApi(
+                    server["api_url"],
+                    username=ADMIN_USERNAME,
+                    password=ADMIN_PASSWORD,
+                    logger=None,
+                )
+                await xui.login()
+                inbound_id = int(server["inbound_id"])
+                online_clients = await xui.client.online()
+                online_inbound_users = 0
+
+                for client_email in online_clients:
+                    client = await xui.client.get_by_email(client_email)
+                    if client and client.inbound_id == inbound_id:
+                        online_inbound_users += 1
+
+                total_online_users += online_inbound_users
+                result_text += f"🌍 <b>{prefix} {server_name}</b> - {online_inbound_users} онлайн\n"
+
+            elif panel_type == "remnawave":
+                server_inbound_id = server.get("inbound_id")
+                if not server_inbound_id:
+                    raise Exception("Не указан inbound_id сервера")
+
+                remna = RemnawaveAPI(server["api_url"])
+                nodes_data = await remna.get_all_nodes_with_online(
+                    username=REMNAWAVE_LOGIN,
+                    password=REMNAWAVE_PASSWORD,
+                    inbound_id=server_inbound_id,
+                )
+
+                if nodes_data.get("error"):
+                    raise Exception(nodes_data["error"])
+
+                online_remna_users = nodes_data["total_online"]
+                total_online_users += online_remna_users
+
+                nodes_info = nodes_data["nodes"]
+                result_text += f"🌍 <b>{prefix} {server_name}</b> - {online_remna_users} онлайн\n"
+                seen = set()
+                for node_info in nodes_info:
+                    node_name = node_info.get("name", "Unknown")
+                    if node_name in seen:
+                        continue
+                    seen.add(node_name)
+
+                    country_code = node_info.get("country_code", "Unknown")
+                    online_users = node_info.get("online_users", 0)
+
+                    flag = (
+                        "".join(chr(ord(c) + 127397) for c in country_code.upper())
+                        if country_code != "Unknown" and len(country_code) == 2
+                        else country_code
+                    )
+                    result_text += f"  ↳ {flag} ({node_name}): {online_users} онлайн\n"
+
+        except Exception as e:
+            error_text = str(e) or "Сервер недоступен"
+            result_text += f"❌ <b>{prefix} {server_name}</b> - ошибка: {error_text}\n"
+
+    result_text += f"\n👥 Всего пользователей онлайн: {total_online_users}"
+    await callback_query.message.edit_text(
+        text=result_text,
+        reply_markup=build_availability_kb(cluster_name),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "backup"), IsAdminFilter())
+async def handle_clusters_backup(
+    callback_query: types.CallbackQuery,
+    callback_data: AdminClusterCallback,
+    session: Any,
+):
+    cluster_name = callback_data.data
+
+    servers = await get_servers(session)
+    cluster_servers = servers.get(cluster_name, [])
+
+    for server in cluster_servers:
+        if server.get("panel_type") == "remnawave":
+            continue
+
+        xui = AsyncApi(
+            server["api_url"],
+            username=ADMIN_USERNAME,
+            password=ADMIN_PASSWORD,
+            logger=logger,
+        )
+        await create_backup_and_send_to_admins(xui)
+
+    text = (
+        f"<b>Бэкап для кластера {cluster_name} был успешно создан и отправлен администраторам!</b>\n\n"
+        f"🔔 <i>Бэкапы отправлены в боты панелей (3x-ui).</i>"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "sync"), IsAdminFilter())
+async def handle_sync(
+    callback_query: types.CallbackQuery,
+    callback_data: AdminClusterCallback,
+    session: Any,
+):
+    cluster_name = callback_data.data
+
+    servers = await get_servers(session)
+    cluster_servers = servers.get(cluster_name, [])
+
+    await callback_query.message.edit_text(
+        text=f"<b>🔄 Синхронизация кластера {cluster_name}</b>",
+        reply_markup=build_sync_cluster_kb(cluster_servers, cluster_name),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "sync-server"), IsAdminFilter())
+async def handle_sync_server(
+    callback_query: types.CallbackQuery,
+    callback_data: AdminClusterCallback,
+    session: AsyncSession,
+):
+    server_name = callback_data.data
+
+    try:
+        server_result = await session.execute(
+            select(Server.cluster_name).where(Server.server_name == server_name).limit(1)
+        )
+        cluster_name = server_result.scalar()
+
+        if not cluster_name:
+            await callback_query.message.edit_text(
+                text=f"❌ Сервер {server_name} не найден.",
+                reply_markup=build_admin_back_kb("clusters"),
+            )
+            return
+
+        use_country_selection = bool(MODES_CONFIG.get("COUNTRY_SELECTION_ENABLED", USE_COUNTRY_SELECTION))
+
+        if use_country_selection:
+            stmt = (
+                select(
+                    Server.api_url,
+                    Server.inbound_id,
+                    Server.server_name,
+                    Server.panel_type,
+                    Key.tg_id,
+                    Key.client_id,
+                    Key.email,
+                    Key.expiry_time,
+                    Key.tariff_id,
+                    Key.remnawave_link,
+                    Key.selected_device_limit,
+                    Key.selected_traffic_limit,
+                    Key.current_device_limit,
+                    Key.current_traffic_limit,
+                )
+                .join(Key, Server.server_name == Key.server_id)
+                .where(Server.server_name == server_name)
+            )
+        else:
+            stmt = (
+                select(
+                    Server.api_url,
+                    Server.inbound_id,
+                    Server.server_name,
+                    Server.panel_type,
+                    Key.tg_id,
+                    Key.client_id,
+                    Key.email,
+                    Key.expiry_time,
+                    Key.tariff_id,
+                    Key.remnawave_link,
+                    Key.selected_device_limit,
+                    Key.selected_traffic_limit,
+                    Key.current_device_limit,
+                    Key.current_traffic_limit,
+                )
+                .join(Key, Server.cluster_name == Key.server_id)
+                .where(Server.server_name == server_name)
+            )
+
+        result = await session.execute(stmt)
+        keys_to_sync = result.mappings().all()
+
+        if not keys_to_sync:
+            await callback_query.message.edit_text(
+                text=f"❌ Нет ключей для синхронизации в сервере {server_name}.",
+                reply_markup=build_admin_back_kb("clusters"),
+            )
+            return
+
+        await callback_query.message.edit_text(
+            text=f"<b>🔄 Синхронизация сервера {server_name}</b>\n\n🔑 Количество ключей: <b>{len(keys_to_sync)}</b>"
+        )
+
+        all_servers = await get_servers(session)
+        cluster_servers = all_servers.get(cluster_name, [])
+
+        server_info = None
+        for s in cluster_servers:
+            if s.get("server_name") == server_name:
+                server_info = s
+                break
+
+        tariff_ids = {key["tariff_id"] for key in keys_to_sync if key["tariff_id"]}
+        tariffs_cache = {}
+        if tariff_ids:
+            tariffs_result = await session.execute(select(Tariff).where(Tariff.id.in_(tariff_ids)))
+            tariffs_list = tariffs_result.scalars().all()
+            tariffs_cache = {t.id: dict(t.__dict__) for t in tariffs_list}
+
+        semaphore = asyncio.Semaphore(2)
+        for key in keys_to_sync:
+            try:
+                if key["panel_type"] == "remnawave":
+                    tariff = tariffs_cache.get(key["tariff_id"]) if key["tariff_id"] else None
+
+                    if tariff and server_info:
+                        subgroup = tariff.get("subgroup_title")
+                        tid = key["tariff_id"]
+                        has_new_binding = tid and tid in (server_info.get("tariff_ids") or [])
+                        has_old_binding = subgroup and subgroup in (server_info.get("tariff_subgroups") or [])
+                        has_any_binding = bool(server_info.get("tariff_ids") or server_info.get("tariff_subgroups"))
+
+                        if has_any_binding and subgroup and not has_new_binding and not has_old_binding:
+                            continue
+
+                        if tariff.get("group_code") and tariff.get("group_code").lower() in ALLOWED_GROUP_CODES:
+                            if tariff.get("group_code").lower() not in server_info.get("special_groups", []):
+                                continue
+
+                    expire_iso = (
+                        datetime.utcfromtimestamp(key["expiry_time"] / 1000).replace(tzinfo=timezone.utc).isoformat()
+                    )
+
+                    remna = RemnawaveAPI(key["api_url"])
+                    if not await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
+                        logger.error(f"Не удалось авторизоваться в Remnawave для сервера {server_name}")
+                        continue
+
+                    traffic_limit_bytes = 0
+                    hwid_limit = 0
+
+                    current_device_limit_from_key = key.get("current_device_limit")
+                    current_traffic_limit_gb_from_key = key.get("current_traffic_limit")
+                    selected_device_limit_from_key = key.get("selected_device_limit")
+                    selected_traffic_limit_gb_from_key = key.get("selected_traffic_limit")
+
+                    if tariff:
+                        if current_traffic_limit_gb_from_key is not None:
+                            traffic_limit_bytes = int(current_traffic_limit_gb_from_key * 1024**3)
+                        elif selected_traffic_limit_gb_from_key is not None:
+                            traffic_limit_bytes = int(selected_traffic_limit_gb_from_key * 1024**3)
+                        elif tariff.get("traffic_limit") is not None:
+                            traffic_limit_bytes = int(tariff.get("traffic_limit") * 1024**3)
+
+                        if current_device_limit_from_key is not None:
+                            hwid_limit = int(current_device_limit_from_key)
+                        elif selected_device_limit_from_key is not None:
+                            hwid_limit = int(selected_device_limit_from_key)
+                        else:
+                            hwid_limit = tariff.get("device_limit")
+
+                    success = await remna.update_user(
+                        uuid=key["client_id"],
+                        expire_at=expire_iso,
+                        telegram_id=key["tg_id"],
+                        email=f"{key['email']}@fake.local",
+                        active_user_inbounds=[key["inbound_id"]],
+                        traffic_limit_bytes=traffic_limit_bytes,
+                        hwid_device_limit=hwid_limit,
+                    )
+
+                    if success:
+                        try:
+                            sub = await remna.get_subscription_by_username(key["email"])
+                            if sub:
+                                new_remnawave_link = sub.get("subscriptionUrl")
+
+                                if new_remnawave_link:
+                                    key_value = await make_aggregated_link(
+                                        session=session,
+                                        cluster_all=cluster_servers,
+                                        cluster_id=cluster_name,
+                                        email=key["email"],
+                                        client_id=key["client_id"],
+                                        tg_id=key["tg_id"],
+                                        remna_link_override=None,
+                                        plan=tariff,
+                                    )
+
+                                    await session.execute(
+                                        update(Key)
+                                        .where(Key.tg_id == key["tg_id"], Key.client_id == key["client_id"])
+                                        .values(remnawave_link=new_remnawave_link, key=key_value)
+                                    )
+                                    await session.commit()
+                                    logger.info(f"[Sync] Обновлена ссылка для {key['email']}: {new_remnawave_link}")
+                        except Exception as e:
+                            logger.warning(f"[Sync] Не удалось получить ссылку для {key['email']}: {e}")
+
+                    if not success:
+                        logger.warning("[Sync] ошибка обновления, пробуем пересоздать")
+
+                        await delete_key_from_cluster(server_name, key["email"], key["client_id"], session)
+
+                        await create_key_on_cluster(
+                            cluster_id=server_name,
+                            tg_id=key["tg_id"],
+                            client_id=key["client_id"],
+                            email=key["email"],
+                            expiry_timestamp=key["expiry_time"],
+                            plan=key["tariff_id"],
+                            session=session,
+                            remnawave_link=key["remnawave_link"],
+                            hwid_limit=hwid_limit,
+                            traffic_limit_bytes=traffic_limit_bytes,
+                            selected_device_limit=key.get("selected_device_limit"),
+                            selected_traffic_limit_gb=key.get("selected_traffic_limit"),
+                            current_device_limit=key.get("current_device_limit"),
+                            current_traffic_limit_gb=key.get("current_traffic_limit"),
+                            selected_price_rub=key.get("selected_price_rub"),
+                        )
+                else:
+                    await create_client_on_server(
+                        {
+                            "api_url": key["api_url"],
+                            "inbound_id": key["inbound_id"],
+                            "server_name": key["server_name"],
+                        },
+                        key["tg_id"],
+                        key["client_id"],
+                        key["email"],
+                        key["expiry_time"],
+                        semaphore,
+                        plan=key["tariff_id"],
+                        session=session,
+                    )
+                    await asyncio.sleep(0.6)
+            except Exception as e:
+                logger.error(f"Ошибка при синхронизации ключа {key['client_id']} в сервер {server_name}: {e}")
+
+        await callback_query.message.edit_text(
+            text=f"✅ Ключи успешно синхронизированы для сервера {server_name}",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    except Exception as e:
+        logger.error(f"Ошибка синхронизации ключей для сервера {server_name}: {e}")
+        await callback_query.message.edit_text(
+            text=f"❌ Произошла ошибка при синхронизации: {e}",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "sync-cluster"), IsAdminFilter())
+async def handle_sync_cluster(
+    callback_query: CallbackQuery,
+    callback_data: AdminClusterCallback,
+    session: AsyncSession,
+):
+    cluster_name = callback_data.data
+
+    try:
+        servers = await get_servers(session)
+        cluster_servers = servers.get(cluster_name, [])
+
+        use_country_selection = bool(MODES_CONFIG.get("COUNTRY_SELECTION_ENABLED", USE_COUNTRY_SELECTION))
+
+        if use_country_selection:
+            server_names = [s.get("server_name") for s in cluster_servers if s.get("server_name")]
+            if not server_names:
+                await callback_query.message.edit_text(
+                    text=f"❌ В кластере {cluster_name} нет серверов.",
+                    reply_markup=build_admin_back_kb("clusters"),
+                )
+                return
+            result = await session.execute(
+                select(
+                    Key.tg_id,
+                    Key.client_id,
+                    Key.email,
+                    Key.expiry_time,
+                    Key.remnawave_link,
+                    Key.tariff_id,
+                    Key.server_id,
+                    Key.selected_device_limit,
+                    Key.selected_traffic_limit,
+                    Key.current_device_limit,
+                    Key.current_traffic_limit,
+                ).where(Key.server_id.in_(server_names), Key.is_frozen.is_(False))
+            )
+        else:
+            result = await session.execute(
+                select(
+                    Key.tg_id,
+                    Key.client_id,
+                    Key.email,
+                    Key.expiry_time,
+                    Key.remnawave_link,
+                    Key.tariff_id,
+                    Key.server_id,
+                    Key.selected_device_limit,
+                    Key.selected_traffic_limit,
+                    Key.current_device_limit,
+                    Key.current_traffic_limit,
+                ).where(Key.server_id == cluster_name, Key.is_frozen.is_(False))
+            )
+
+        keys_to_sync = result.mappings().all()
+
+        if not keys_to_sync:
+            await callback_query.message.edit_text(
+                text=f"❌ Нет ключей для синхронизации в кластере {cluster_name}.",
+                reply_markup=build_admin_back_kb("clusters"),
+            )
+            return
+        only_remnawave = all(s.get("panel_type") == "remnawave" for s in cluster_servers)
+
+        await callback_query.message.edit_text(
+            text=f"<b>🔄 Синхронизация кластера {cluster_name}</b>\n\n🔑 Количество ключей: <b>{len(keys_to_sync)}</b>"
+        )
+
+        tariff_ids = {key["tariff_id"] for key in keys_to_sync if key["tariff_id"]}
+        tariffs_cache = {}
+        if tariff_ids:
+            tariffs_result = await session.execute(select(Tariff).where(Tariff.id.in_(tariff_ids)))
+            tariffs_list = tariffs_result.scalars().all()
+            tariffs_cache = {t.id: dict(t.__dict__) for t in tariffs_list}
+
+        if only_remnawave:
+            batch_size = 50
+            total_keys = len(keys_to_sync)
+            processed_count = 0
+
+            for batch_start in range(0, total_keys, batch_size):
+                batch = keys_to_sync[batch_start : batch_start + batch_size]
+                batch_end = batch_start + len(batch)
+                logger.info(f"[Sync] Обработка батча {batch_start}-{batch_end} из {total_keys}")
+
+                async def update_remnawave_api(key):
+                    try:
+                        traffic_limit_bytes = 0
+                        hwid_limit = 0
+                        subgroup_title = None
+                        tariff = tariffs_cache.get(key["tariff_id"]) if key["tariff_id"] else None
+
+                        current_device_limit_from_key = key.get("current_device_limit")
+                        current_traffic_limit_gb_from_key = key.get("current_traffic_limit")
+                        selected_device_limit_from_key = key.get("selected_device_limit")
+                        selected_traffic_limit_gb_from_key = key.get("selected_traffic_limit")
+
+                        if tariff:
+                            if current_traffic_limit_gb_from_key is not None:
+                                traffic_limit_bytes = int(current_traffic_limit_gb_from_key * 1024**3)
+                            elif selected_traffic_limit_gb_from_key is not None:
+                                traffic_limit_bytes = int(selected_traffic_limit_gb_from_key * 1024**3)
+                            elif tariff.get("traffic_limit") is not None:
+                                traffic_limit_bytes = int(tariff.get("traffic_limit") * 1024**3)
+                            else:
+                                traffic_limit_bytes = 0
+
+                            if current_device_limit_from_key is not None:
+                                hwid_limit = int(current_device_limit_from_key)
+                            elif selected_device_limit_from_key is not None:
+                                hwid_limit = int(selected_device_limit_from_key)
+                            else:
+                                hwid_limit = tariff.get("device_limit")
+
+                            subgroup_title = tariff.get("subgroup_title")
+
+                        expire_iso = (
+                            datetime.utcfromtimestamp(key["expiry_time"] / 1000)
+                            .replace(tzinfo=timezone.utc)
+                            .isoformat()
+                        )
+
+                        if use_country_selection:
+                            user_server = None
+                            for s in cluster_servers:
+                                if s.get("server_name") == key["server_id"]:
+                                    user_server = s
+                                    break
+
+                            if not user_server:
+                                return {"key": key, "success": False, "error": "Server not found"}
+
+                            remna = RemnawaveAPI(user_server["api_url"])
+                            inbound_ids = [user_server["inbound_id"]] if user_server.get("inbound_id") else []
+                        else:
+                            remna = RemnawaveAPI(cluster_servers[0]["api_url"])
+
+                            filtered_servers = cluster_servers
+                            if subgroup_title or (tariff and tariff.get("id")):
+                                tid = tariff.get("id") if tariff else None
+                                filtered_servers = [
+                                    s
+                                    for s in cluster_servers
+                                    if (tid and tid in (s.get("tariff_ids") or []))
+                                    or (subgroup_title and subgroup_title in (s.get("tariff_subgroups") or []))
+                                ]
+                                if not filtered_servers:
+                                    filtered_servers = cluster_servers
+
+                            if tariff and tariff.get("group_code"):
+                                group_code = tariff.get("group_code").lower()
+                                if group_code in ALLOWED_GROUP_CODES:
+                                    special_filtered = [
+                                        s for s in filtered_servers if group_code in (s.get("special_groups") or [])
+                                    ]
+                                    if special_filtered:
+                                        filtered_servers = special_filtered
+
+                            inbound_ids = [s["inbound_id"] for s in filtered_servers if s.get("inbound_id")]
+
+                        if not await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
+                            return {"key": key, "success": False, "error": "Login failed"}
+
+                        success = await remna.update_user(
+                            uuid=key["client_id"],
+                            expire_at=expire_iso,
+                            telegram_id=key["tg_id"],
+                            email=f"{key['email']}@fake.local",
+                            active_user_inbounds=inbound_ids,
+                            traffic_limit_bytes=traffic_limit_bytes,
+                            hwid_device_limit=hwid_limit,
+                        )
+
+                        if success:
+                            sub = await remna.get_subscription_by_username(key["email"])
+                            new_link = sub.get("subscriptionUrl") if sub else None
+                            return {
+                                "key": key,
+                                "success": True,
+                                "new_link": new_link,
+                                "tariff": tariff,
+                                "traffic_limit_bytes": traffic_limit_bytes,
+                                "hwid_limit": hwid_limit,
+                            }
+                        else:
+                            return {
+                                "key": key,
+                                "success": False,
+                                "needs_recreate": True,
+                                "tariff": tariff,
+                                "traffic_limit_bytes": traffic_limit_bytes,
+                                "hwid_limit": hwid_limit,
+                            }
+
+                    except Exception as e:
+                        logger.error(f"[Sync] Ошибка API для {key.get('email')}: {e}")
+                        return {"key": key, "success": False, "error": str(e)}
+
+                tasks = [update_remnawave_api(key) for key in batch]
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+
+                bulk_updates = []
+                recreate_tasks = []
+
+                for result in results:
+                    if isinstance(result, Exception):
+                        logger.error(f"[Sync] Exception в батче: {result}")
+                        continue
+
+                    if not isinstance(result, dict):
+                        continue
+
+                    key = result.get("key")
+                    if not key:
+                        continue
+
+                    try:
+                        if result.get("success") and result.get("new_link"):
+                            new_link = result["new_link"]
+                            tariff = result.get("tariff")
+
+                            key_value = await make_aggregated_link(
+                                session=session,
+                                cluster_all=cluster_servers,
+                                cluster_id=cluster_name,
+                                email=key["email"],
+                                client_id=key["client_id"],
+                                tg_id=key["tg_id"],
+                                remna_link_override=None,
+                                plan=tariff,
+                            )
+
+                            bulk_updates.append({
+                                "client_id": key["client_id"],
+                                "remnawave_link": new_link,
+                                "key": key_value,
+                            })
+
+                        elif result.get("needs_recreate"):
+                            recreate_tasks.append((key, result))
+
+                    except Exception as e:
+                        logger.error(f"[Sync] Ошибка подготовки для {key.get('email')}: {e}")
+
+                if bulk_updates:
+                    try:
+                        await session.run_sync(
+                            lambda sync_session: sync_session.bulk_update_mappings(Key, bulk_updates)
+                        )
+                        await session.commit()
+                        logger.info(f"[Sync] Bulk: обновлено {len(bulk_updates)} ключей")
+                    except Exception as bulk_error:
+                        logger.warning(f"[Sync] Bulk упал, fallback: {bulk_error}")
+                        await session.rollback()
+
+                        for upd in bulk_updates:
+                            try:
+                                await session.execute(
+                                    update(Key)
+                                    .where(Key.client_id == upd["client_id"])
+                                    .values(remnawave_link=upd["remnawave_link"], key=upd["key"])
+                                )
+                                await session.commit()
+                            except Exception as e:
+                                logger.error(f"[Sync] Fallback ошибка {upd['client_id']}: {e}")
+                                await session.rollback()
+
+                for key, result in recreate_tasks:
+                    try:
+                        logger.warning(f"[Sync] Пересоздание {key['email']}")
+                        await delete_key_from_cluster(cluster_name, key["email"], key["client_id"], session)
+                        await session.execute(
+                            delete(Key).where(Key.tg_id == key["tg_id"], Key.client_id == key["client_id"])
+                        )
+                        await session.commit()
+
+                        cluster_id_for_recreate = key["server_id"] if use_country_selection else cluster_name
+                        await create_key_on_cluster(
+                            cluster_id_for_recreate,
+                            key["tg_id"],
+                            key["client_id"],
+                            key["email"],
+                            key["expiry_time"],
+                            plan=key["tariff_id"],
+                            session=session,
+                            remnawave_link=key["remnawave_link"],
+                            hwid_limit=result.get("hwid_limit"),
+                            traffic_limit_bytes=result.get("traffic_limit_bytes"),
+                            selected_device_limit=key.get("selected_device_limit"),
+                            selected_traffic_limit_gb=key.get("selected_traffic_limit"),
+                            current_device_limit=key.get("current_device_limit"),
+                            current_traffic_limit_gb=key.get("current_traffic_limit"),
+                            selected_price_rub=key.get("selected_price_rub"),
+                        )
+                    except Exception as e:
+                        logger.error(f"[Sync] Пересоздание ошибка {key.get('email')}: {e}")
+
+                processed_count = batch_end
+                progress_percent = int((processed_count / total_keys) * 100)
+                progress_bar = "█" * (progress_percent // 5) + "░" * (20 - progress_percent // 5)
+
+                try:
+                    await callback_query.message.edit_text(
+                        text=(
+                            f"<b>🔄 Синхронизация кластера {cluster_name}</b>\n\n"
+                            f"🔑 Количество ключей: <b>{total_keys}</b>\n\n"
+                            f"Обработано: <b>{processed_count}/{total_keys}</b>\n"
+                            f"<code>{progress_bar}</code>"
+                        )
+                    )
+                except Exception:
+                    pass
+
+        else:
+            for key in keys_to_sync:
+                try:
+                    traffic_limit_bytes = 0
+                    hwid_limit = 0
+                    tariff = tariffs_cache.get(key["tariff_id"]) if key["tariff_id"] else None
+
+                    current_device_limit_from_key = key.get("current_device_limit")
+                    current_traffic_limit_gb_from_key = key.get("current_traffic_limit")
+                    selected_device_limit_from_key = key.get("selected_device_limit")
+                    selected_traffic_limit_gb_from_key = key.get("selected_traffic_limit")
+
+                    if tariff:
+                        if current_traffic_limit_gb_from_key is not None:
+                            traffic_limit_bytes = int(current_traffic_limit_gb_from_key * 1024**3)
+                        elif selected_traffic_limit_gb_from_key is not None:
+                            traffic_limit_bytes = int(selected_traffic_limit_gb_from_key * 1024**3)
+                        elif tariff.get("traffic_limit") is not None:
+                            traffic_limit_bytes = int(tariff.get("traffic_limit") * 1024**3)
+                        else:
+                            traffic_limit_bytes = 0
+
+                        if current_device_limit_from_key is not None:
+                            hwid_limit = int(current_device_limit_from_key)
+                        elif selected_device_limit_from_key is not None:
+                            hwid_limit = int(selected_device_limit_from_key)
+                        else:
+                            hwid_limit = tariff.get("device_limit")
+
+                        tariff.get("subgroup_title")
+                    elif key["tariff_id"]:
+                        logger.warning(
+                            f"[Sync] Ключ {key['client_id']} с несуществующим тарифом ID={key['tariff_id']} — "
+                            f"обновим без лимитов"
+                        )
+
+                    await delete_key_from_cluster(cluster_name, key["email"], key["client_id"], session)
+
+                    await session.execute(
+                        delete(Key).where(Key.tg_id == key["tg_id"], Key.client_id == key["client_id"])
+                    )
+
+                    cluster_id_for_recreate = key["server_id"] if use_country_selection else cluster_name
+                    await create_key_on_cluster(
+                        cluster_id_for_recreate,
+                        key["tg_id"],
+                        key["client_id"],
+                        key["email"],
+                        key["expiry_time"],
+                        plan=key["tariff_id"],
+                        session=session,
+                        remnawave_link=key["remnawave_link"],
+                        hwid_limit=hwid_limit,
+                        traffic_limit_bytes=traffic_limit_bytes,
+                        selected_device_limit=key.get("selected_device_limit"),
+                        selected_traffic_limit_gb=key.get("selected_traffic_limit"),
+                        current_device_limit=key.get("current_device_limit"),
+                        current_traffic_limit_gb=key.get("current_traffic_limit"),
+                        selected_price_rub=key.get("selected_price_rub"),
+                    )
+
+                    await asyncio.sleep(0.5)
+
+                except Exception as e:
+                    logger.error(f"[Sync] Ошибка при обработке ключа {key['client_id']} в {cluster_name}: {e}")
+
+        await callback_query.message.edit_text(
+            text=(
+                f"✅ <b>Синхронизация завершена</b>\n\n"
+                f"📊 Кластер: <b>{cluster_name}</b>\n"
+                f"🔑 Обработано ключей: <b>{len(keys_to_sync)}</b>"
+            ),
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+
+    except Exception as e:
+        logger.error(f"[Sync] Ошибка синхронизации кластера {cluster_name}: {e}")
+        await callback_query.message.edit_text(
+            text=f"❌ Произошла ошибка при синхронизации: {e}",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
@@ -0,0 +1,628 @@
+from aiogram import F
+from aiogram.fsm.context import FSMContext
+from aiogram.types import CallbackQuery
+from sqlalchemy import and_, delete, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database import get_servers
+from database.models import Server, ServerSpecialgroup, ServerSubgroup, Tariff
+from database.servers import has_legacy_subgroup_bindings
+from filters.admin import IsAdminFilter
+from handlers.utils import ALLOWED_GROUP_CODES
+from logger import logger
+
+from .base import router
+from .keyboard import (
+    AdminClusterCallback,
+    build_attach_tariff_kb,
+    build_legacy_reset_kb,
+    build_manage_cluster_kb,
+    build_select_group_servers_kb,
+    build_select_subgroup_servers_kb,
+    build_tariff_group_selection_for_servers_kb,
+    build_tariff_group_selection_kb,
+    build_tariff_selection_kb,
+)
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "set_tariff"), IsAdminFilter())
+async def show_tariff_group_selection(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession
+):
+    cluster_name = callback_data.data
+    result = await session.execute(
+        select(Tariff.id, Tariff.group_code).where(Tariff.group_code.isnot(None)).distinct(Tariff.group_code)
+    )
+    rows = result.mappings().all()
+    groups = [(r["id"], r["group_code"]) for r in rows]
+
+    if not groups:
+        await callback.message.edit_text("❌ Нет доступных тарифных групп.")
+        return
+
+    await callback.message.edit_text(
+        f"<b>💸 Выберите тарифную группу для кластера <code>{cluster_name}</code>:</b>",
+        reply_markup=build_tariff_group_selection_kb(cluster_name, groups),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "apply_tariff_group"), IsAdminFilter())
+async def apply_tariff_group(callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession):
+    try:
+        cluster_name, group_id = callback_data.data.split("|", 1)
+        group_id = int(group_id)
+
+        result = await session.execute(select(Tariff.group_code).where(Tariff.id == group_id))
+        row = result.mappings().first()
+
+        if not row:
+            await callback.message.edit_text("❌ Тарифная группа не найдена.")
+            return
+
+        group_code = row["group_code"]
+
+        await session.execute(update(Server).where(Server.cluster_name == cluster_name).values(tariff_group=group_code))
+        await session.commit()
+
+        servers = await get_servers(session=session, include_enabled=True)
+        cluster_servers = servers.get(cluster_name, [])
+
+        await callback.message.edit_text(
+            f"✅ Для кластера <code>{cluster_name}</code> установлена тарифная группа: <b>{group_code}</b>",
+            reply_markup=build_manage_cluster_kb(cluster_servers, cluster_name),
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка при применении тарифной группы: {e}")
+        await callback.message.edit_text("❌ Произошла ошибка при установке тарифной группы.")
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "set_subgroup"), IsAdminFilter())
+async def show_servers_for_tariffs(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name = callback_data.data
+    servers = await get_servers(session=session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+
+    server_ids = [s.get("server_id") for s in cluster_servers if s.get("server_id")]
+    if server_ids and await has_legacy_subgroup_bindings(session, server_ids):
+        await callback.message.edit_text(
+            f"<b>⚠️ Обнаружены привязки старого формата</b>\n\n"
+            f"Кластер <code>{cluster_name}</code> содержит привязки по названиям подгрупп.\n"
+            f"Для использования новой системы необходимо сбросить текущие привязки.\n\n"
+            f"<i>После сброса вы сможете привязать тарифы по ID.</i>",
+            reply_markup=build_legacy_reset_kb(cluster_name),
+        )
+        return
+
+    data = await state.get_data()
+    selected = set(data.get(f"subgrp_sel:{cluster_name}", []))
+    await callback.message.edit_text(
+        f"<b>📋 Выберите серверы для привязки тарифов</b>\n<i>Кластер: {cluster_name}</i>",
+        reply_markup=build_select_subgroup_servers_kb(cluster_name, cluster_servers, selected),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "toggle_server_subgroup"), IsAdminFilter())
+async def toggle_server_for_tariffs(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name, idx_str = callback_data.data.split("|", 1)
+    i = int(idx_str)
+    servers = await get_servers(session=session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+    names = []
+    for s in cluster_servers:
+        if isinstance(s, str):
+            names.append(s)
+        elif isinstance(s, dict):
+            names.append(s.get("server_name") or s.get("name") or str(s))
+        else:
+            names.append(getattr(s, "server_name", None) or getattr(s, "name", None) or str(s))
+    if i < 0 or i >= len(names):
+        await callback.answer("Сервер не найден", show_alert=True)
+        return
+    server_name = names[i]
+    key = f"subgrp_sel:{cluster_name}"
+    data = await state.get_data()
+    selected = set(data.get(key, []))
+    if server_name in selected:
+        selected.remove(server_name)
+    else:
+        selected.add(server_name)
+    await state.update_data({key: list(selected)})
+    await callback.message.edit_text(
+        f"<b>📋 Выберите серверы для привязки тарифов</b>\n<i>Кластер: {cluster_name}</i>",
+        reply_markup=build_select_subgroup_servers_kb(cluster_name, cluster_servers, selected),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "reset_subgroup_selection"), IsAdminFilter())
+async def reset_tariff_selection(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name = callback_data.data
+    servers = await get_servers(session=session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+    await state.update_data({
+        f"subgrp_sel:{cluster_name}": [],
+        f"tariff_sel:{cluster_name}": [],
+    })
+    await callback.message.edit_text(
+        f"<b>📋 Выберите серверы для привязки тарифов</b>\n<i>Кластер: {cluster_name}</i>",
+        reply_markup=build_select_subgroup_servers_kb(cluster_name, cluster_servers, set()),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "choose_subgroup"), IsAdminFilter())
+async def choose_tariffs(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name = callback_data.data
+    key = f"subgrp_sel:{cluster_name}"
+    data = await state.get_data()
+    selected_servers = set(data.get(key, []))
+    if not selected_servers:
+        await callback.answer("Сначала выберите хотя бы один сервер", show_alert=True)
+        return
+
+    res = await session.execute(select(Server.tariff_group).where(Server.cluster_name == cluster_name).distinct())
+    group_codes = [r[0] for r in res.fetchall() if r[0]]
+    if not group_codes:
+        await callback.answer("Сначала установите тарифную группу для этого кластера", show_alert=True)
+        return
+
+    group_code = group_codes[0]
+
+    result = await session.execute(
+        select(Tariff)
+        .where(Tariff.group_code == group_code, Tariff.is_active.is_(True))
+        .order_by(Tariff.subgroup_title.nulls_last(), Tariff.sort_order, Tariff.id)
+    )
+    tariffs = result.scalars().all()
+
+    if not tariffs:
+        await callback.message.edit_text("❌ Для этой группы нет доступных тарифов.")
+        return
+
+    servers_q = await session.execute(select(Server.id).where(Server.server_name.in_(selected_servers)))
+    server_ids = [row[0] for row in servers_q.fetchall()]
+
+    current_bindings_q = await session.execute(
+        select(ServerSubgroup.subgroup_title)
+        .where(ServerSubgroup.server_id.in_(server_ids))
+        .where(ServerSubgroup.subgroup_title.regexp_match(r"^\d+$"))
+    )
+    current_tariff_ids = {int(row[0]) for row in current_bindings_q.fetchall()}
+
+    await state.update_data({f"tariff_sel:{cluster_name}": list(current_tariff_ids)})
+
+    await callback.message.edit_text(
+        f"<b>📋 Выберите тарифы для {len(selected_servers)} сервер(а/ов)</b>\n<i>Кластер: {cluster_name}</i>",
+        reply_markup=build_tariff_selection_kb(cluster_name, tariffs, current_tariff_ids),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "toggle_tariff"), IsAdminFilter())
+async def toggle_tariff_selection(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name, tariff_id_str = callback_data.data.split("|", 1)
+    tariff_id = int(tariff_id_str)
+
+    key = f"tariff_sel:{cluster_name}"
+    data = await state.get_data()
+    selected_tariffs = set(data.get(key, []))
+
+    if tariff_id in selected_tariffs:
+        selected_tariffs.remove(tariff_id)
+    else:
+        selected_tariffs.add(tariff_id)
+
+    await state.update_data({key: list(selected_tariffs)})
+
+    res = await session.execute(select(Server.tariff_group).where(Server.cluster_name == cluster_name).distinct())
+    group_codes = [r[0] for r in res.fetchall() if r[0]]
+    if not group_codes:
+        return
+
+    result = await session.execute(
+        select(Tariff)
+        .where(Tariff.group_code == group_codes[0], Tariff.is_active.is_(True))
+        .order_by(Tariff.subgroup_title.nulls_last(), Tariff.sort_order, Tariff.id)
+    )
+    tariffs = result.scalars().all()
+
+    selected_servers = set(data.get(f"subgrp_sel:{cluster_name}", []))
+
+    await callback.message.edit_text(
+        f"<b>📋 Выберите тарифы для {len(selected_servers)} сервер(а/ов)</b>\n<i>Кластер: {cluster_name}</i>",
+        reply_markup=build_tariff_selection_kb(cluster_name, tariffs, selected_tariffs),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "apply_tariffs"), IsAdminFilter())
+async def apply_tariffs(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    try:
+        cluster_name = callback_data.data
+        data = await state.get_data()
+
+        selected_servers = set(data.get(f"subgrp_sel:{cluster_name}", []))
+        selected_tariffs = set(data.get(f"tariff_sel:{cluster_name}", []))
+
+        if not selected_servers:
+            await callback.answer("Не выбраны серверы", show_alert=True)
+            return
+
+        servers_q = await session.execute(
+            select(Server.id, Server.server_name, Server.tariff_group).where(Server.server_name.in_(selected_servers))
+        )
+        servers_data = servers_q.fetchall()
+        server_ids = [row[0] for row in servers_data]
+        group_code = servers_data[0][2] if servers_data else "standard"
+
+        if not server_ids:
+            await callback.answer("Серверы не найдены", show_alert=True)
+            return
+
+        selected_tariff_strs = {str(tid) for tid in selected_tariffs}
+
+        await session.execute(
+            delete(ServerSubgroup)
+            .where(ServerSubgroup.server_id.in_(server_ids))
+            .where(ServerSubgroup.subgroup_title.regexp_match(r"^\d+$"))
+            .where(ServerSubgroup.subgroup_title.notin_(selected_tariff_strs))
+        )
+
+        for tariff_id in selected_tariffs:
+            tariff_id_str = str(tariff_id)
+
+            existing_q = await session.execute(
+                select(ServerSubgroup.server_id)
+                .where(ServerSubgroup.server_id.in_(server_ids))
+                .where(ServerSubgroup.subgroup_title == tariff_id_str)
+            )
+            already = {r[0] for r in existing_q.fetchall()}
+            to_insert = [sid for sid in server_ids if sid not in already]
+
+            if to_insert:
+                session.add_all([
+                    ServerSubgroup(server_id=sid, group_code=group_code, subgroup_title=tariff_id_str)
+                    for sid in to_insert
+                ])
+
+        await session.commit()
+
+        await state.update_data({
+            f"subgrp_sel:{cluster_name}": [],
+            f"tariff_sel:{cluster_name}": [],
+        })
+
+        servers = await get_servers(session, include_enabled=True)
+        cluster_servers = servers.get(cluster_name, [])
+
+        all_tariff_ids = set()
+        for s in cluster_servers:
+            all_tariff_ids.update(s.get("tariff_ids") or [])
+
+        tariffs_cache = {}
+        if all_tariff_ids:
+            result = await session.execute(select(Tariff).where(Tariff.id.in_(all_tariff_ids)))
+            for t in result.scalars().all():
+                tariffs_cache[t.id] = {
+                    "id": t.id,
+                    "name": t.name,
+                    "subgroup_title": t.subgroup_title,
+                    "group_code": t.group_code,
+                }
+
+        text = render_attach_tariff_menu_text(cluster_name, cluster_servers, tariffs_cache)
+        await callback.message.edit_text(
+            text=text,
+            reply_markup=build_attach_tariff_kb(cluster_name),
+            disable_web_page_preview=True,
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка при применении тарифов: {e}")
+        await callback.message.edit_text("❌ Произошла ошибка при назначении тарифов.")
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "reset_cluster_subgroups"), IsAdminFilter())
+async def reset_cluster_subgroups(callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession):
+    try:
+        cluster_name = callback_data.data
+
+        res = await session.execute(select(Server.id).where(Server.cluster_name == cluster_name))
+        server_ids = [row[0] for row in res.fetchall()]
+        if not server_ids:
+            await callback.answer("В кластере нет серверов", show_alert=True)
+            return
+
+        await session.execute(delete(ServerSubgroup).where(ServerSubgroup.server_id.in_(server_ids)))
+        await session.commit()
+
+        servers = await get_servers(session=session, include_enabled=True)
+        cluster_servers = servers.get(cluster_name, [])
+
+        await callback.message.edit_text(
+            f"✅ Все подгруппы тарифов сброшены для кластера <b>{cluster_name}</b>.",
+            reply_markup=build_manage_cluster_kb(cluster_servers, cluster_name),
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при сбросе подгрупп для кластера {cluster_name}: {e}")
+        await callback.message.edit_text("❌ Не удалось сбросить подгруппы.")
+
+
+def render_attach_tariff_menu_text(
+    cluster_name: str, cluster_servers: list[dict], tariffs_cache: dict[int, dict] | None = None
+) -> str:
+    tariff_map: dict[int, list[str]] = {}
+    legacy_map: dict[str, list[str]] = {}
+
+    for s in cluster_servers:
+        server_name = s["server_name"]
+
+        for tid in s.get("tariff_ids") or []:
+            tariff_map.setdefault(tid, []).append(server_name)
+
+        for sg in s.get("tariff_subgroups") or []:
+            legacy_map.setdefault(sg, []).append(server_name)
+
+    allowed = tuple(ALLOWED_GROUP_CODES)
+    spec_map: dict[str, list[str]] = {k: [] for k in allowed}
+    for s in cluster_servers:
+        for g in s.get("special_groups") or []:
+            if g in spec_map:
+                spec_map[g].append(s["server_name"])
+
+    lines = [f"<b>🧩 Привязки тарифов • {cluster_name}</b>"]
+
+    lines.append("\n<b>📋 Тарифы:</b>")
+    if tariff_map and tariffs_cache:
+        grouped: dict[str | None, list[tuple[int, str, list[str]]]] = {}
+        for tid, servers in tariff_map.items():
+            tariff = tariffs_cache.get(tid, {})
+            subgroup = tariff.get("subgroup_title")
+            name = tariff.get("name", f"ID:{tid}")
+            grouped.setdefault(subgroup, []).append((tid, name, servers))
+
+        tariff_lines = []
+        subgroups_sorted = sorted(grouped.keys(), key=lambda x: (x is None, x or ""))
+
+        for subgroup in subgroups_sorted:
+            tariffs_list = grouped[subgroup]
+            if subgroup:
+                tariff_lines.append(f"<b>{subgroup}</b>")
+                for tid, name, servers in sorted(tariffs_list, key=lambda x: x[1]):
+                    servers_str = ", ".join(sorted(set(servers)))
+                    tariff_lines.append(f"  └ {name}: {servers_str}")
+            else:
+                for tid, name, servers in sorted(tariffs_list, key=lambda x: x[1]):
+                    servers_str = ", ".join(sorted(set(servers)))
+                    tariff_lines.append(f"• {name}: {servers_str}")
+
+        lines.append("<blockquote>" + "\n".join(tariff_lines) + "</blockquote>")
+    elif tariff_map:
+        tariff_lines = []
+        for tid, servers in sorted(tariff_map.items()):
+            servers_str = ", ".join(sorted(set(servers)))
+            tariff_lines.append(f"• ID:{tid}: {servers_str}")
+        lines.append("<blockquote>" + "\n".join(tariff_lines) + "</blockquote>")
+    else:
+        lines.append("<blockquote>— нет привязок</blockquote>")
+
+    if legacy_map:
+        lines.append("\n<b>⚠️ Старые привязки (по названию):</b>")
+        legacy_lines = []
+        for k in sorted(legacy_map):
+            servers_list = ", ".join(sorted(set(legacy_map[k])))
+            legacy_lines.append(f"• <b>{k}</b>: {servers_list}")
+        lines.append("<blockquote>" + "\n".join(legacy_lines) + "</blockquote>")
+        lines.append("<i>Рекомендуется сбросить и настроить заново</i>")
+
+    lines.append("\n<b>🎁 Спецгруппы:</b>")
+    has_spec = any(spec_map[k] for k in allowed)
+    if has_spec:
+        spec_lines = []
+        for k in allowed:
+            vals = sorted(set(spec_map[k]))
+            spec_lines.append(f"• <b>{k}</b>: {', '.join(vals) if vals else '—'}")
+        lines.append("<blockquote>" + "\n".join(spec_lines) + "</blockquote>")
+    else:
+        lines.append("<blockquote>— нет привязок</blockquote>")
+
+    return "\n".join(lines)
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "attach_tariff_menu"), IsAdminFilter())
+async def handle_attach_tariff_menu(callback: CallbackQuery, session: AsyncSession):
+    packed = AdminClusterCallback.unpack(callback.data)
+    cluster_name = packed.data
+
+    servers = await get_servers(session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+
+    all_tariff_ids = set()
+    for s in cluster_servers:
+        all_tariff_ids.update(s.get("tariff_ids") or [])
+
+    tariffs_cache = {}
+    if all_tariff_ids:
+        result = await session.execute(select(Tariff).where(Tariff.id.in_(all_tariff_ids)))
+        for t in result.scalars().all():
+            tariffs_cache[t.id] = {
+                "id": t.id,
+                "name": t.name,
+                "subgroup_title": t.subgroup_title,
+                "group_code": t.group_code,
+            }
+
+    text = render_attach_tariff_menu_text(cluster_name, cluster_servers, tariffs_cache)
+    await callback.message.edit_text(
+        text=text,
+        reply_markup=build_attach_tariff_kb(cluster_name),
+        disable_web_page_preview=True,
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "set_group"), IsAdminFilter())
+async def show_servers_for_group(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name = callback_data.data
+    servers = await get_servers(session=session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+    data = await state.get_data()
+    selected = set(data.get(f"grp_sel:{cluster_name}", []))
+    await callback.message.edit_text(
+        f"<b>🗂 Выберите серверы в кластере <code>{cluster_name}</code> для назначения тарифной группы:</b>",
+        reply_markup=build_select_group_servers_kb(cluster_name, cluster_servers, selected),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "toggle_server_group"), IsAdminFilter())
+async def toggle_server_for_group(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name, idx_str = callback_data.data.split("|", 1)
+    i = int(idx_str)
+    servers = await get_servers(session=session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+    names = []
+    for s in cluster_servers:
+        if isinstance(s, str):
+            names.append(s)
+        elif isinstance(s, dict):
+            names.append(s.get("server_name") or s.get("name") or str(s))
+        else:
+            names.append(getattr(s, "server_name", None) or getattr(s, "name", None) or str(s))
+    if i < 0 or i >= len(names):
+        await callback.answer("Сервер не найден", show_alert=True)
+        return
+    server_name = names[i]
+    key = f"grp_sel:{cluster_name}"
+    data = await state.get_data()
+    selected = set(data.get(key, []))
+    if server_name in selected:
+        selected.remove(server_name)
+    else:
+        selected.add(server_name)
+    await state.update_data({key: list(selected)})
+    await callback.message.edit_text(
+        f"<b>🗂 Выберите серверы в кластере <code>{cluster_name}</code> для назначения тарифной группы:</b>",
+        reply_markup=build_select_group_servers_kb(cluster_name, cluster_servers, selected),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "reset_group_selection"), IsAdminFilter())
+async def reset_group_selection(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name = callback_data.data
+    servers = await get_servers(session=session, include_enabled=True)
+    cluster_servers = servers.get(cluster_name, [])
+    await state.update_data({f"grp_sel:{cluster_name}": []})
+    await callback.message.edit_text(
+        f"<b>🗂 Выберите серверы в кластере <code>{cluster_name}</code> для назначения тарифной группы:</b>",
+        reply_markup=build_select_group_servers_kb(cluster_name, cluster_servers, set()),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "choose_group"), IsAdminFilter())
+async def choose_group(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    cluster_name = callback_data.data
+    key = f"grp_sel:{cluster_name}"
+    data = await state.get_data()
+    selected = set(data.get(key, []))
+    if not selected:
+        await callback.answer("Сначала выберите хотя бы один сервер", show_alert=True)
+        return
+    groups = [(i, code) for i, code in enumerate(ALLOWED_GROUP_CODES)]
+    await callback.message.edit_text(
+        f"<b>📚 Выберите группу для {len(selected)} сервер(а/ов) кластера <code>{cluster_name}</code>:</b>",
+        reply_markup=build_tariff_group_selection_for_servers_kb(cluster_name, groups),
+    )
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "apply_group_to_servers"), IsAdminFilter())
+async def apply_group_to_servers(
+    callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession, state: FSMContext
+):
+    try:
+        cluster_name, idx_str = callback_data.data.split("|", 1)
+        i = int(idx_str)
+        groups = ALLOWED_GROUP_CODES
+        if i < 0 or i >= len(groups):
+            await callback.answer("Группа не найдена", show_alert=True)
+            return
+        group_code = groups[i]
+
+        key = f"grp_sel:{cluster_name}"
+        data = await state.get_data()
+        selected = set(data.get(key, []))
+        if not selected:
+            await callback.message.edit_text("❌ Не выбраны серверы для назначения группы.")
+            return
+
+        rows = await session.execute(select(Server.id, Server.server_name).where(Server.server_name.in_(selected)))
+        id_by_name = {name: sid for sid, name in rows.fetchall()}
+        server_ids = [id_by_name[n] for n in selected if n in id_by_name]
+        if not server_ids:
+            await callback.answer("Серверы не найдены", show_alert=True)
+            return
+
+        exist_rows = await session.execute(
+            select(ServerSpecialgroup.server_id).where(
+                and_(ServerSpecialgroup.server_id.in_(server_ids), ServerSpecialgroup.group_code == group_code)
+            )
+        )
+        already = {r[0] for r in exist_rows.fetchall()}
+        to_insert = [sid for sid in server_ids if sid not in already]
+
+        if to_insert:
+            session.add_all([ServerSpecialgroup(server_id=sid, group_code=group_code) for sid in to_insert])
+            await session.commit()
+
+        logger.debug(f"[apply_group_to_servers] group={group_code} server_ids={server_ids}")
+
+        await state.update_data({key: []})
+
+        servers = await get_servers(session, include_enabled=True)
+        cluster_servers = servers.get(cluster_name, [])
+        text = render_attach_tariff_menu_text(cluster_name, cluster_servers)
+        await callback.message.edit_text(
+            text=text,
+            reply_markup=build_attach_tariff_kb(cluster_name),
+            disable_web_page_preview=True,
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при назначении группы тарифов: {e}")
+        await callback.message.edit_text("❌ Произошла ошибка при назначении группы.")
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "reset_cluster_groups"), IsAdminFilter())
+async def reset_cluster_groups(callback: CallbackQuery, callback_data: AdminClusterCallback, session: AsyncSession):
+    try:
+        cluster_name = callback_data.data
+        res = await session.execute(select(Server.id).where(Server.cluster_name == cluster_name))
+        server_ids = [row[0] for row in res.fetchall()]
+        if not server_ids:
+            await callback.answer("В кластере нет серверов", show_alert=True)
+            return
+        await session.execute(delete(ServerSpecialgroup).where(ServerSpecialgroup.server_id.in_(server_ids)))
+        await session.commit()
+        servers = await get_servers(session=session, include_enabled=True)
+        cluster_servers = servers.get(cluster_name, [])
+        await callback.message.edit_text(
+            f"✅ Все привязки групп сброшены для кластера <b>{cluster_name}</b>.",
+            reply_markup=build_manage_cluster_kb(cluster_servers, cluster_name),
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при сбросе групп для кластера {cluster_name}: {e}")
+        await callback.message.edit_text("❌ Не удалось сбросить привязки групп.")
@@ -0,0 +1,98 @@
+from aiogram import F
+from aiogram.fsm.context import FSMContext
+from aiogram.types import CallbackQuery
+from sqlalchemy import delete, update
+from sqlalchemy.ext.asyncio import AsyncSession
+from filters.admin import IsAdminFilter
+
+from config import USE_COUNTRY_SELECTION
+from core.bootstrap import MODES_CONFIG
+from database.models import Key, Server
+from logger import logger
+
+from ..panel.keyboard import build_admin_back_kb
+from .base import router
+
+
+@router.callback_query(F.data.startswith("transfer_to_server|"), IsAdminFilter())
+async def handle_server_transfer(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    try:
+        data = callback_query.data.split("|")
+        new_server_name = data[1]
+        old_server_name = data[2]
+
+        user_data = await state.get_data()
+        cluster_name = user_data.get("cluster_name")
+
+        await session.execute(update(Key).where(Key.server_id == old_server_name).values(server_id=new_server_name))
+
+        await session.execute(
+            delete(Server).where(
+                Server.cluster_name == cluster_name,
+                Server.server_name == old_server_name,
+            )
+        )
+
+        await session.commit()
+
+        use_country_selection = bool(MODES_CONFIG.get("COUNTRY_SELECTION_ENABLED", USE_COUNTRY_SELECTION))
+
+        base_text = f"✅ Ключи успешно перенесены на сервер '{new_server_name}', сервер '{old_server_name}' удален!"
+        sync_reminder = '\n\n⚠️ Не забудьте сделать "Синхронизацию".'
+        final_text = base_text + (sync_reminder if use_country_selection else "")
+
+        await callback_query.message.edit_text(
+            text=final_text,
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    except Exception as e:
+        await session.rollback()
+        logger.error(f"Ошибка при переносе ключей на сервер {new_server_name}: {e}")
+        await callback_query.message.edit_text(
+            text=f"❌ Произошла ошибка при переносе ключей: {e}",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    finally:
+        await state.clear()
+
+
+@router.callback_query(F.data.startswith("transfer_to_cluster|"), IsAdminFilter())
+async def handle_cluster_transfer(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    try:
+        data = callback_query.data.split("|")
+        new_cluster_name = data[1]
+        old_cluster_name = data[2]
+        old_server_name = data[3]
+
+        user_data = await state.get_data()
+        cluster_name = user_data.get("cluster_name")
+
+        await session.execute(update(Key).where(Key.server_id == old_server_name).values(server_id=new_cluster_name))
+        await session.execute(update(Key).where(Key.server_id == old_cluster_name).values(server_id=new_cluster_name))
+
+        await session.execute(
+            delete(Server).where(
+                Server.cluster_name == cluster_name,
+                Server.server_name == old_server_name,
+            )
+        )
+
+        await session.commit()
+
+        await callback_query.message.edit_text(
+            text=(
+                f"✅ Ключи успешно перенесены в кластер '<b>{new_cluster_name}</b>', "
+                f"сервер '<b>{old_server_name}</b>' и кластер '<b>{old_cluster_name}</b>' удалены!\n\n"
+                f'⚠️ Не забудьте сделать "Синхронизацию".'
+            ),
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    except Exception as e:
+        await session.rollback()
+        logger.error(f"Ошибка при переносе ключей в кластер {new_cluster_name}: {e}")
+        await callback_query.message.edit_text(
+            text=f"❌ Произошла ошибка при переносе ключей: {e}",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+    finally:
+        await state.clear()
@@ -0,0 +1,260 @@
+from typing import Any
+
+from aiogram import F
+from aiogram.fsm.context import FSMContext
+from aiogram.types import CallbackQuery, Message
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database import check_unique_server_name, get_servers
+from database.models import Server
+from filters.admin import IsAdminFilter
+
+from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
+from .base import AdminClusterStates, router
+from .keyboard import (
+    AdminClusterCallback,
+    AdminServerCallback,
+    build_clusters_editor_kb,
+    build_panel_type_kb,
+)
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "clusters"),
+    IsAdminFilter(),
+)
+async def handle_servers(callback_query: CallbackQuery, session: AsyncSession):
+    servers = await get_servers(session, include_enabled=True)
+
+    text = (
+        "<b>🔧 Управление кластерами</b>\n\n"
+        "<blockquote>"
+        "🌐 <b>Кластеры</b> — это пространство серверов, в пределах которого создается подписка.\n"
+        "💡 Если вы хотите выдавать по 1 серверу, то добавьте всего 1 сервер в кластер."
+        "</blockquote>\n\n"
+        "<i>⚠️ <b>Важно:</b> Кластеры удаляются автоматически, если удалить все серверы внутри них.</i>\n\n"
+    )
+
+    message = callback_query.message
+    markup = build_clusters_editor_kb(servers)
+
+    if message and message.text:
+        await message.edit_text(text=text, reply_markup=markup)
+    else:
+        try:
+            await message.delete()
+        except Exception:
+            pass
+        await message.answer(text=text, reply_markup=markup)
+
+
+@router.callback_query(AdminClusterCallback.filter(F.action == "add"), IsAdminFilter())
+async def handle_clusters_add(callback_query: CallbackQuery, state: FSMContext):
+    text = (
+        "🔧 <b>Введите имя нового кластера:</b>\n\n"
+        "<b>Имя должно быть уникальным!</b>\n"
+        "<b>Имя не должно превышать 12 символов!</b>\n\n"
+        "<i>Пример:</i> <code>cluster1</code> или <code>us_east_1</code>"
+    )
+
+    await callback_query.message.edit_text(text=text, reply_markup=build_admin_back_kb("clusters"))
+
+    await state.set_state(AdminClusterStates.waiting_for_cluster_name)
+
+
+@router.message(AdminClusterStates.waiting_for_cluster_name, IsAdminFilter())
+async def handle_cluster_name_input(message: Message, state: FSMContext):
+    if not message.text:
+        await message.answer(
+            text="❌ Имя кластера не может быть пустым! Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    if len(message.text) > 12:
+        await message.answer(
+            text="❌ Имя кластера не должно превышать 12 символов! Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    cluster_name = message.text.strip()
+    await state.update_data(cluster_name=cluster_name)
+
+    text = (
+        f"<b>Введите имя сервера для кластера {cluster_name}:</b>\n\n"
+        "Рекомендуется указать локацию и номер сервера в имени.\n\n"
+        "<i>Пример:</i> <code>de1</code>, <code>fra1</code>, <code>fi2</code>"
+    )
+
+    await message.answer(
+        text=text,
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+
+    await state.set_state(AdminClusterStates.waiting_for_server_name)
+
+
+@router.message(AdminClusterStates.waiting_for_server_name, IsAdminFilter())
+async def handle_server_name_input(message: Message, state: FSMContext, session: Any):
+    if not message.text:
+        await message.answer(
+            text="❌ Имя сервера не может быть пустым. Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    server_name = message.text.strip()
+
+    if len(server_name) > 12:
+        await message.answer(
+            text="❌ Имя сервера не должно превышать 12 символов. Попробуйте снова.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+
+    if not await check_unique_server_name(session, server_name, cluster_name):
+        await message.answer(
+            text="❌ Сервер с таким именем уже существует. Пожалуйста, выберите другое имя.",
+            reply_markup=build_admin_back_kb("clusters"),
+        )
+        return
+
+    await state.update_data(server_name=server_name)
+
+    text = (
+        f"<b>Введите API URL для сервера {server_name} в кластере {cluster_name}:</b>\n\n"
+        "🔍 Ссылку можно найти в адресной строке браузера при входе в панель управления сервером.\n\n"
+        "ℹ️ <b>Формат для 3X-UI:</b>\n"
+        "<code>https://your-domain.com:port/panel_path/</code>\n\n"
+        "ℹ️ <b>Формат для Remnawave:</b>\n"
+        "<code>https://your-domain.com/api</code>"
+    )
+
+    await message.answer(
+        text=text,
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+
+    await state.set_state(AdminClusterStates.waiting_for_api_url)
+
+
+@router.message(AdminClusterStates.waiting_for_api_url, IsAdminFilter())
+async def handle_api_url_input(message: Message, state: FSMContext):
+    api_url = message.text.strip().rstrip("/")
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+    server_name = user_data.get("server_name")
+
+    await state.update_data(api_url=api_url)
+
+    text = (
+        f"<b>Введите subscription_url для сервера {server_name} в кластере {cluster_name}:</b>\n\n"
+        "Если вы используете Remnawave — введите <code>0</code>\n\n"
+        "<i>Формат:</i> <code>https://your_domain:port/sub_path</code>"
+    )
+
+    await message.answer(text=text, reply_markup=build_admin_back_kb("clusters"))
+    await state.set_state(AdminClusterStates.waiting_for_subscription_url)
+
+
+@router.message(AdminClusterStates.waiting_for_subscription_url, IsAdminFilter())
+async def handle_subscription_url_input(message: Message, state: FSMContext):
+    raw = message.text.strip()
+    subscription_url = None if raw == "0" else raw.rstrip("/")
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+    server_name = user_data.get("server_name")
+
+    await state.update_data(subscription_url=subscription_url)
+
+    await message.answer(
+        text=f"<b>Введите inbound_id/Squads для сервера {server_name} в кластере {cluster_name}:</b>\n\n"
+        f"Для Remnawave это UUID Squads, для 3x-ui — просто ID (например, <code>1</code>).",
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+    await state.set_state(AdminClusterStates.waiting_for_inbound_id)
+
+
+@router.message(AdminClusterStates.waiting_for_inbound_id, IsAdminFilter())
+async def handle_inbound_id_input(message: Message, state: FSMContext):
+    inbound_id = message.text.strip()
+    await state.update_data(inbound_id=inbound_id)
+
+    await message.answer(
+        text=(
+            "🧩 <b>Выберите тип панели для этого сервера:</b>\n\n"
+            "⚠️ <b>Внимание:</b> Некоторые функции <b>Remnawave</b> находятся в разработке.\n"
+            "Поддержка режима выбора стран — <b>ограничена</b>."
+        ),
+        reply_markup=build_panel_type_kb(),
+    )
+
+
+@router.callback_query(
+    AdminClusterCallback.filter(F.action.in_(["panel_3xui", "panel_remnawave"])),
+    IsAdminFilter(),
+)
+async def handle_panel_type_selection(
+    callback_query: CallbackQuery,
+    callback_data: AdminClusterCallback,
+    state: FSMContext,
+    session: AsyncSession,
+):
+    panel_type = "3x-ui" if callback_data.action == "panel_3xui" else "remnawave"
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+    server_name = user_data.get("server_name")
+    api_url = user_data.get("api_url")
+    subscription_url = user_data.get("subscription_url")
+    inbound_id = user_data.get("inbound_id")
+
+    result = await session.execute(select(Server.tariff_group).where(Server.cluster_name == cluster_name).limit(1))
+    row = result.first()
+    tariff_group = row[0] if row else None
+
+    new_server = Server(
+        cluster_name=cluster_name,
+        server_name=server_name,
+        api_url=api_url,
+        subscription_url=subscription_url,
+        inbound_id=inbound_id,
+        panel_type=panel_type,
+        tariff_group=tariff_group,
+    )
+
+    session.add(new_server)
+    await session.commit()
+
+    await callback_query.message.edit_text(
+        text=f"✅ Сервер <b>{server_name}</b> с панелью <b>{panel_type}</b> успешно добавлен в кластер <b>{cluster_name}</b>!",
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+    await state.clear()
+
+
+@router.callback_query(AdminServerCallback.filter(F.action == "add"), IsAdminFilter())
+async def handle_add_server(callback_query: CallbackQuery, callback_data: AdminServerCallback, state: FSMContext):
+    cluster_name = callback_data.data
+
+    await state.update_data(cluster_name=cluster_name)
+
+    text = (
+        f"<b>Введите имя сервера для кластера {cluster_name}:</b>\n\n"
+        "Рекомендуется указать локацию и номер сервера в имени.\n\n"
+        "<i>Пример:</i> <code>de1</code>, <code>fra1</code>, <code>fi2</code>"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_admin_back_kb("clusters"),
+    )
+
+    await state.set_state(AdminClusterStates.waiting_for_server_name)
@@ -4,6 +4,7 @@ from aiogram.utils.keyboard import InlineKeyboardBuilder

 from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
 from ..servers.keyboard import AdminServerCallback
+from handlers.buttons import BACK


 class AdminClusterCallback(CallbackData, prefix="admin_cluster"):
@@ -57,11 +58,171 @@ def build_manage_cluster_kb(cluster_servers: list, cluster_name: str) -> InlineK
            callback_data=AdminServerCallback(action="add", data=cluster_name).pack(),
        )
    )
+    builder.row(
+        InlineKeyboardButton(
+            text="💸 Тариф(Установить/изменить)",
+            callback_data=AdminClusterCallback(action="attach_tariff_menu", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
+        )
+    )
+
+    return builder.as_markup()
+
+
+def build_attach_tariff_kb(cluster_name: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(
+            text="📋 Привязать тарифы",
+            callback_data=AdminClusterCallback(action="set_subgroup", data=cluster_name).pack(),
+        ),
+        InlineKeyboardButton(
+            text="🧹 Сбросить",
+            callback_data=AdminClusterCallback(action="reset_cluster_subgroups", data=cluster_name).pack(),
+        ),
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="🗂 Спецгруппы",
+            callback_data=AdminClusterCallback(action="set_group", data=cluster_name).pack(),
+        ),
+        InlineKeyboardButton(
+            text="🧹 Сбросить",
+            callback_data=AdminClusterCallback(action="reset_cluster_groups", data=cluster_name).pack(),
+        ),
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
+        )
+    )
+    return builder.as_markup()
+
+
+def build_legacy_reset_kb(cluster_name: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(
+            text="🧹 Сбросить привязки",
+            callback_data=AdminClusterCallback(action="reset_cluster_subgroups", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminClusterCallback(action="attach_tariff_menu", data=cluster_name).pack(),
+        )
+    )
+    return builder.as_markup()
+
+
+def build_select_subgroup_servers_kb(
+    cluster_name: str, cluster_servers: list, selected: set[str]
+) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    names = []
+    for s in cluster_servers:
+        if isinstance(s, str):
+            names.append(s)
+        elif isinstance(s, dict):
+            names.append(s.get("server_name") or s.get("name") or str(s))
+        else:
+            names.append(getattr(s, "server_name", None) or getattr(s, "name", None) or str(s))
+
+    for i, name in enumerate(names):
+        mark = "✅" if name in selected else "⬜️"
+        builder.row(
+            InlineKeyboardButton(
+                text=f"{mark} {name}",
+                callback_data=AdminClusterCallback(action="toggle_server_subgroup", data=f"{cluster_name}|{i}").pack(),
+            )
+        )

    builder.row(
        InlineKeyboardButton(
-            text="🔙 Назад",
-            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
+            text="📋 Выбрать тарифы",
+            callback_data=AdminClusterCallback(action="choose_subgroup", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="♻️ Сбросить выбор",
+            callback_data=AdminClusterCallback(action="reset_subgroup_selection", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminClusterCallback(action="attach_tariff_menu", data=cluster_name).pack(),
+        )
+    )
+
+    return builder.as_markup()
+
+
+def build_tariff_subgroup_selection_kb(cluster_name: str, subgroups: list[str]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    for i, title in enumerate(subgroups):
+        builder.button(
+            text=title,
+            callback_data=AdminClusterCallback(action="apply_tariff_subgroup", data=f"{cluster_name}|{i}").pack(),
+        )
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад к выбору серверов",
+            callback_data=AdminClusterCallback(action="set_subgroup", data=cluster_name).pack(),
+        )
+    )
+    builder.adjust(2, 1)
+    return builder.as_markup()
+
+
+def build_tariff_selection_kb(cluster_name: str, tariffs: list, selected: set[int]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    grouped: dict[str | None, list] = {}
+    for t in tariffs:
+        subgroup = t.subgroup_title
+        grouped.setdefault(subgroup, []).append(t)
+
+    subgroups_sorted = sorted(grouped.keys(), key=lambda x: (x is None, x or ""))
+
+    for subgroup in subgroups_sorted:
+        tariffs_list = grouped[subgroup]
+
+        if subgroup:
+            builder.row(
+                InlineKeyboardButton(
+                    text=f"━━ {subgroup} ━━",
+                    callback_data="noop",
+                )
+            )
+
+        for t in tariffs_list:
+            mark = "✅" if t.id in selected else "⬜️"
+            builder.row(
+                InlineKeyboardButton(
+                    text=f"{mark} {t.name}",
+                    callback_data=AdminClusterCallback(action="toggle_tariff", data=f"{cluster_name}|{t.id}").pack(),
+                )
+            )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="✅ Применить",
+            callback_data=AdminClusterCallback(action="apply_tariffs", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад к выбору серверов",
+            callback_data=AdminClusterCallback(action="set_subgroup", data=cluster_name).pack(),
        )
    )

@@ -113,7 +274,7 @@ def build_cluster_management_kb(cluster_name: str) -> InlineKeyboardMarkup:
            callback_data=AdminClusterCallback(action="set_tariff", data=cluster_name).pack(),
        )
    )
-    builder.row(InlineKeyboardButton(text="🔙 Назад", callback_data=AdminPanelCallback(action="clusters").pack()))
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=AdminPanelCallback(action="clusters").pack()))

    return builder.as_markup()

@@ -161,9 +322,89 @@ def build_tariff_group_selection_kb(cluster_name: str, groups: list[tuple[int, s
        )
    builder.row(
        InlineKeyboardButton(
-            text="⬅️ Назад",
+            text=BACK,
            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
        )
    )
    builder.adjust(2, 1)
    return builder.as_markup()
+
+
+def build_select_group_servers_kb(cluster_name: str, cluster_servers: list, selected: set[str]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    names = []
+    for s in cluster_servers:
+        if isinstance(s, str):
+            names.append(s)
+        elif isinstance(s, dict):
+            names.append(s.get("server_name") or s.get("name") or str(s))
+        else:
+            names.append(getattr(s, "server_name", None) or getattr(s, "name", None) or str(s))
+
+    for i, name in enumerate(names):
+        mark = "✅" if name in selected else "⬜️"
+        builder.row(
+            InlineKeyboardButton(
+                text=f"{mark} {name}",
+                callback_data=AdminClusterCallback(action="toggle_server_group", data=f"{cluster_name}|{i}").pack(),
+            )
+        )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="📚 Выбрать спецгруппу",
+            callback_data=AdminClusterCallback(action="choose_group", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="♻️ Сбросить выбор",
+            callback_data=AdminClusterCallback(action="reset_group_selection", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
+        )
+    )
+    return builder.as_markup()
+
+
+def build_tariff_group_selection_for_servers_kb(
+    cluster_name: str, groups: list[tuple[int, str]]
+) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    for group_id, group_code in groups:
+        builder.button(
+            text=group_code,
+            callback_data=AdminClusterCallback(
+                action="apply_group_to_servers", data=f"{cluster_name}|{group_id}"
+            ).pack(),
+        )
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminClusterCallback(action="set_group", data=cluster_name).pack(),
+        )
+    )
+    builder.adjust(2, 1)
+    return builder.as_markup()
+
+
+def build_availability_kb(cluster_name: str) -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="🔁 Обновить",
+                    callback_data=AdminClusterCallback(action="availability", data=cluster_name).pack(),
+                )
+            ],
+            [
+                InlineKeyboardButton(
+                    text=BACK, callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack()
+                )
+            ],
+        ]
+    )
@@ -28,14 +28,15 @@ from .keyboard import (
    format_coupons_list,
 )

-
 router = Router()


 class AdminCouponsState(StatesGroup):
    waiting_for_coupon_type = State()
+    waiting_for_coupon_audience = State()
    waiting_for_balance_data = State()
    waiting_for_days_data = State()
+    waiting_for_percent_data = State()


@router.callback_query(
@@ -55,6 +56,7 @@ async def handle_coupons_create(callback_query: CallbackQuery, state: FSMContext
    kb = InlineKeyboardBuilder()
    kb.button(text="💰 Баланс", callback_data="coupon_type_balance")
    kb.button(text="⏳ Время", callback_data="coupon_type_days")
+    kb.button(text="📉 Процент", callback_data="coupon_type_percent")
    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
    kb.adjust(1)

@@ -62,34 +64,82 @@ async def handle_coupons_create(callback_query: CallbackQuery, state: FSMContext
    await state.set_state(AdminCouponsState.waiting_for_coupon_type)


-@router.callback_query(F.data == "coupon_type_balance")
-async def handle_balance_coupon_selection(callback_query: CallbackQuery, state: FSMContext):
-    text = (
-        "🎫 <b>Введите данные для создания купона в формате:</b>\n\n"
-        "📝 <i>код</i> 💰 <i>сумма</i> 🔢 <i>лимит</i>\n\n"
-        "Пример: <b>'COUPON1 50 5'</b> 👈\n\n"
-    )
+async def show_coupon_audience_step(callback_query: CallbackQuery, state: FSMContext):
+    text = "🎯 <b>Кому доступен купон?</b>"
    kb = InlineKeyboardBuilder()
+    kb.button(text="👤 Всем", callback_data="coupon_audience_all")
+    kb.button(text="🆕 Только новым", callback_data="coupon_audience_new")
    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+    kb.adjust(1)

    await callback_query.message.edit_text(text=text, reply_markup=kb.as_markup())
-    await state.set_state(AdminCouponsState.waiting_for_balance_data)
+    await state.set_state(AdminCouponsState.waiting_for_coupon_audience)


-@router.callback_query(F.data == "coupon_type_days")
+@router.callback_query(F.data == "coupon_type_balance", IsAdminFilter())
+async def handle_balance_coupon_selection(callback_query: CallbackQuery, state: FSMContext):
+    await state.update_data(coupon_type="balance")
+    await show_coupon_audience_step(callback_query, state)
+
+
+@router.callback_query(F.data == "coupon_type_days", IsAdminFilter())
 async def handle_days_coupon_selection(callback_query: CallbackQuery, state: FSMContext):
+    await state.update_data(coupon_type="days", new_users_only=False)
+
+    kb = InlineKeyboardBuilder()
+    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+    kb.adjust(1)
+
    text = (
        "🎫 <b>Введите данные для создания купона в формате:</b>\n\n"
        "📝 <i>код</i> ⏳ <i>дни</i> 🔢 <i>лимит</i>\n\n"
-        "Пример: <b>'DAYS10 10 50'</b> 👈\n\n"
+        "Пример: <b>'DAYS10 10 50'</b>\n\n"
    )
-    kb = InlineKeyboardBuilder()
-    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
-
    await callback_query.message.edit_text(text=text, reply_markup=kb.as_markup())
    await state.set_state(AdminCouponsState.waiting_for_days_data)


+@router.callback_query(F.data == "coupon_type_percent", IsAdminFilter())
+async def handle_percent_coupon_selection(callback_query: CallbackQuery, state: FSMContext):
+    await state.update_data(coupon_type="percent", new_users_only=False)
+
+    kb = InlineKeyboardBuilder()
+    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+    kb.adjust(1)
+
+    text = (
+        "🎫 <b>Введите данные для создания купона в формате:</b>\n\n"
+        "📝 <i>код</i> 📉 <i>процент</i> 🔢 <i>лимит</i>\n\n"
+        "Пример: <b>'SALE20 20 10'</b>\n"
+        "Где 20 — это скидка 20%\n\n"
+    )
+    await callback_query.message.edit_text(text=text, reply_markup=kb.as_markup())
+    await state.set_state(AdminCouponsState.waiting_for_percent_data)
+
+
+@router.callback_query(F.data.in_(("coupon_audience_all", "coupon_audience_new")), IsAdminFilter())
+async def handle_coupon_audience(callback_query: CallbackQuery, state: FSMContext):
+    data = await state.get_data()
+    coupon_type = data.get("coupon_type")
+    if coupon_type != "balance":
+        await callback_query.answer("Ошибка: режим доступен только для купонов на баланс", show_alert=True)
+        return
+
+    await state.update_data(new_users_only=callback_query.data == "coupon_audience_new")
+
+    kb = InlineKeyboardBuilder()
+    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+    kb.adjust(1)
+
+    text = (
+        "🎫 <b>Введите данные для создания купона в формате:</b>\n\n"
+        "📝 <i>код</i> 💰 <i>сумма</i> 🔢 <i>лимит</i>\n\n"
+        "Пример: <b>'COUPON1 50 5'</b>\n\n"
+    )
+    await callback_query.message.edit_text(text=text, reply_markup=kb.as_markup())
+    await state.set_state(AdminCouponsState.waiting_for_balance_data)
+
+
@router.message(AdminCouponsState.waiting_for_balance_data, IsAdminFilter())
 async def handle_balance_coupon_input(message: Message, state: FSMContext, session: Any):
    text = message.text.strip()
@@ -97,12 +147,13 @@ async def handle_balance_coupon_input(message: Message, state: FSMContext, sessi

    kb = InlineKeyboardBuilder()
    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+    kb.adjust(1)

    if len(parts) != 3:
        text = (
-            "❌ <b>Некорректный формат!</b> 📝 Пожалуйста, введите данные в формате:\n"
+            "❌ <b>Некорректный формат!</b>\n"
            "🏷️ <b>код</b> 💰 <b>сумма</b> 🔢 <b>лимит</b>\n"
-            "Пример: <b>'COUPON1 50 5'</b> 👈"
+            "Пример: <b>'COUPON1 50 5'</b>"
        )
        await message.answer(text=text, reply_markup=kb.as_markup())
        return
@@ -112,20 +163,39 @@ async def handle_balance_coupon_input(message: Message, state: FSMContext, sessi
        coupon_amount = int(parts[1])
        usage_limit = int(parts[2])
        if coupon_amount <= 0:
-            raise ValueError("Сумма должна быть больше 0")
+            raise ValueError
+        if usage_limit <= 0:
+            raise ValueError
    except ValueError:
-        text = "⚠️ <b>Проверьте правильность введенных данных!</b>\n💱 Сумма должна быть числом, а лимит — целым числом."
+        text = "⚠️ <b>Проверьте данные!</b>\nСумма и лимит должны быть целыми числами больше 0."
        await message.answer(text=text, reply_markup=kb.as_markup())
        return

    try:
-        await create_coupon(session, coupon_code, coupon_amount, usage_limit, days=None)
+        data = await state.get_data()
+        new_users_only = bool(data.get("new_users_only"))
+
+        ok = await create_coupon(
+            session,
+            coupon_code,
+            coupon_amount,
+            usage_limit,
+            days=None,
+            new_users_only=new_users_only,
+            percent=None,
+        )
+        if not ok:
+            await message.answer("❌ Купон с таким кодом уже существует.", reply_markup=kb.as_markup())
+            return

        coupon_link = f"https://t.me/{USERNAME_BOT}?start=coupons_{coupon_code}"
+        audience_txt = "🆕 Только новым" if new_users_only else "👤 Всем"
+
        text = (
-            f"✅ Купон с кодом <b>{coupon_code}</b> успешно создан!\n"
+            f"✅ Купон <b>{coupon_code}</b> создан!\n"
            f"💰 Сумма: <b>{coupon_amount} рублей</b>\n"
-            f"🔢 Лимит использования: <b>{usage_limit} раз</b>\n"
+            f"🔢 Лимит: <b>{usage_limit} раз</b>\n"
+            f"🎯 Доступ: <b>{audience_txt}</b>\n"
            f"🔗 <b>Ссылка:</b> <code>{coupon_link}</code>\n"
        )

@@ -137,7 +207,6 @@ async def handle_balance_coupon_input(message: Message, state: FSMContext, sessi

        await message.answer(text=text, reply_markup=kb.as_markup())
        await state.clear()
-
    except Exception as e:
        logger.error(f"Ошибка при создании купона: {e}")
        await message.answer("❌ Произошла ошибка при создании купона.", reply_markup=kb.as_markup())
@@ -150,12 +219,11 @@ async def handle_days_coupon_input(message: Message, state: FSMContext, session:

    kb = InlineKeyboardBuilder()
    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+    kb.adjust(1)

    if len(parts) != 3:
        text = (
-            "❌ <b>Некорректный формат!</b> 📝 Пожалуйста, введите данные в формате:\n"
-            "🏷️ <b>код</b> ⏳ <i>дни</i> 🔢 <b>лимит</b>\n"
-            "Пример: <b>'DAYS10 10 50'</b> 👈"
+            "❌ <b>Некорректный формат!</b>\n🏷️ <b>код</b> ⏳ <b>дни</b> 🔢 <b>лимит</b>\nПример: <b>'DAYS10 10 50'</b>"
        )
        await message.answer(text=text, reply_markup=kb.as_markup())
        return
@@ -165,20 +233,34 @@ async def handle_days_coupon_input(message: Message, state: FSMContext, session:
        days = int(parts[1])
        usage_limit = int(parts[2])
        if days <= 0:
-            raise ValueError("Количество дней должно быть больше 0")
+            raise ValueError
+        if usage_limit <= 0:
+            raise ValueError
    except ValueError:
-        text = "⚠️ <b>Проверьте правильность введенных данных!</b>\n💱 Дни должны быть числом, а лимит — целым числом."
+        text = "⚠️ <b>Проверьте данные!</b>\nДни и лимит должны быть целыми числами больше 0."
        await message.answer(text=text, reply_markup=kb.as_markup())
        return

    try:
-        await create_coupon(session, coupon_code, 0, usage_limit, days=days)
+        ok = await create_coupon(
+            session,
+            coupon_code,
+            0,
+            usage_limit,
+            days=days,
+            new_users_only=False,
+            percent=None,
+        )
+        if not ok:
+            await message.answer("❌ Купон с таким кодом уже существует.", reply_markup=kb.as_markup())
+            return

        coupon_link = f"https://t.me/{USERNAME_BOT}?start=coupons_{coupon_code}"
+
        text = (
-            f"✅ Купон с кодом <b>{coupon_code}</b> успешно создан!\n"
+            f"✅ Купон <b>{coupon_code}</b> создан!\n"
            f"⏳ <b>{format_days(days)}</b>\n"
-            f"🔢 Лимит использования: <b>{usage_limit} раз</b>\n"
+            f"🔢 Лимит: <b>{usage_limit} раз</b>\n"
            f"🔗 <b>Ссылка:</b> <code>{coupon_link}</code>\n"
        )

@@ -190,7 +272,66 @@ async def handle_days_coupon_input(message: Message, state: FSMContext, session:

        await message.answer(text=text, reply_markup=kb.as_markup())
        await state.clear()
+    except Exception as e:
+        logger.error(f"Ошибка при создании купона: {e}")
+        await message.answer("❌ Произошла ошибка при создании купона.", reply_markup=kb.as_markup())

+
+@router.message(AdminCouponsState.waiting_for_percent_data, IsAdminFilter())
+async def handle_percent_coupon_input(message: Message, state: FSMContext, session: Any):
+    text = message.text.strip()
+    parts = text.split()
+
+    kb = InlineKeyboardBuilder()
+    kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+    kb.adjust(1)
+
+    if len(parts) != 3:
+        text = (
+            "❌ <b>Некорректный формат!</b>\n"
+            "🏷️ <b>код</b> 📉 <b>процент</b> 🔢 <b>лимит</b>\n"
+            "Пример: <b>'SALE20 20 10'</b>"
+        )
+        await message.answer(text=text, reply_markup=kb.as_markup())
+        return
+
+    try:
+        coupon_code = parts[0]
+        percent = int(parts[1])
+        usage_limit = int(parts[2])
+        if percent <= 0 or percent > 100:
+            raise ValueError
+        if usage_limit <= 0:
+            raise ValueError
+    except ValueError:
+        text = "⚠️ <b>Проверьте данные!</b>\nПроцент должен быть 1..100, лимит — целое число больше 0."
+        await message.answer(text=text, reply_markup=kb.as_markup())
+        return
+
+    try:
+        ok = await create_coupon(
+            session,
+            coupon_code,
+            0,
+            usage_limit,
+            days=None,
+            new_users_only=False,
+            percent=percent,
+        )
+        if not ok:
+            await message.answer("❌ Купон с таким кодом уже существует.", reply_markup=kb.as_markup())
+            return
+
+        text = (
+            f"✅ Купон <b>{coupon_code}</b> создан!\n📉 Скидка: <b>{percent}%</b>\n🔢 Лимит: <b>{usage_limit} раз</b>\n"
+        )
+
+        kb = InlineKeyboardBuilder()
+        kb.button(text=BACK, callback_data=AdminPanelCallback(action="coupons").pack())
+        kb.adjust(1)
+
+        await message.answer(text=text, reply_markup=kb.as_markup())
+        await state.clear()
    except Exception as e:
        logger.error(f"Ошибка при создании купона: {e}")
        await message.answer("❌ Произошла ошибка при создании купона.", reply_markup=kb.as_markup())
@@ -286,7 +427,6 @@ async def inline_coupon_handler(inline_query: InlineQuery, session: Any):
        return

    coupon_code = inline_query.query.split("coupon_")[1]
-    coupon_link = f"https://t.me/{USERNAME_BOT}?start=coupons_{coupon_code}"

    coupons = await get_all_coupons(session, page=1, per_page=10)
    coupon = next((c for c in coupons["coupons"] if c["code"] == coupon_code), None)
@@ -300,17 +440,39 @@ async def inline_coupon_handler(inline_query: InlineQuery, session: Any):
        )
        return

+    percent_value = coupon.get("percent")
+    if percent_value is not None and int(percent_value) > 0:
+        await inline_query.answer(
+            results=[],
+            switch_pm_text="Процентные купоны не публикуются ссылкой",
+            switch_pm_parameter="coupons",
+            cache_time=1,
+        )
+        return
+
+    coupon_link = f"https://t.me/{USERNAME_BOT}?start=coupons_{coupon_code}"
    title = f"Купон {coupon['code']}"
-    description = (
-        f"Получи {coupon['amount']} рублей!"
-        if coupon["amount"] > 0
-        else f"Продли подписку на {format_days(coupon['days'])}!"
-    )
-    message_text = (
-        f"🎫 <b>Купон:</b> {coupon['code']}\n"
-        f"{'💰 <b>Бонус:</b> ' + str(coupon['amount']) + ' рублей' if coupon['amount'] > 0 else '⏳ <b>Продление:</b> ' + format_days(coupon['days'])}\n"
-        f"👇 Нажми, чтобы активировать!"
-    )
+
+    days_value = coupon.get("days")
+    amount_value = coupon.get("amount") or 0
+
+    if days_value is not None and int(days_value) > 0:
+        days_int = int(days_value)
+        description = f"Продли подписку на {format_days(days_int)}!"
+        message_text = (
+            f"🎫 <b>Купон:</b> {coupon['code']}\n"
+            f"⏳ <b>Продление:</b> {format_days(days_int)}\n"
+            f"👇 Нажми, чтобы активировать!"
+        )
+    elif int(amount_value) > 0:
+        amount_int = int(amount_value)
+        description = f"Получи {amount_int} рублей!"
+        message_text = (
+            f"🎫 <b>Купон:</b> {coupon['code']}\n💰 <b>Бонус:</b> {amount_int} рублей\n👇 Нажми, чтобы активировать!"
+        )
+    else:
+        description = "Купон"
+        message_text = f"🎫 <b>Купон:</b> {coupon['code']}\n👇 Нажми, чтобы активировать!"

    builder = InlineKeyboardBuilder()
    builder.button(text="Активировать купон", url=coupon_link)
@@ -1,5 +1,3 @@
-from typing import Optional
-
 from aiogram.filters.callback_data import CallbackData
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder
@@ -69,18 +67,30 @@ def build_coupons_list_kb(coupons: list, current_page: int, total_pages: int) ->


 def format_coupons_list(coupons: list, username_bot: str) -> str:
-    coupon_list = "📜 Список всех купонов:\n\n"
-    for coupon in coupons:
-        value_text = (
-            f"💰 <b>Сумма:</b> {coupon['amount']} рублей"
-            if coupon["amount"] > 0
-            else f"⏳ <b>{format_days(coupon['days'])}</b>"
+    text = "📜 <b>Список купонов</b>\n\n"
+
+    for i, coupon in enumerate(coupons, start=1):
+        percent_value = coupon.get("percent")
+        days_value = coupon.get("days")
+        amount_value = coupon.get("amount") or 0
+
+        if percent_value is not None and int(percent_value) > 0:
+            value_line = f"📉 <b>Скидка:</b> {int(percent_value)}%"
+        elif days_value is not None and int(days_value) > 0:
+            value_line = f"⏳ <b>Продление:</b> {format_days(int(days_value))}"
+        elif int(amount_value) > 0:
+            value_line = f"💰 <b>Баланс:</b> {int(amount_value)} ₽"
+        else:
+            value_line = "—"
+
+        text += (
+            f"<blockquote>"
+            f"<b>{i}. {coupon['code']}</b>\n"
+            f"{value_line}\n"
+            f"🔢 <b>Лимит:</b> {coupon['usage_limit']} | "
+            f"✅ <b>Использовано:</b> {coupon['usage_count']}\n"
+            f"<code>https://t.me/{username_bot}?start=coupons_{coupon['code']}</code>"
+            f"</blockquote>\n\n"
        )
-        coupon_list += (
-            f"🏷️ <b>Код:</b> {coupon['code']}\n"
-            f"{value_text}\n"
-            f"🔢 <b>Лимит использования:</b> {coupon['usage_limit']} раз\n"
-            f"✅ <b>Использовано:</b> {coupon['usage_count']} раз\n"
-            f"🔗 <b>Ссылка:</b> <code>https://t.me/{username_bot}?start=coupons_{coupon['code']}</code>\n\n"
-        )
-    return coupon_list
+
+    return text
@@ -0,0 +1,3 @@
+__all__ = ("router",)
+
+from .emoji_handler import router
@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from aiogram import F, Router
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.enums import MessageEntityType
+from aiogram.types import CallbackQuery, Message, MessageEntity
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from filters.admin import IsAdminFilter
+from handlers.buttons import BACK
+from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
+
+
+class AdminEmojiState(StatesGroup):
+    waiting_for_custom_emoji = State()
+
+
+router = Router()
+
+
+def _build_back_to_emoji_menu() -> InlineKeyboardBuilder:
+    builder = InlineKeyboardBuilder()
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="emoji").pack())
+    builder.adjust(1)
+    return builder
+
+
+def _extract_custom_emoji_ids(entities: Iterable[MessageEntity]) -> list[str]:
+    ids: list[str] = []
+    for ent in entities:
+        if ent.type == MessageEntityType.CUSTOM_EMOJI and ent.custom_emoji_id:
+            ids.append(ent.custom_emoji_id)
+    return ids
+
+
+def _utf16_len(text: str) -> int:
+    return len(text.encode("utf-16-le")) // 2
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "emoji"), IsAdminFilter())
+async def show_emoji_menu(callback_query: CallbackQuery, state: FSMContext):
+    await state.set_state(AdminEmojiState.waiting_for_custom_emoji)
+    example_id = "5201769509345588200"
+    marker = f"{{{{emoji:{example_id}}}}}"
+    preview_placeholder = "😀"
+    text = (
+        "Отправьте любое кастомное эмоджи — я верну его ID и покажу пример для текстов.\n\n"
+        "Пример:\n"
+        f"{preview_placeholder}"
+    )
+
+    entities: list[MessageEntity] = []
+    start = 0
+    while True:
+        marker_pos = text.find(marker, start)
+        if marker_pos == -1:
+            break
+        entities.append(
+            MessageEntity(
+                type=MessageEntityType.CODE,
+                offset=_utf16_len(text[:marker_pos]),
+                length=_utf16_len(marker),
+            )
+        )
+        start = marker_pos + len(marker)
+    preview_pos = text.find(preview_placeholder)
+    if preview_pos != -1:
+        entities.append(
+            MessageEntity(
+                type=MessageEntityType.CUSTOM_EMOJI,
+                offset=_utf16_len(text[:preview_pos]),
+                length=_utf16_len(preview_placeholder),
+                custom_emoji_id=example_id,
+            )
+        )
+
+    if hasattr(callback_query.message, "_original_edit_text"):
+        await callback_query.message._original_edit_text(
+            text=text,
+            entities=entities,
+            reply_markup=build_admin_back_kb("admin"),
+            parse_mode=None,
+        )
+    else:
+        await callback_query.message.edit_text(
+            text=text,
+            entities=entities,
+            reply_markup=build_admin_back_kb("admin"),
+            parse_mode=None,
+        )
+
+
+@router.message(AdminEmojiState.waiting_for_custom_emoji, IsAdminFilter())
+async def handle_custom_emoji_id(message: Message, state: FSMContext):
+    entities = list(message.entities or []) + list(message.caption_entities or [])
+    emoji_ids = _extract_custom_emoji_ids(entities)
+
+    if not emoji_ids:
+        await message.answer(
+            "❌ Не вижу кастомных эмоджи. Отправьте именно <b>кастомный эмоджи</b> из набора.",
+            reply_markup=_build_back_to_emoji_menu().as_markup(),
+        )
+        return
+
+    unique_ids: list[str] = []
+    for emoji_id in emoji_ids:
+        if emoji_id not in unique_ids:
+            unique_ids.append(emoji_id)
+
+    placeholder = "😀"
+    back_builder = _build_back_to_emoji_menu()
+
+    if len(unique_ids) == 1:
+        emoji_id = unique_ids[0]
+        marker = f"{{{{emoji:{emoji_id}}}}}"
+        example_send = f"Ты отправил: Привет, {marker} !"
+        example_recv = f"А получил: Привет, {placeholder} !"
+        instruction_text = (
+            "✅ ID кастомного эмоджи\n"
+            f"{emoji_id}\n\n"
+            "Вставляйте в файл текстов так:\n"
+            f"{marker}\n\n"
+            "Пример:\n"
+            f"{example_send}\n"
+            f"{example_recv}\n\n"
+            "⚠️ Условие: отображение кастомных эмоджи работает, если у владельца бота есть Telegram Premium."
+        )
+        preview_text = example_recv
+        preview_ids = [emoji_id]
+        code_markers = [marker]
+    else:
+        ids_text = "\n".join(f"• {emoji_id}" for emoji_id in unique_ids)
+        markers_text = "\n".join(f"• {{{{emoji:{emoji_id}}}}}" for emoji_id in unique_ids)
+        markers_inline = " ".join(f"{{{{emoji:{emoji_id}}}}}" for emoji_id in unique_ids)
+        example_send = f"Ты отправил: Привет, {markers_inline} !"
+        example_recv = "А получил: Привет, " + " ".join(placeholder for _ in unique_ids) + " !"
+        instruction_text = (
+            "✅ ID кастомных эмоджи\n"
+            f"{ids_text}\n\n"
+            "Вставляйте в файл текстов так:\n"
+            f"{markers_text}\n\n"
+            "Пример:\n"
+            f"{example_send}\n"
+            f"{example_recv}\n\n"
+            "⚠️ Условие: отображение кастомных эмоджи работает, если у владельца бота есть Telegram Premium."
+        )
+        preview_text = example_recv
+        preview_ids = unique_ids
+        code_markers = [f"{{{{emoji:{emoji_id}}}}}" for emoji_id in unique_ids]
+
+    full_text = instruction_text
+
+    entities: list[MessageEntity] = []
+    for marker in code_markers:
+        start = 0
+        while True:
+            pos = full_text.find(marker, start)
+            if pos == -1:
+                break
+            entities.append(
+                MessageEntity(
+                    type=MessageEntityType.CODE,
+                    offset=_utf16_len(full_text[:pos]),
+                    length=_utf16_len(marker),
+                )
+            )
+            start = pos + len(marker)
+
+    for emoji_id in unique_ids:
+        start = 0
+        while True:
+            pos = full_text.find(emoji_id, start)
+            if pos == -1:
+                break
+            entities.append(
+                MessageEntity(
+                    type=MessageEntityType.CODE,
+                    offset=_utf16_len(full_text[:pos]),
+                    length=_utf16_len(emoji_id),
+                )
+            )
+            start = pos + len(emoji_id)
+    preview_offset_base = _utf16_len(full_text[: full_text.index(preview_text)])
+    running_utf16 = 0
+    idx = 0
+    for ch in preview_text:
+        if ch == placeholder and idx < len(preview_ids):
+            entities.append(
+                MessageEntity(
+                    type=MessageEntityType.CUSTOM_EMOJI,
+                    offset=preview_offset_base + running_utf16,
+                    length=_utf16_len(placeholder),
+                    custom_emoji_id=str(preview_ids[idx]),
+                )
+            )
+            idx += 1
+        running_utf16 += _utf16_len(ch)
+
+    if hasattr(message, "_original_answer"):
+        await message._original_answer(
+            text=full_text,
+            entities=entities,
+            reply_markup=back_builder.as_markup(),
+            parse_mode=None,
+        )
+    else:
+        await message.answer(text=full_text, reply_markup=back_builder.as_markup(), parse_mode=None)
+    await state.clear()
@@ -1,3 +1,5 @@
+from collections import defaultdict
+
 from aiogram import Bot, F, Router, types
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
@@ -6,13 +8,15 @@ from aiogram.utils.keyboard import InlineKeyboardBuilder
 from sqlalchemy import delete, func, select
 from sqlalchemy.ext.asyncio import AsyncSession

-from database.models import Gift, GiftUsage, Tariff
-from database.tariffs import create_subgroup_hash, find_subgroup_by_hash
+from filters.admin import IsAdminFilter
+from database.models import Gift, GiftUsage
+from database.tariffs import create_subgroup_hash, find_subgroup_by_hash, get_tariffs
 from handlers.utils import edit_or_send_message, format_days, format_months
 from logger import logger

 from ..panel.keyboard import AdminPanelCallback
 from .keyboard import build_admin_gifts_kb, build_gifts_list_kb
+from handlers.buttons import BACK


 router = Router()
@@ -23,42 +27,46 @@ class GiftCreationState(StatesGroup):
    waiting_for_limit_input_or_unlimited = State()


-@router.callback_query(AdminPanelCallback.filter(F.action == "gifts"))
+@router.callback_query(AdminPanelCallback.filter(F.action == "gifts"), IsAdminFilter())
 async def admin_gift_menu(callback: CallbackQuery):
    await callback.message.edit_text(
        text="🎁 <b>Подарки</b>\nВыберите, что хотите сделать:", reply_markup=build_admin_gifts_kb()
    )


-@router.callback_query(F.data == "admin_gift_create")
+@router.callback_query(F.data == "admin_gift_create", IsAdminFilter())
 async def admin_create_gift_step1(callback: CallbackQuery, session: AsyncSession):
-    stmt = select(Tariff).where(Tariff.group_code == "gifts", Tariff.is_active.is_(True)).order_by(Tariff.duration_days)
-    result = await session.execute(stmt)
-    tariffs = result.scalars().all()
+    tariffs_data = await get_tariffs(session, group_code="gifts", with_subgroup_weights=True)
+    tariffs = [t for t in tariffs_data["tariffs"] if t.get("is_active")]
+    subgroup_weights = tariffs_data["subgroup_weights"]

    if not tariffs:
        builder = InlineKeyboardBuilder()
-        builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack())
+        builder.button(text=BACK, callback_data=AdminPanelCallback(action="gifts").pack())
        await callback.message.edit_text("❌ Нет активных тарифов в группе 'gifts'.", reply_markup=builder.as_markup())
        return

-    from collections import defaultdict
-
    grouped_tariffs = defaultdict(list)
    for t in tariffs:
-        grouped_tariffs[t.subgroup_title].append(t)
+        grouped_tariffs[t.get("subgroup_title")].append(t)

    builder = InlineKeyboardBuilder()

    for t in grouped_tariffs.get(None, []):
-        if t.duration_days % 30 == 0:
-            duration_text = format_months(t.duration_days // 30)
+        if t.get("duration_days") % 30 == 0:
+            duration_text = format_months(t.get("duration_days") // 30)
        else:
-            duration_text = format_days(t.duration_days)
+            duration_text = format_days(t.get("duration_days"))

-        builder.button(text=f"{t.name} – {duration_text}", callback_data=f"admin_gift_select|{t.id}")
+        builder.row(
+            types.InlineKeyboardButton(
+                text=f"{t.get('name')} – {duration_text}", callback_data=f"admin_gift_select|{t.get('id')}"
+            )
+        )

-    for subgroup in sorted(k for k in grouped_tariffs if k):
+    sorted_subgroups = sorted([k for k in grouped_tariffs if k], key=lambda x: (subgroup_weights.get(x, 999999), x))
+
+    for subgroup in sorted_subgroups:
        subgroup_hash = create_subgroup_hash(subgroup, "gifts")
        builder.row(
            types.InlineKeyboardButton(
@@ -67,12 +75,12 @@ async def admin_create_gift_step1(callback: CallbackQuery, session: AsyncSession
            )
        )

-    builder.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack()))
+    builder.row(types.InlineKeyboardButton(text=BACK, callback_data=AdminPanelCallback(action="gifts").pack()))

    await callback.message.edit_text("🎁 Выберите тариф для подарка:", reply_markup=builder.as_markup())


-@router.callback_query(F.data.startswith("admin_gift_subgroup|"))
+@router.callback_query(F.data.startswith("admin_gift_subgroup|"), IsAdminFilter())
 async def admin_gift_show_tariffs_in_subgroup(callback: CallbackQuery, session: AsyncSession):
    try:
        subgroup_hash = callback.data.split("|", 1)[1]
@@ -82,34 +90,27 @@ async def admin_gift_show_tariffs_in_subgroup(callback: CallbackQuery, session:
            await callback.message.edit_text("❌ Подгруппа не найдена.")
            return

-        stmt = (
-            select(Tariff)
-            .where(Tariff.group_code == "gifts", Tariff.is_active.is_(True))
-            .order_by(Tariff.duration_days)
-        )
-        result = await session.execute(stmt)
-        tariffs = result.scalars().all()
-
-        filtered = [t for t in tariffs if t.subgroup_title == subgroup]
+        tariffs = await get_tariffs(session, group_code="gifts")
+        filtered = [t for t in tariffs if t.get("subgroup_title") == subgroup and t.get("is_active")]
        if not filtered:
            await callback.message.edit_text("❌ В этой подгруппе пока нет тарифов.")
            return

        builder = InlineKeyboardBuilder()
        for t in filtered:
-            if t.duration_days % 30 == 0:
-                duration_text = format_months(t.duration_days // 30)
+            if t.get("duration_days") % 30 == 0:
+                duration_text = format_months(t.get("duration_days") // 30)
            else:
-                duration_text = format_days(t.duration_days)
+                duration_text = format_days(t.get("duration_days"))

            builder.row(
                types.InlineKeyboardButton(
-                    text=f"{t.name} – {duration_text}",
-                    callback_data=f"admin_gift_select|{t.id}",
+                    text=f"{t.get('name')} – {duration_text}",
+                    callback_data=f"admin_gift_select|{t.get('id')}",
                )
            )

-        builder.row(types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_gift_create"))
+        builder.row(types.InlineKeyboardButton(text=BACK, callback_data="admin_gift_create"))

        await edit_or_send_message(
            target_message=callback.message,
@@ -122,20 +123,20 @@ async def admin_gift_show_tariffs_in_subgroup(callback: CallbackQuery, session:
        await callback.message.answer("❌ Произошла ошибка при отображении тарифов.")


-@router.callback_query(F.data.startswith("admin_gift_select|"))
+@router.callback_query(F.data.startswith("admin_gift_select|"), IsAdminFilter())
 async def handle_tariff_selection(callback: CallbackQuery, state: FSMContext):
    tariff_id = int(callback.data.split("|")[1])
    await state.update_data(tariff_id=tariff_id)
    await state.set_state(GiftCreationState.waiting_for_limit_input_or_unlimited)

    kb = InlineKeyboardBuilder()
-    kb.button(text="🔙 Назад", callback_data="admin_gift_create")
+    kb.button(text=BACK, callback_data="admin_gift_create")
    await callback.message.edit_text(
        "🔢 Введите максимальное количество активаций подарка:", reply_markup=kb.as_markup()
    )


-@router.callback_query(F.data == "gift_limit_unlimited")
+@router.callback_query(F.data == "gift_limit_unlimited", IsAdminFilter())
 async def handle_unlimited_gift(callback: CallbackQuery, state: FSMContext, bot: Bot):
    from handlers.payments.gift import finalize_gift

@@ -145,7 +146,7 @@ async def handle_unlimited_gift(callback: CallbackQuery, state: FSMContext, bot:
    await finalize_gift(callback.message, session, bot, data, is_unlimited=True)


-@router.message(GiftCreationState.waiting_for_limit_input_or_unlimited)
+@router.message(GiftCreationState.waiting_for_limit_input_or_unlimited, IsAdminFilter())
 async def handle_limited_gift_input(message: types.Message, session: AsyncSession, state: FSMContext, bot: Bot):
    from handlers.payments.gift import finalize_gift

@@ -163,12 +164,12 @@ async def handle_limited_gift_input(message: types.Message, session: AsyncSessio
    await finalize_gift(message, session, bot, data, is_unlimited=False)


-@router.callback_query(F.data == "admin_gifts_all")
+@router.callback_query(F.data == "admin_gifts_all", IsAdminFilter())
 async def show_gifts_page(callback: CallbackQuery, session: AsyncSession):
    await show_gift_list(callback, session, page=1)


-@router.callback_query(F.data.startswith("gifts_page|"))
+@router.callback_query(F.data.startswith("gifts_page|"), IsAdminFilter())
 async def paginate_gifts(callback: CallbackQuery, session: AsyncSession):
    page = int(callback.data.split("|")[1])
    await show_gift_list(callback, session, page)
@@ -182,47 +183,21 @@ async def show_gift_list(callback: CallbackQuery, session: AsyncSession, page: i
    result = await session.execute(stmt)
    gifts = result.scalars().all()

-    from aiogram.utils.keyboard import InlineKeyboardBuilder
-
-    builder = InlineKeyboardBuilder()
-
    if not gifts:
-        builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack())
+        builder = InlineKeyboardBuilder()
+        builder.button(text=BACK, callback_data=AdminPanelCallback(action="gifts").pack())
        await callback.message.edit_text("❌ Подарки не найдены.", reply_markup=builder.as_markup())
        return

    keyboard = build_gifts_list_kb(gifts, page, total=len(gifts))

-    builder.inline_keyboard.extend(keyboard.inline_keyboard)
-    builder.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack()))
-
-    await callback.message.edit_text(f"🎁 <b>Список подарков</b>\nСтраница {page}:", reply_markup=builder.as_markup())
+    await callback.message.edit_text(
+        f"🎁 <b>Список подарков</b>\nСтраница {page}:",
+        reply_markup=keyboard,
+    )


-async def show_gift_list(callback: CallbackQuery, session: AsyncSession, page: int):
-    limit = 10
-    offset = (page - 1) * limit
-
-    stmt = select(Gift).order_by(Gift.created_at.desc()).offset(offset).limit(limit)
-    result = await session.execute(stmt)
-    gifts = result.scalars().all()
-
-    builder = InlineKeyboardBuilder()
-
-    if not gifts:
-        builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack())
-        await callback.message.edit_text("❌ Подарки не найдены.", reply_markup=builder.as_markup())
-        return
-
-    keyboard = build_gifts_list_kb(gifts, page, total=len(gifts))
-
-    for row in keyboard.inline_keyboard:
-        builder.row(*row)
-
-    await callback.message.edit_text(f"🎁 <b>Список подарков</b>\nСтраница {page}:", reply_markup=builder.as_markup())
-
-
-@router.callback_query(F.data.startswith("gift_view|"))
+@router.callback_query(F.data.startswith("gift_view|"), IsAdminFilter())
 async def view_gift(callback: CallbackQuery, session: AsyncSession):
    gift_id = callback.data.split("|")[1]

@@ -250,18 +225,17 @@ async def view_gift(callback: CallbackQuery, session: AsyncSession):
        f"ID: <code>{gift.gift_id}</code>\n"
        f"Срок: <b>{duration_text}</b>\n"
        f"Активаций: <b>{usage_text}</b>\n"
-        f"Истекает: <i>{gift.expiry_time.strftime('%d.%m.%Y')}</i>\n"
        f"<b>Ссылка для активации:</b>\n<blockquote>{gift.gift_link}</blockquote>"
    )

    builder = InlineKeyboardBuilder()
    builder.button(text="🗑 Удалить", callback_data=f"gift_delete|{gift_id}")
-    builder.button(text="🔙 Назад", callback_data="admin_gifts_all")
+    builder.button(text=BACK, callback_data="admin_gifts_all")

    await callback.message.edit_text(text, reply_markup=builder.as_markup())


-@router.callback_query(F.data.startswith("gift_delete|"))
+@router.callback_query(F.data.startswith("gift_delete|"), IsAdminFilter())
 async def delete_gift(callback: CallbackQuery, session: AsyncSession):
    gift_id = callback.data.split("|")[1]

@@ -3,7 +3,7 @@ from aiogram.utils.keyboard import InlineKeyboardBuilder

 from database.models import Gift, Tariff
 from handlers.buttons import BACK
-from handlers.utils import format_days, format_months, get_plural_form
+from handlers.utils import format_days

 from ..panel.keyboard import AdminPanelCallback

@@ -27,7 +27,7 @@ def build_gift_tariffs_kb(tariffs: list[Tariff]) -> InlineKeyboardMarkup:
            text=f"{tariff.name} — {tariff.duration_days // 30} мес.",
            callback_data=f"admin_gift_confirm|{tariff.id}",
        )
-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="gifts").pack())
    builder.adjust(1)
    return builder.as_markup()

@@ -37,11 +37,8 @@ def build_gifts_list_kb(gifts: list[Gift], page: int, total: int) -> InlineKeybo
    row = []

    for i, gift in enumerate(gifts):
-        if gift.selected_months > 0:
-            duration_text = format_months(gift.selected_months)
-        else:
-            days = (gift.expiry_time.date() - gift.created_at.date()).days
-            duration_text = format_days(days)
+        days = (gift.expiry_time.date() - gift.created_at.date()).days
+        duration_text = format_days(days)

        button_text = f"{gift.gift_id[:6]}... — {duration_text}"

@@ -64,6 +61,6 @@ def build_gifts_list_kb(gifts: list[Gift], page: int, total: int) -> InlineKeybo
    if nav:
        builder.row(*nav)

-    builder.row(InlineKeyboardButton(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack()))
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=AdminPanelCallback(action="gifts").pack()))

    return builder.as_markup()
@@ -1,3 +1,14 @@
-__all__ = ("router",)
+from aiogram import Router

-from .management_handler import router
+
+router = Router()
+
+from . import (
+    admins,  # noqa: F401
+    database,  # noqa: F401
+    domain,  # noqa: F401
+    file_upload,  # noqa: F401
+    import_3xui,  # noqa: F401
+    import_remnawave,  # noqa: F401
+    maintenance,  # noqa: F401
+)
@@ -0,0 +1,154 @@
+import hashlib
+
+from asyncio import sleep
+
+from aiogram import F
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+from sqlalchemy import delete, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Admin
+from filters.admin import IsAdminFilter
+
+from . import router
+from .keyboard import (
+    AdminPanelCallback,
+    build_admin_back_kb_to_admins,
+    build_admins_kb,
+    build_role_selection_kb,
+    build_single_admin_menu,
+    build_token_result_kb,
+)
+
+
+class AdminState(StatesGroup):
+    waiting_for_tg_id = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "admins"), IsAdminFilter())
+async def show_admins(callback: CallbackQuery, session: AsyncSession):
+    result = await session.execute(select(Admin.tg_id, Admin.role))
+    admins = result.all()
+    await callback.message.edit_text("👑 <b>Список админов</b>", reply_markup=build_admins_kb(admins))
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "add_admin"), IsAdminFilter())
+async def prompt_new_admin(callback: CallbackQuery, state: FSMContext):
+    await callback.message.edit_text(
+        "Введите <code>tg_id</code> нового админа:", reply_markup=build_admin_back_kb_to_admins()
+    )
+    await state.set_state(AdminState.waiting_for_tg_id)
+
+
+@router.message(AdminState.waiting_for_tg_id, IsAdminFilter())
+async def save_new_admin(message: Message, session: AsyncSession, state: FSMContext):
+    try:
+        tg_id = int(message.text.strip())
+    except ValueError:
+        await message.answer("❌ Неверный формат. Введите числовой <code>tg_id</code>.")
+        return
+
+    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
+    if result.scalar_one_or_none():
+        await message.answer("⚠️ Такой админ уже существует.")
+    else:
+        session.add(Admin(tg_id=tg_id, role="moderator", description="Добавлен вручную"))
+        await session.commit()
+        await message.answer(f"✅ Админ <code>{tg_id}</code> добавлен.", reply_markup=build_admin_back_kb_to_admins())
+
+    await state.clear()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("admin_menu|")), IsAdminFilter())
+async def open_admin_menu(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
+    tg_id = int(callback_data.action.split("|")[1])
+
+    result = await session.execute(select(Admin.role).where(Admin.tg_id == tg_id))
+    admin = result.scalar_one_or_none()
+    role = admin or "moderator"
+
+    await callback.message.edit_text(
+        f"👤 <b>Управление админом</b> <code>{tg_id}</code>", reply_markup=build_single_admin_menu(tg_id, role)
+    )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("generate_token|")), IsAdminFilter())
+async def generate_token(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
+    tg_id = int(callback_data.action.split("|")[1])
+
+    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
+    admin = result.scalar_one_or_none()
+    if not admin:
+        await callback.message.edit_text("❌ Админ не найден.")
+        return
+
+    token = Admin.generate_token()
+    token_hash = hashlib.sha256(token.encode()).hexdigest()
+    admin.token = token_hash
+    await session.commit()
+
+    msg = await callback.message.edit_text(
+        f"🎟 <b>Новый токен для</b> <code>{tg_id}</code>:\n\n"
+        f"<code>{token}</code>\n\n"
+        f"⚠️ Это сообщение исчезнет через 5 минут.",
+        reply_markup=build_token_result_kb(token),
+    )
+
+    await sleep(300)
+    try:
+        await msg.delete()
+    except Exception:
+        pass
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("edit_role|")), IsAdminFilter())
+async def edit_admin_role(callback: CallbackQuery, callback_data: AdminPanelCallback):
+    tg_id = int(callback_data.action.split("|")[1])
+    await callback.message.edit_text(
+        f"✏ <b>Выберите новую роль для</b> <code>{tg_id}</code>:", reply_markup=build_role_selection_kb(tg_id)
+    )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("set_role|")), IsAdminFilter())
+async def set_admin_role(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
+    try:
+        _, tg_id_str, role = callback_data.action.split("|")
+        tg_id = int(tg_id_str)
+        if role not in ("superadmin", "moderator"):
+            raise ValueError
+    except Exception:
+        await callback.message.edit_text("❌ Неверный формат.")
+        return
+
+    if tg_id == callback.from_user.id:
+        await callback.message.edit_text(
+            "🚫 <b>Нельзя изменить свою собственную роль!</b>", reply_markup=build_single_admin_menu(tg_id)
+        )
+        return
+
+    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
+    admin = result.scalar_one_or_none()
+    if not admin:
+        await callback.message.edit_text("❌ Админ не найден.")
+        return
+
+    admin.role = role
+    await session.commit()
+
+    await callback.message.edit_text(
+        f"✅ Роль админа <code>{tg_id}</code> изменена на <b>{role}</b>.", reply_markup=build_single_admin_menu(tg_id)
+    )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("delete_admin|")), IsAdminFilter())
+async def delete_admin(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
+    tg_id = int(callback_data.action.split("|")[1])
+
+    await session.execute(delete(Admin).where(Admin.tg_id == tg_id))
+    await session.commit()
+
+    await callback.message.edit_text(
+        f"🗑 Админ <code>{tg_id}</code> удалён.", reply_markup=build_admin_back_kb_to_admins()
+    )
@@ -0,0 +1,169 @@
+import os
+import subprocess
+import sys
+import traceback
+
+from tempfile import NamedTemporaryFile
+
+from aiogram import Bot, F
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+
+from config import DB_NAME, DB_PASSWORD, DB_USER, PG_HOST, PG_PORT
+from filters.admin import IsAdminFilter
+from logger import logger
+
+from . import router
+from .keyboard import AdminPanelCallback, build_back_to_db_menu, build_database_kb, build_export_db_sources_kb
+
+
+class DatabaseState(StatesGroup):
+    waiting_for_backup_file = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "database"), IsAdminFilter())
+async def handle_database_menu(callback: CallbackQuery):
+    await callback.message.edit_text(
+        text="🗄 <b>Управление базой данных</b>",
+        reply_markup=build_database_kb(),
+    )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "restore_db"), IsAdminFilter())
+async def prompt_restore_db(callback: CallbackQuery, state: FSMContext):
+    await callback.message.edit_text(
+        "📂 Отправьте файл резервной копии (.sql), чтобы восстановить базу данных.\n"
+        "⚠️ Все текущие данные будут перезаписаны.",
+        reply_markup=build_back_to_db_menu(),
+    )
+    await state.set_state(DatabaseState.waiting_for_backup_file)
+
+
+@router.message(DatabaseState.waiting_for_backup_file, IsAdminFilter())
+async def restore_database(message: Message, state: FSMContext, bot: Bot):
+    document = message.document
+
+    if not document or not document.file_name.endswith(".sql"):
+        await message.answer("❌ Пожалуйста, отправьте файл с расширением .sql.")
+        return
+
+    try:
+        with NamedTemporaryFile(delete=False, suffix=".sql") as tmp_file:
+            tmp_path = tmp_file.name
+
+        await bot.download(document, destination=tmp_path)
+        logger.info(f"[Restore] Файл получен и сохранён: {tmp_path}")
+
+        is_custom_dump = False
+        with open(tmp_path, "rb") as f:
+            signature = f.read(5)
+            if signature == b"PGDMP":
+                is_custom_dump = True
+
+        subprocess.run(
+            [
+                "sudo",
+                "-u",
+                "postgres",
+                "psql",
+                "-d",
+                "postgres",
+                "-c",
+                f"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '{DB_NAME}' AND pid <> pg_backend_pid();",
+            ],
+            check=True,
+        )
+
+        subprocess.run(
+            ["sudo", "-u", "postgres", "psql", "-d", "postgres", "-c", f"DROP DATABASE IF EXISTS {DB_NAME};"],
+            check=True,
+        )
+
+        subprocess.run(
+            ["sudo", "-u", "postgres", "psql", "-d", "postgres", "-c", f"CREATE DATABASE {DB_NAME} OWNER {DB_USER};"],
+            check=True,
+        )
+
+        logger.info("[Restore] База данных пересоздана")
+
+        os.environ["PGPASSWORD"] = DB_PASSWORD
+
+        if is_custom_dump:
+            result = subprocess.run(
+                [
+                    "pg_restore",
+                    f"--dbname={DB_NAME}",
+                    "-U",
+                    DB_USER,
+                    "-h",
+                    PG_HOST,
+                    "-p",
+                    PG_PORT,
+                    "--no-owner",
+                    "--exit-on-error",
+                    tmp_path,
+                ],
+                capture_output=True,
+                text=True,
+            )
+        else:
+            result = subprocess.run(
+                [
+                    "psql",
+                    "-U",
+                    DB_USER,
+                    "-h",
+                    PG_HOST,
+                    "-p",
+                    PG_PORT,
+                    "-d",
+                    DB_NAME,
+                    "-f",
+                    tmp_path,
+                ],
+                capture_output=True,
+                text=True,
+            )
+
+        del os.environ["PGPASSWORD"]
+
+        if result.returncode != 0:
+            logger.error(f"[Restore] Ошибка восстановления: {result.stderr}")
+            await message.answer(
+                f"❌ Ошибка при восстановлении базы данных:\n<pre>{result.stderr}</pre>",
+            )
+            return
+
+        await message.answer(
+            "✅ База данных восстановлена.",
+            reply_markup=build_back_to_db_menu(),
+        )
+        logger.info("[Restore] Успешно восстановлено. Завершаем процесс для перезапуска.")
+        await state.clear()
+        sys.exit(0)
+
+    except Exception as e:
+        logger.exception(f"[Restore] Непредвиденная ошибка: {e}")
+        await message.answer(
+            f"❌ Произошла ошибка:\n<pre>{traceback.format_exc()}</pre>",
+        )
+    finally:
+        try:
+            os.remove(tmp_path)
+        except Exception:
+            pass
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "export_db"), IsAdminFilter())
+async def handle_export_db(callback: CallbackQuery):
+    await callback.message.edit_text(
+        "📤 Выберите панель, с которой требуется получить данные:\n\n"
+        "<i>Подтянутся подписки с панели и будут сохранены в базу данных бота.</i>",
+        reply_markup=build_export_db_sources_kb(),
+    )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "back_to_db_menu"), IsAdminFilter())
+async def back_to_database_menu(callback: CallbackQuery):
+    await callback.message.edit_text("📦 Управление базой данных:", reply_markup=build_database_kb())
@@ -0,0 +1,79 @@
+import re
+
+from aiogram import F
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+from sqlalchemy import func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Key
+from filters.admin import IsAdminFilter
+from logger import logger
+
+from ..panel.keyboard import build_admin_back_kb
+from . import router
+from .keyboard import AdminPanelCallback
+
+
+class AdminManagementStates(StatesGroup):
+    waiting_for_new_domain = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "change_domain"), IsAdminFilter())
+async def request_new_domain(callback_query: CallbackQuery, state: FSMContext):
+    await state.set_state(AdminManagementStates.waiting_for_new_domain)
+    await callback_query.message.edit_text(
+        text="🌐 Введите новый домен (без https://):\nПример: solobotdomen.ru",
+    )
+
+
+@router.message(AdminManagementStates.waiting_for_new_domain, IsAdminFilter())
+async def process_new_domain(message: Message, state: FSMContext, session: AsyncSession):
+    new_domain = message.text.strip()
+
+    if not re.fullmatch(r"[a-zA-Z0-9.-]+", new_domain) or " " in new_domain:
+        logger.warning("[DomainChange] Некорректный домен")
+        await message.answer(
+            "🚫 Некорректный домен! Введите домен без http:// и без пробелов.",
+            reply_markup=build_admin_back_kb("admin"),
+        )
+        return
+
+    new_domain_url = f"https://{new_domain}"
+
+    try:
+        stmt = (
+            update(Key)
+            .values(
+                key=func.regexp_replace(Key.key, r"^https://[^/]+", new_domain_url),
+                remnawave_link=func.regexp_replace(Key.remnawave_link, r"^https://[^/]+", new_domain_url),
+            )
+            .where(
+                (Key.key.startswith("https://") & ~Key.key.startswith(new_domain_url))
+                | (Key.remnawave_link.startswith("https://") & ~Key.remnawave_link.startswith(new_domain_url))
+            )
+        )
+        await session.execute(stmt)
+        await session.commit()
+        logger.info("[DomainChange] Запрос на обновление домена выполнен успешно.")
+    except Exception as e:
+        logger.error(f"[DomainChange] Ошибка при выполнении запроса: {e}")
+        await message.answer(
+            f"❌ Ошибка при обновлении домена: {e}",
+            reply_markup=build_admin_back_kb("admin"),
+        )
+        return
+
+    try:
+        sample = await session.execute(select(Key.key, Key.remnawave_link).limit(1))
+        example = sample.fetchone()
+        logger.info(f"[DomainChange] Пример обновленной записи: {example}")
+    except Exception as e:
+        logger.error(f"[DomainChange] Ошибка при выборке обновленной записи: {e}")
+
+    await message.answer(
+        f"✅ Домен успешно изменен на {new_domain}!",
+        reply_markup=build_admin_back_kb("admin"),
+    )
+    await state.clear()
@@ -0,0 +1,108 @@
+import os
+
+from aiogram import F
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from filters.admin import IsAdminFilter
+from logger import logger
+
+from ..panel.keyboard import build_admin_back_kb
+from . import router
+from .keyboard import AdminPanelCallback
+
+
+class FileUploadState(StatesGroup):
+    waiting_for_target = State()
+    waiting_for_file = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "upload_file"), IsAdminFilter())
+async def prompt_for_file_upload(callback: CallbackQuery, state: FSMContext):
+    text = (
+        "📤 <b>Загрузка файла</b>\n\n"
+        "Вы можете заменить файл в корневой директории бота или в папке <code>handlers</code>.\n\n"
+        "📁 Выберите директорию, а затем отправьте файл с таким же именем и расширением, "
+        "как у уже существующего файла. Он будет автоматически заменён."
+    )
+
+    back_kb = build_admin_back_kb("management")
+    kb = InlineKeyboardBuilder()
+    kb.button(text="📁 Корень бота", callback_data="upload_target:root")
+    kb.button(text="📂 Папка handlers", callback_data="upload_target:handlers")
+    for row in back_kb.inline_keyboard:
+        kb.row(*row)
+
+    await callback.message.edit_text(
+        text,
+        reply_markup=kb.as_markup(),
+    )
+    await state.set_state(FileUploadState.waiting_for_target)
+
+
+@router.callback_query(F.data.startswith("upload_target:"), FileUploadState.waiting_for_target, IsAdminFilter())
+async def select_upload_target(callback: CallbackQuery, state: FSMContext):
+    target = callback.data.split(":", 1)[1]
+    if target not in {"root", "handlers"}:
+        await callback.answer("Неизвестная директория.")
+        return
+
+    await state.update_data(upload_target=target)
+
+    target_text = "Корень бота" if target == "root" else "Папка handlers"
+    await callback.message.edit_text(
+        "📤 <b>Загрузка файла</b>\n\n"
+        f"Выбрана директория: <b>{target_text}</b>.\n\n"
+        "Теперь отправьте файл с таким же именем и расширением, как у уже существующего файла. "
+        "Он будет автоматически заменён.",
+        reply_markup=build_admin_back_kb("management"),
+    )
+    await state.set_state(FileUploadState.waiting_for_file)
+
+
+@router.message(FileUploadState.waiting_for_file, F.document, IsAdminFilter())
+async def handle_admin_file_upload(message: Message, state: FSMContext):
+    document = message.document
+    file_name = document.file_name
+
+    if not file_name or "." not in file_name:
+        await message.answer("❌ У файла должно быть имя с расширением.")
+        return
+
+    data = await state.get_data()
+    target = data.get("upload_target", "root")
+
+    if target == "handlers":
+        base_dir = os.path.abspath("./handlers")
+    else:
+        base_dir = os.path.abspath(".")
+
+    os.makedirs(base_dir, exist_ok=True)
+    dest_path = os.path.join(base_dir, file_name)
+
+    try:
+        await message.bot.download(document, destination=dest_path)
+
+        back_kb = build_admin_back_kb("management")
+        kb = InlineKeyboardBuilder()
+        kb.button(
+            text="🔁 Перезагрузить бота",
+            callback_data=AdminPanelCallback(action="restart").pack(),
+        )
+        for row in back_kb.inline_keyboard:
+            kb.row(*row)
+
+        await message.answer(
+            f"✅ Файл <code>{file_name}</code> успешно загружен и заменён в директории <code>{target}</code>.\n\n"
+            "🔄 <b>Перезагрузите бота, чтобы изменения вступили в силу.</b>",
+            reply_markup=kb.as_markup(),
+        )
+    except Exception as e:
+        logger.error(f"[Upload File] Ошибка при загрузке файла {file_name}: {e}")
+        await message.answer(
+            f"❌ Не удалось сохранить файл: {e}",
+            reply_markup=build_admin_back_kb("management"),
+        )
+    await state.clear()
@@ -0,0 +1,89 @@
+from aiogram import F
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from filters.admin import IsAdminFilter
+from database.models import Key
+from handlers.keys.operations import update_subscription
+from logger import logger
+
+from . import router
+from .keyboard import AdminPanelCallback, build_back_to_db_menu, build_post_import_kb
+
+
+class Import3xuiStates(StatesGroup):
+    waiting_for_file = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "request_3xui_file"), IsAdminFilter())
+async def prompt_for_3xui_file(callback: CallbackQuery, state: FSMContext):
+    await callback.message.edit_text(
+        "📂 Пришлите файл базы данных <code>x-ui.db</code> для восстановления подписок и клиентов.\n\n"
+        "Формат: SQLite-файл с таблицей <code>inbounds</code>.\n\n"
+        "<b>⚠️ Важно!</b> Убедитесь, что у всех подписок в панели прописан <code>telegram_id</code>.\n"
+        "После восстановления обязательно выполните <b>синхронизацию</b> с текущими серверами!",
+        reply_markup=build_back_to_db_menu(),
+    )
+    await state.set_state(Import3xuiStates.waiting_for_file)
+
+
+@router.message(Import3xuiStates.waiting_for_file, F.document, IsAdminFilter())
+async def handle_3xui_db_upload(message: Message, state: FSMContext, session: AsyncSession):
+    file = message.document
+
+    if not file.file_name.endswith(".db"):
+        await message.reply("❌ Пожалуйста, пришли файл с расширением .db")
+        return
+
+    file_path = f"/tmp/{file.file_name}"
+    await message.bot.download(file, destination=file_path)
+
+    processing_message = await message.reply("📥 Файл получен. Начинаю восстановление...")
+
+    try:
+        from database.importer import import_keys_from_3xui_db
+
+        imported, skipped = await import_keys_from_3xui_db(file_path, session)
+
+        await processing_message.edit_text(
+            f"✅ Восстановление завершено:\n"
+            f"🔐 Импортировано подписок: <b>{imported}</b>\n"
+            f"⏭ Пропущено (уже есть): <b>{skipped}</b>",
+            reply_markup=build_post_import_kb(),
+        )
+
+    except Exception as e:
+        logger.error(f"[Import 3x-ui] Ошибка: {e}")
+        await processing_message.edit_text(
+            "❌ Произошла ошибка при импорте. Убедись, что это валидный файл <code>x-ui.db</code>",
+            reply_markup=build_back_to_db_menu(),
+        )
+
+    await state.clear()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "resync_after_import"), IsAdminFilter())
+async def handle_resync_after_import(callback: CallbackQuery, session: AsyncSession):
+    await callback.answer("🔁 Начинаю перевыпуск подписок...")
+
+    result = await session.execute(select(Key.tg_id, Key.email))
+    keys = result.all()
+
+    success = 0
+    failed = 0
+
+    for tg_id, email in keys:
+        try:
+            await update_subscription(tg_id=tg_id, email=email, session=session)
+            success += 1
+        except Exception as e:
+            logger.error(f"[Resync] Ошибка при перевыпуске {email}: {e}")
+            failed += 1
+
+    await callback.message.edit_text(
+        f"🔁 Перевыпуск завершён:\n✅ Успешно: <b>{success}</b>\n❌ Ошибки: <b>{failed}</b>",
+        reply_markup=build_back_to_db_menu(),
+    )
@@ -0,0 +1,196 @@
+import json
+import re
+import time
+
+from datetime import datetime
+
+from aiogram import F
+from aiogram.types import CallbackQuery
+from dateutil import parser
+from sqlalchemy import select
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config import REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD
+from database.models import Key, Server, User
+from filters.admin import IsAdminFilter
+from logger import logger
+from panels.remnawave import RemnawaveAPI
+
+from . import router
+from .keyboard import AdminPanelCallback, build_back_to_db_menu
+
+
+def extract_tg_id_from_username(value: str | None) -> int | None:
+    if not value:
+        return None
+
+    value = value.strip()
+    match = re.search(r"_(\d+)(?:\D|$)", value)
+    if not match:
+        return None
+
+    tg_id = int(match.group(1))
+    if tg_id <= 0:
+        return None
+
+    return tg_id
+
+
+def extract_tg_id_from_user_payload(user: dict) -> int | None:
+    tg_id = user.get("telegramId")
+
+    if isinstance(tg_id, int):
+        if tg_id > 0:
+            return tg_id
+        return None
+
+    if isinstance(tg_id, str):
+        tg_id = tg_id.strip()
+        if tg_id.isdigit():
+            tg_id_int = int(tg_id)
+            return tg_id_int if tg_id_int > 0 else None
+
+    tg_id = extract_tg_id_from_username(user.get("username")) or extract_tg_id_from_username(user.get("email"))
+    return tg_id
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "export_remnawave"), IsAdminFilter())
+async def show_remnawave_clients(callback: CallbackQuery, session: AsyncSession):
+    result = await session.execute(select(Server).where(Server.panel_type == "remnawave", Server.enabled.is_(True)))
+    servers = result.scalars().all()
+
+    if not servers:
+        await callback.message.edit_text(
+            "❌ Нет доступных Remnawave-серверов.",
+            reply_markup=build_back_to_db_menu(),
+        )
+        return
+
+    server = servers[0]
+
+    api = RemnawaveAPI(base_url=server.api_url)
+
+    users = await api.get_all_users_time(
+        username=REMNAWAVE_LOGIN,
+        password=REMNAWAVE_PASSWORD,
+    )
+
+    if not users:
+        await callback.message.edit_text(
+            "📭 На панели нет клиентов.",
+            reply_markup=build_back_to_db_menu(),
+        )
+        return
+
+    logger.warning(f"[Remnawave Export] Пример ответа:\n{json.dumps(users[:3], indent=2, ensure_ascii=False)}")
+
+    added_users = await import_remnawave_users(session, users)
+
+    server_id = server.cluster_name or server.server_name
+
+    added_keys = await import_remnawave_keys(session, users, server_id=server_id)
+
+    preview = ""
+    for i, user in enumerate(users[:3], 1):
+        email = user.get("email") or user.get("username") or "-"
+        expire = (user.get("expireAt") or "")[:10]
+        preview += f"{i}. {email} — до {expire}\n"
+
+    await callback.message.edit_text(
+        f"📄 Найдено клиентов: <b>{len(users)}</b>\n"
+        f"👤 Импортировано пользователей: <b>{added_users}</b>\n"
+        f"🔐 Импортировано ключей: <b>{added_keys}</b>\n\n"
+        f"<b>Первые 3:</b>\n{preview}",
+        reply_markup=build_back_to_db_menu(),
+    )
+
+
+async def import_remnawave_users(session: AsyncSession, users: list[dict]) -> int:
+    added = 0
+
+    for user in users:
+        tg_id = extract_tg_id_from_user_payload(user)
+        if not tg_id:
+            continue
+
+        exists = await session.execute(select(User).where(User.tg_id == tg_id))
+        if exists.scalar():
+            continue
+
+        try:
+            new_user = User(
+                tg_id=tg_id,
+                username=None,
+                first_name=None,
+                last_name=None,
+                language_code=None,
+                is_bot=False,
+                balance=0.0,
+                trial=1,
+                source_code=None,
+                created_at=datetime.utcnow(),
+                updated_at=datetime.utcnow(),
+            )
+            session.add(new_user)
+            added += 1
+
+        except SQLAlchemyError as e:
+            logger.error(f"[Remnawave Import] Ошибка при добавлении пользователя {tg_id}: {e}")
+            continue
+
+    await session.commit()
+    return added
+
+
+async def import_remnawave_keys(session: AsyncSession, users: list[dict], server_id: str) -> int:
+    added = 0
+
+    for user in users:
+        tg_id = extract_tg_id_from_user_payload(user)
+
+        client_id = user.get("uuid")
+        email = user.get("email") or user.get("username")
+        remnawave_link = user.get("subscriptionUrl")
+        expire_at = user.get("expireAt")
+        created_at = user.get("createdAt")
+
+        if not tg_id or not client_id:
+            logger.warning(f"[SKIP] Пропущен клиент: tg_id={tg_id}, client_id={client_id}")
+            continue
+
+        exists_stmt = await session.execute(select(Key).where(Key.client_id == client_id))
+        if exists_stmt.scalar():
+            logger.info(f"[SKIP] Ключ уже существует: {client_id}")
+            continue
+
+        try:
+            created_ts = int(parser.isoparse(created_at).timestamp() * 1000) if created_at else int(time.time() * 1000)
+            expire_ts = int(parser.isoparse(expire_at).timestamp() * 1000) if expire_at else int(time.time() * 1000)
+
+            new_key = Key(
+                tg_id=tg_id,
+                client_id=client_id,
+                email=email,
+                created_at=created_ts,
+                expiry_time=expire_ts,
+                key="",
+                server_id=server_id,
+                remnawave_link=remnawave_link,
+                tariff_id=None,
+                is_frozen=False,
+                alias=None,
+                notified=False,
+                notified_24h=False,
+            )
+            session.add(new_key)
+            added += 1
+
+            logger.info(f"[ADD] Ключ добавлен: {client_id}, до {expire_at}, email={email}, server_id={server_id}")
+
+        except Exception as e:
+            logger.error(f"[ERROR] Ошибка при добавлении ключа {client_id}: {e}")
+
+    await session.commit()
+    logger.info(f"[IMPORT] Всего добавлено ключей: {added}")
+    return added
@@ -1,7 +1,8 @@
 from aiogram.types import InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder

-from middlewares import maintenance
+from core.bootstrap import MANAGEMENT_CONFIG
+from handlers.buttons import BACK

 from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn

@@ -39,7 +40,9 @@ def build_management_kb(admin_role: str) -> InlineKeyboardMarkup:
        text="📤 Загрузить файл",
        callback_data=AdminPanelCallback(action="upload_file").pack(),
    )
-    maintenance_text = "🛠️ Выключить тех. работы" if maintenance.maintenance_mode else "🛠️ Включить тех. работы"
+
+    maintenance_enabled = bool(MANAGEMENT_CONFIG.get("MAINTENANCE_ENABLED", False))
+    maintenance_text = "🛠️ Выключить тех. работы" if maintenance_enabled else "🛠️ Включить тех. работы"
    builder.button(
        text=maintenance_text,
        callback_data=AdminPanelCallback(action="toggle_maintenance").pack(),
@@ -72,7 +75,8 @@ def build_database_kb() -> InlineKeyboardMarkup:

 def build_back_to_db_menu() -> InlineKeyboardMarkup:
    builder = InlineKeyboardBuilder()
-    builder.button(text="⬅️ Назад", callback_data=AdminPanelCallback(action="database").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="back_to_db_menu").pack())
+    builder.adjust(1)
    return builder.as_markup()


@@ -81,7 +85,7 @@ def build_export_db_sources_kb() -> InlineKeyboardMarkup:

    builder.button(text="🌀 Remnawave", callback_data=AdminPanelCallback(action="export_remnawave").pack())
    builder.button(text="🧩 3x-ui", callback_data=AdminPanelCallback(action="request_3xui_file").pack())
-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="back_to_db_menu").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="back_to_db_menu").pack())

    builder.adjust(1)
    return builder.as_markup()
@@ -105,7 +109,6 @@ def build_single_admin_menu(tg_id: int, role: str = "moderator") -> InlineKeyboa
    builder = InlineKeyboardBuilder()

    builder.button(text="✏ Изменить роль", callback_data=AdminPanelCallback(action=f"edit_role|{tg_id}").pack())
-
    builder.button(text="🗑 Удалить админа", callback_data=AdminPanelCallback(action=f"delete_admin|{tg_id}").pack())

    if role == "superadmin":
@@ -113,7 +116,7 @@ def build_single_admin_menu(tg_id: int, role: str = "moderator") -> InlineKeyboa
            text="🎟 Выпустить токен", callback_data=AdminPanelCallback(action=f"generate_token|{tg_id}").pack()
        )

-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="admins").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="admins").pack())

    builder.adjust(1)
    return builder.as_markup()
@@ -123,14 +126,14 @@ def build_role_selection_kb(tg_id: int) -> InlineKeyboardMarkup:
    builder = InlineKeyboardBuilder()
    builder.button(text="👑 superadmin", callback_data=AdminPanelCallback(action=f"set_role|{tg_id}|superadmin").pack())
    builder.button(text="🛡 moderator", callback_data=AdminPanelCallback(action=f"set_role|{tg_id}|moderator").pack())
-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action=f"admin_menu|{tg_id}").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action=f"admin_menu|{tg_id}").pack())
    builder.adjust(1)
    return builder.as_markup()


 def build_admin_back_kb_to_admins() -> InlineKeyboardMarkup:
    builder = InlineKeyboardBuilder()
-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="admins").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="admins").pack())
    builder.adjust(1)
    return builder.as_markup()

@@ -138,24 +141,16 @@ def build_admin_back_kb_to_admins() -> InlineKeyboardMarkup:
 def build_token_result_kb(token: str) -> InlineKeyboardMarkup:
    builder = InlineKeyboardBuilder()
    builder.button(text="📋 Скопировать токен", switch_inline_query_current_chat=token)
-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="admins").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="admins").pack())
    builder.adjust(1)
    return builder.as_markup()


-def build_back_to_db_menu() -> InlineKeyboardMarkup:
-    builder = InlineKeyboardBuilder()
-
-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="back_to_db_menu").pack())
-
-    return builder.as_markup()
-
-
 def build_post_import_kb() -> InlineKeyboardMarkup:
    builder = InlineKeyboardBuilder()
    builder.button(
        text="🔁 Перевыпустить подписки", callback_data=AdminPanelCallback(action="resync_after_import").pack()
    )
-    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="back_to_db_menu").pack())
+    builder.button(text=BACK, callback_data=AdminPanelCallback(action="back_to_db_menu").pack())
    builder.adjust(1)
    return builder.as_markup()
@@ -0,0 +1,52 @@
+from aiogram import F
+from aiogram.types import CallbackQuery
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from core.bootstrap import MANAGEMENT_CONFIG, update_management_config
+from database.models import Admin
+from filters.admin import IsAdminFilter
+
+from . import router
+from .keyboard import AdminPanelCallback, build_management_kb
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "management"), IsAdminFilter())
+async def handle_management(callback_query: CallbackQuery, session: AsyncSession):
+    tg_id = callback_query.from_user.id
+
+    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
+    admin = result.scalar_one_or_none()
+
+    if not admin:
+        await callback_query.message.edit_text("❌ Вы не зарегистрированы как администратор.")
+        return
+
+    await callback_query.message.edit_text(
+        text="🤖 Управление ботом",
+        reply_markup=build_management_kb(admin.role),
+    )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "toggle_maintenance"), IsAdminFilter())
+async def toggle_maintenance_mode(callback: CallbackQuery, session: AsyncSession):
+    tg_id = callback.from_user.id
+
+    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
+    admin = result.scalar_one_or_none()
+
+    if not admin:
+        await callback.answer("❌ Админ не найден.", show_alert=True)
+        return
+
+    current_config = dict(MANAGEMENT_CONFIG)
+    current_value = bool(current_config.get("MAINTENANCE_ENABLED", False))
+    new_value = not current_value
+    current_config["MAINTENANCE_ENABLED"] = new_value
+
+    await update_management_config(session, current_config)
+
+    new_status = "включён" if new_value else "выключен"
+    await callback.answer(f"🛠️ Режим обслуживания {new_status}.", show_alert=True)
+
+    await callback.message.edit_reply_markup(reply_markup=build_management_kb(admin.role))
@@ -1,688 +0,0 @@
-import hashlib
-import json
-import os
-import subprocess
-import sys
-import time
-import traceback
-
-from asyncio import sleep
-from datetime import datetime
-from tempfile import NamedTemporaryFile
-
-from aiogram import Bot, F, Router
-from aiogram.fsm.context import FSMContext
-from aiogram.fsm.state import State, StatesGroup
-from aiogram.types import CallbackQuery, Message
-from dateutil import parser
-from sqlalchemy import delete, func, select, update
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from config import DB_NAME, DB_PASSWORD, DB_USER, PG_HOST, PG_PORT, REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD
-from database.models import Admin, Key, Server, User
-from filters.admin import IsAdminFilter
-from handlers.keys.key_utils import update_subscription
-from logger import logger
-from middlewares import maintenance
-from panels.remnawave import RemnawaveAPI
-
-from ..panel.keyboard import build_admin_back_kb
-from .keyboard import (
-    AdminPanelCallback,
-    build_admin_back_kb_to_admins,
-    build_admins_kb,
-    build_back_to_db_menu,
-    build_database_kb,
-    build_export_db_sources_kb,
-    build_management_kb,
-    build_post_import_kb,
-    build_role_selection_kb,
-    build_single_admin_menu,
-    build_token_result_kb,
-)
-
-
-router = Router()
-
-
-class AdminManagementStates(StatesGroup):
-    waiting_for_new_domain = State()
-
-
-class Import3xuiStates(StatesGroup):
-    waiting_for_file = State()
-
-
-class FileUploadState(StatesGroup):
-    waiting_for_file = State()
-
-
-class DatabaseState(StatesGroup):
-    waiting_for_backup_file = State()
-
-
-class AdminState(StatesGroup):
-    waiting_for_tg_id = State()
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "management"), IsAdminFilter())
-async def handle_management(callback_query: CallbackQuery, session: AsyncSession):
-    tg_id = callback_query.from_user.id
-
-    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
-    admin = result.scalar_one_or_none()
-
-    if not admin:
-        await callback_query.message.edit_text("❌ Вы не зарегистрированы как администратор.")
-        return
-
-    await callback_query.message.edit_text(
-        text="🤖 Управление ботом",
-        reply_markup=build_management_kb(admin.role),
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "change_domain"), IsAdminFilter())
-async def request_new_domain(callback_query: CallbackQuery, state: FSMContext):
-    """Запрашивает у администратора новый домен."""
-    await state.set_state(AdminManagementStates.waiting_for_new_domain)
-    await callback_query.message.edit_text(
-        text="🌐 Введите новый домен (без https://):\nПример: solobotdomen.ru",
-    )
-
-
-@router.message(AdminManagementStates.waiting_for_new_domain)
-async def process_new_domain(message: Message, state: FSMContext, session: AsyncSession):
-    """Обновляет домен в таблице keys."""
-    new_domain = message.text.strip()
-
-    if not new_domain or " " in new_domain or not new_domain.replace(".", "").isalnum():
-        logger.warning("[DomainChange] Некорректный домен")
-        await message.answer(
-            "🚫 Некорректный домен! Введите домен без http:// и без пробелов.",
-            reply_markup=build_admin_back_kb("admin"),
-        )
-        return
-
-    new_domain_url = f"https://{new_domain}"
-
-    try:
-        stmt = (
-            update(Key)
-            .values(
-                key=func.regexp_replace(Key.key, r"^https://[^/]+", new_domain_url),
-                remnawave_link=func.regexp_replace(Key.remnawave_link, r"^https://[^/]+", new_domain_url),
-            )
-            .where(
-                (Key.key.startswith("https://") & ~Key.key.startswith(new_domain_url))
-                | (Key.remnawave_link.startswith("https://") & ~Key.remnawave_link.startswith(new_domain_url))
-            )
-        )
-        await session.execute(stmt)
-        await session.commit()
-        logger.info("[DomainChange] Запрос на обновление домена выполнен успешно.")
-    except Exception as e:
-        logger.error(f"[DomainChange] Ошибка при выполнении запроса: {e}")
-        await message.answer(
-            f"❌ Ошибка при обновлении домена: {e}",
-            reply_markup=build_admin_back_kb("admin"),
-        )
-        return
-
-    try:
-        sample = await session.execute(select(Key.key, Key.remnawave_link).limit(1))
-        example = sample.fetchone()
-        logger.info(f"[DomainChange] Пример обновленной записи: {example}")
-    except Exception as e:
-        logger.error(f"[DomainChange] Ошибка при выборке обновленной записи: {e}")
-
-    await message.answer(
-        f"✅ Домен успешно изменен на {new_domain}!",
-        reply_markup=build_admin_back_kb("admin"),
-    )
-    await state.clear()
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "toggle_maintenance"))
-async def toggle_maintenance_mode(callback: CallbackQuery, session: AsyncSession):
-    tg_id = callback.from_user.id
-
-    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
-    admin = result.scalar_one_or_none()
-
-    if not admin:
-        await callback.answer("❌ Админ не найден.", show_alert=True)
-        return
-
-    maintenance.maintenance_mode = not maintenance.maintenance_mode
-    new_status = "включён" if maintenance.maintenance_mode else "выключен"
-    await callback.answer(f"🛠️ Режим обслуживания {new_status}.", show_alert=True)
-
-    await callback.message.edit_reply_markup(reply_markup=build_management_kb(admin.role))
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "admins"))
-async def show_admins(callback: CallbackQuery, session: AsyncSession):
-    result = await session.execute(select(Admin.tg_id, Admin.role))
-    admins = result.all()
-    await callback.message.edit_text("👑 <b>Список админов</b>", reply_markup=build_admins_kb(admins))
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "add_admin"))
-async def prompt_new_admin(callback: CallbackQuery, state: FSMContext):
-    await callback.message.edit_text(
-        "Введите <code>tg_id</code> нового админа:", reply_markup=build_admin_back_kb_to_admins()
-    )
-    await state.set_state(AdminState.waiting_for_tg_id)
-
-
-@router.message(AdminState.waiting_for_tg_id)
-async def save_new_admin(message: Message, session: AsyncSession, state: FSMContext):
-    try:
-        tg_id = int(message.text.strip())
-    except ValueError:
-        await message.answer("❌ Неверный формат. Введите числовой <code>tg_id</code>.")
-        return
-
-    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
-    if result.scalar_one_or_none():
-        await message.answer("⚠️ Такой админ уже существует.")
-    else:
-        session.add(Admin(tg_id=tg_id, role="moderator", description="Добавлен вручную"))
-        await session.commit()
-        await message.answer(f"✅ Админ <code>{tg_id}</code> добавлен.", reply_markup=build_admin_back_kb_to_admins())
-
-    await state.clear()
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action.startswith("admin_menu|")))
-async def open_admin_menu(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
-    tg_id = int(callback_data.action.split("|")[1])
-
-    result = await session.execute(select(Admin.role).where(Admin.tg_id == tg_id))
-    admin = result.scalar_one_or_none()
-    role = admin or "moderator"
-
-    await callback.message.edit_text(
-        f"👤 <b>Управление админом</b> <code>{tg_id}</code>", reply_markup=build_single_admin_menu(tg_id, role)
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action.startswith("generate_token|")))
-async def generate_token(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
-    tg_id = int(callback_data.action.split("|")[1])
-
-    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
-    admin = result.scalar_one_or_none()
-    if not admin:
-        await callback.message.edit_text("❌ Админ не найден.")
-        return
-
-    token = Admin.generate_token()
-    token_hash = hashlib.sha256(token.encode()).hexdigest()
-    admin.token = token_hash
-    await session.commit()
-
-    msg = await callback.message.edit_text(
-        f"🎟 <b>Новый токен для</b> <code>{tg_id}</code>:\n\n"
-        f"<code>{token}</code>\n\n"
-        f"⚠️ Это сообщение исчезнет через 5 минут.",
-        reply_markup=build_token_result_kb(token),
-    )
-
-    await sleep(300)
-    try:
-        await msg.delete()
-    except Exception:
-        pass
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action.startswith("edit_role|")))
-async def edit_admin_role(callback: CallbackQuery, callback_data: AdminPanelCallback):
-    tg_id = int(callback_data.action.split("|")[1])
-    await callback.message.edit_text(
-        f"✏ <b>Выберите новую роль для</b> <code>{tg_id}</code>:", reply_markup=build_role_selection_kb(tg_id)
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action.startswith("set_role|")))
-async def set_admin_role(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
-    try:
-        _, tg_id_str, role = callback_data.action.split("|")
-        tg_id = int(tg_id_str)
-        if role not in ("superadmin", "moderator"):
-            raise ValueError
-    except Exception:
-        await callback.message.edit_text("❌ Неверный формат.")
-        return
-
-    if tg_id == callback.from_user.id:
-        await callback.message.edit_text(
-            "🚫 <b>Нельзя изменить свою собственную роль!</b>", reply_markup=build_single_admin_menu(tg_id)
-        )
-        return
-
-    result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
-    admin = result.scalar_one_or_none()
-    if not admin:
-        await callback.message.edit_text("❌ Админ не найден.")
-        return
-
-    admin.role = role
-    await session.commit()
-
-    await callback.message.edit_text(
-        f"✅ Роль админа <code>{tg_id}</code> изменена на <b>{role}</b>.", reply_markup=build_single_admin_menu(tg_id)
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action.startswith("delete_admin|")))
-async def delete_admin(callback: CallbackQuery, callback_data: AdminPanelCallback, session: AsyncSession):
-    tg_id = int(callback_data.action.split("|")[1])
-
-    await session.execute(delete(Admin).where(Admin.tg_id == tg_id))
-    await session.commit()
-
-    await callback.message.edit_text(
-        f"🗑 Админ <code>{tg_id}</code> удалён.", reply_markup=build_admin_back_kb_to_admins()
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "database"))
-async def handle_database_menu(callback: CallbackQuery):
-    await callback.message.edit_text(
-        text="🗄 <b>Управление базой данных</b>",
-        reply_markup=build_database_kb(),
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "restore_db"))
-async def prompt_restore_db(callback: CallbackQuery, state: FSMContext):
-    await callback.message.edit_text(
-        "📂 Отправьте файл резервной копии (.sql), чтобы восстановить базу данных.\n"
-        "⚠️ Все текущие данные будут перезаписаны.",
-        reply_markup=build_back_to_db_menu(),
-    )
-    await state.set_state(DatabaseState.waiting_for_backup_file)
-
-
-@router.message(DatabaseState.waiting_for_backup_file)
-async def restore_database(message: Message, state: FSMContext, bot: Bot):
-    document = message.document
-
-    if not document or not document.file_name.endswith(".sql"):
-        await message.answer("❌ Пожалуйста, отправьте файл с расширением .sql.")
-        return
-
-    try:
-        with NamedTemporaryFile(delete=False, suffix=".sql") as tmp_file:
-            tmp_path = tmp_file.name
-
-        await bot.download(document, destination=tmp_path)
-        logger.info(f"[Restore] Файл получен и сохранён: {tmp_path}")
-
-        is_custom_dump = False
-        with open(tmp_path, "rb") as f:
-            signature = f.read(5)
-            if signature == b"PGDMP":
-                is_custom_dump = True
-
-        subprocess.run(
-            [
-                "sudo",
-                "-u",
-                "postgres",
-                "psql",
-                "-d",
-                "postgres",
-                "-c",
-                f"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '{DB_NAME}' AND pid <> pg_backend_pid();",
-            ],
-            check=True,
-        )
-
-        subprocess.run(
-            ["sudo", "-u", "postgres", "psql", "-d", "postgres", "-c", f"DROP DATABASE IF EXISTS {DB_NAME};"],
-            check=True,
-        )
-
-        subprocess.run(
-            ["sudo", "-u", "postgres", "psql", "-d", "postgres", "-c", f"CREATE DATABASE {DB_NAME} OWNER {DB_USER};"],
-            check=True,
-        )
-
-        logger.info("[Restore] База данных пересоздана")
-
-        os.environ["PGPASSWORD"] = DB_PASSWORD
-
-        if is_custom_dump:
-            result = subprocess.run(
-                [
-                    "pg_restore",
-                    f"--dbname={DB_NAME}",
-                    "-U",
-                    DB_USER,
-                    "-h",
-                    PG_HOST,
-                    "-p",
-                    PG_PORT,
-                    "--no-owner",
-                    "--exit-on-error",
-                    tmp_path,
-                ],
-                capture_output=True,
-                text=True,
-            )
-        else:
-            result = subprocess.run(
-                [
-                    "psql",
-                    "-U",
-                    DB_USER,
-                    "-h",
-                    PG_HOST,
-                    "-p",
-                    PG_PORT,
-                    "-d",
-                    DB_NAME,
-                    "-f",
-                    tmp_path,
-                ],
-                capture_output=True,
-                text=True,
-            )
-
-        del os.environ["PGPASSWORD"]
-
-        if result.returncode != 0:
-            logger.error(f"[Restore] Ошибка восстановления: {result.stderr}")
-            await message.answer(
-                f"❌ Ошибка при восстановлении базы данных:\n<pre>{result.stderr}</pre>",
-            )
-            return
-
-        await message.answer(
-            "✅ База данных восстановлена.",
-            reply_markup=build_back_to_db_menu(),
-        )
-        logger.info("[Restore] Успешно восстановлено. Завершаем процесс для перезапуска.")
-        await state.clear()
-        sys.exit(0)
-
-    except Exception as e:
-        logger.exception(f"[Restore] Непредвиденная ошибка: {e}")
-        await message.answer(
-            f"❌ Произошла ошибка:\n<pre>{traceback.format_exc()}</pre>",
-        )
-    finally:
-        try:
-            os.remove(tmp_path)
-        except Exception:
-            pass
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "export_db"))
-async def handle_export_db(callback: CallbackQuery):
-    await callback.message.edit_text(
-        "📤 Выберите панель, с которой требуется получить данные:\n\n"
-        "<i>Подтянутся подписки с панели и будут сохранены в базу данных бота.</i>",
-        reply_markup=build_export_db_sources_kb(),
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "back_to_db_menu"))
-async def back_to_database_menu(callback: CallbackQuery):
-    await callback.message.edit_text("📦 Управление базой данных:", reply_markup=build_database_kb())
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "export_remnawave"))
-async def show_remnawave_clients(callback: CallbackQuery, session: AsyncSession):
-    await callback.answer()
-
-    result = await session.execute(select(Server).where(Server.panel_type == "remnawave", Server.enabled.is_(True)))
-    servers = result.scalars().all()
-
-    if not servers:
-        await callback.message.edit_text(
-            "❌ Нет доступных Remnawave-серверов.",
-            reply_markup=build_back_to_db_menu(),
-        )
-        return
-
-    server = servers[0]
-
-    api = RemnawaveAPI(base_url=server.api_url)
-
-    users = await api.get_all_users_time(
-        username=REMNAWAVE_LOGIN,
-        password=REMNAWAVE_PASSWORD,
-    )
-
-    if not users:
-        await callback.message.edit_text(
-            "📭 На панели нет клиентов.",
-            reply_markup=build_back_to_db_menu(),
-        )
-        return
-
-    logger.warning(f"[Remnawave Export] Пример ответа:\n{json.dumps(users[:3], indent=2, ensure_ascii=False)}")
-
-    added_users = await import_remnawave_users(session, users)
-
-    server_id = server.cluster_name or server.server_name
-
-    added_keys = await import_remnawave_keys(session, users, server_id=server_id)
-
-    preview = ""
-    for i, user in enumerate(users[:3], 1):
-        email = user.get("email") or user.get("username") or "-"
-        expire = user.get("expireAt", "")[:10]
-        preview += f"{i}. {email} — до {expire}\n"
-
-    await callback.message.edit_text(
-        f"📄 Найдено клиентов: <b>{len(users)}</b>\n"
-        f"👤 Импортировано пользователей: <b>{added_users}</b>\n"
-        f"🔐 Импортировано ключей: <b>{added_keys}</b>\n\n"
-        f"<b>Первые 3:</b>\n{preview}",
-        reply_markup=build_back_to_db_menu(),
-    )
-
-
-async def import_remnawave_users(session: AsyncSession, users: list[dict]) -> int:
-    added = 0
-
-    for user in users:
-        tg_id = user.get("telegramId")
-        if not tg_id:
-            continue
-
-        exists = await session.execute(select(User).where(User.tg_id == tg_id))
-        if exists.scalar():
-            continue
-
-        try:
-            new_user = User(
-                tg_id=tg_id,
-                username=None,
-                first_name=None,
-                last_name=None,
-                language_code=None,
-                is_bot=False,
-                balance=0.0,
-                trial=1,
-                source_code=None,
-                created_at=datetime.utcnow(),
-                updated_at=datetime.utcnow(),
-            )
-            session.add(new_user)
-            added += 1
-
-        except SQLAlchemyError as e:
-            logger.error(f"[Remnawave Import] Ошибка при добавлении пользователя {tg_id}: {e}")
-            continue
-
-    await session.commit()
-    return added
-
-
-async def import_remnawave_keys(session: AsyncSession, users: list[dict], server_id: str) -> int:
-    added = 0
-
-    for user in users:
-        tg_id = user.get("telegramId")
-        client_id = user.get("uuid")
-        email = user.get("email") or user.get("username")
-        remnawave_link = user.get("subscriptionUrl")
-        expire_at = user.get("expireAt")
-        created_at = user.get("createdAt")
-
-        if not tg_id or not client_id:
-            logger.warning(f"[SKIP] Пропущен клиент: tg_id={tg_id}, client_id={client_id}")
-            continue
-
-        exists_stmt = await session.execute(select(Key).where(Key.client_id == client_id))
-        if exists_stmt.scalar():
-            logger.info(f"[SKIP] Ключ уже существует: {client_id}")
-            continue
-
-        try:
-            created_ts = int(parser.isoparse(created_at).timestamp() * 1000) if created_at else int(time.time() * 1000)
-            expire_ts = int(parser.isoparse(expire_at).timestamp() * 1000) if expire_at else int(time.time() * 1000)
-
-            new_key = Key(
-                tg_id=tg_id,
-                client_id=client_id,
-                email=email,
-                created_at=created_ts,
-                expiry_time=expire_ts,
-                key="",
-                server_id=server_id,
-                remnawave_link=remnawave_link,
-                tariff_id=None,
-                is_frozen=False,
-                alias=None,
-                notified=False,
-                notified_24h=False,
-            )
-            session.add(new_key)
-            added += 1
-
-            logger.info(f"[ADD] Ключ добавлен: {client_id}, до {expire_at}, email={email}, server_id={server_id}")
-
-        except Exception as e:
-            logger.error(f"[ERROR] Ошибка при добавлении ключа {client_id}: {e}")
-
-    await session.commit()
-    logger.info(f"[IMPORT] Всего добавлено ключей: {added}")
-    return added
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "request_3xui_file"))
-async def prompt_for_3xui_file(callback: CallbackQuery, state: FSMContext):
-    await callback.message.edit_text(
-        "📂 Пришлите файл базы данных <code>x-ui.db</code> для восстановления подписок и клиентов.\n\n"
-        "Формат: SQLite-файл с таблицей <code>inbounds</code>.\n\n"
-        "<b>⚠️ Важно!</b> Убедитесь, что у всех подписок в панели прописан <code>telegram_id</code>.\n"
-        "После восстановления обязательно выполните <b>синхронизацию</b> с текущими серверами!",
-        reply_markup=build_back_to_db_menu(),
-    )
-    await state.set_state(Import3xuiStates.waiting_for_file)
-
-
-@router.message(Import3xuiStates.waiting_for_file, F.document)
-async def handle_3xui_db_upload(message: Message, state: FSMContext, session: AsyncSession):
-    file = message.document
-
-    if not file.file_name.endswith(".db"):
-        await message.reply("❌ Пожалуйста, пришли файл с расширением .db")
-        return
-
-    file_path = f"/tmp/{file.file_name}"
-    await message.bot.download(file, destination=file_path)
-
-    processing_message = await message.reply("📥 Файл получен. Начинаю восстановление...")
-
-    try:
-        from database.importer import import_keys_from_3xui_db
-
-        imported, skipped = await import_keys_from_3xui_db(file_path, session)
-
-        await processing_message.edit_text(
-            f"✅ Восстановление завершено:\n"
-            f"🔐 Импортировано подписок: <b>{imported}</b>\n"
-            f"⏭ Пропущено (уже есть): <b>{skipped}</b>",
-            reply_markup=build_post_import_kb(),
-        )
-
-    except Exception as e:
-        logger.error(f"[Import 3x-ui] Ошибка: {e}")
-        await processing_message.edit_text(
-            "❌ Произошла ошибка при импорте. Убедись, что это валидный файл <code>x-ui.db</code>",
-            reply_markup=build_back_to_db_menu(),
-        )
-
-    await state.clear()
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "resync_after_import"))
-async def handle_resync_after_import(callback: CallbackQuery, session: AsyncSession):
-    await callback.answer("🔁 Начинаю перевыпуск подписок...")
-
-    result = await session.execute(select(Key.tg_id, Key.email))
-    keys = result.all()
-
-    success = 0
-    failed = 0
-
-    for tg_id, email in keys:
-        try:
-            await update_subscription(tg_id=tg_id, email=email, session=session)
-            success += 1
-        except Exception as e:
-            logger.error(f"[Resync] Ошибка при перевыпуске {email}: {e}")
-            failed += 1
-
-    await callback.message.edit_text(
-        f"🔁 Перевыпуск завершён:\n✅ Успешно: <b>{success}</b>\n❌ Ошибки: <b>{failed}</b>",
-        reply_markup=build_back_to_db_menu(),
-    )
-
-
-@router.callback_query(AdminPanelCallback.filter(F.action == "upload_file"))
-async def prompt_for_file_upload(callback: CallbackQuery, state: FSMContext):
-    await callback.message.edit_text(
-        "📤 <b>Загрузка файла</b>\n\n"
-        "Вы можете заменить файл в корневой директории бота.\n\n"
-        "📁 <b>Отправьте файл с таким же именем и расширением</b>, "
-        "как у уже существующего файла. Он будет автоматически заменён.",
-        reply_markup=build_admin_back_kb("management"),
-    )
-    await state.set_state(FileUploadState.waiting_for_file)
-
-
-@router.message(FileUploadState.waiting_for_file, F.document)
-async def handle_admin_file_upload(message: Message, state: FSMContext):
-    document = message.document
-    file_name = document.file_name
-
-    if not file_name or "." not in file_name:
-        await message.answer("❌ У файла должно быть имя с расширением.")
-        return
-
-    dest_path = os.path.abspath(f"./{file_name}")
-
-    try:
-        await message.bot.download(document, destination=dest_path)
-        await message.answer(
-            f"✅ Файл <code>{file_name}</code> успешно загружен и заменён.\n\n"
-            "🔄 <b>Перезагрузите бота, чтобы изменения вступили в силу.</b>",
-            reply_markup=build_admin_back_kb("management"),
-        )
-    except Exception as e:
-        logger.error(f"[Upload File] Ошибка при загрузке файла {file_name}: {e}")
-        await message.answer(
-            f"❌ Не удалось сохранить файл: {e}",
-            reply_markup=build_admin_back_kb("management"),
-        )
-    await state.clear()
@@ -0,0 +1,3 @@
+__all__ = ("router",)
+
+from .module_handler import router
@@ -0,0 +1,103 @@
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from handlers.admin.panel.keyboard import AdminPanelCallback
+from handlers.buttons import BACK
+from utils.modules_manager import manager
+
+
+def build_modules_kb(page: int, total_pages: int, items: list[tuple[str, str | None]]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    row_buf = []
+    for name, _ in items:
+        label = name if manager.is_enabled(name) else f"{name} (off)"
+        row_buf.append(
+            InlineKeyboardButton(
+                text=label,
+                callback_data=AdminPanelCallback(action=f"module__{name}", page=page).pack(),
+            )
+        )
+        if len(row_buf) == 2:
+            builder.row(*row_buf)
+            row_buf = []
+    if row_buf:
+        builder.row(*row_buf)
+
+    if total_pages > 1:
+        nav = []
+        if page > 1:
+            nav.append(
+                InlineKeyboardButton(
+                    text=BACK,
+                    callback_data=AdminPanelCallback(action="modules", page=page - 1).pack(),
+                )
+            )
+        nav.append(
+            InlineKeyboardButton(
+                text=f"{page}/{total_pages}",
+                callback_data=AdminPanelCallback(action="modules", page=page).pack(),
+            )
+        )
+        if page < total_pages:
+            nav.append(
+                InlineKeyboardButton(
+                    text="Вперед ➡️",
+                    callback_data=AdminPanelCallback(action="modules", page=page + 1).pack(),
+                )
+            )
+        builder.row(*nav)
+
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminPanelCallback(action="admin", page=1).pack(),
+        )
+    )
+
+    return builder.as_markup()
+
+
+def build_module_menu_kb(name: str, page: int) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    enabled = manager.is_enabled(name)
+
+    if enabled:
+        builder.button(
+            text="🔁 Перезапустить",
+            callback_data=AdminPanelCallback(action=f"module_restart__{name}", page=page).pack(),
+        )
+        builder.button(
+            text="🛑 Остановить",
+            callback_data=AdminPanelCallback(action=f"module_stop__{name}", page=page).pack(),
+        )
+    else:
+        builder.button(
+            text="▶️ Запустить",
+            callback_data=AdminPanelCallback(action=f"module_start__{name}", page=page).pack(),
+        )
+
+    builder.button(
+        text="🔄 Обновить",
+        callback_data=AdminPanelCallback(action=f"module_update__{name}", page=page).pack(),
+    )
+
+    builder.button(
+        text="⬆️ Загрузить settings.py",
+        callback_data=AdminPanelCallback(action="module_upload_settings", page=page).pack(),
+    )
+    builder.button(
+        text="⬆️ Загрузить texts.py",
+        callback_data=AdminPanelCallback(action="module_upload_texts", page=page).pack(),
+    )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ К списку",
+            callback_data=AdminPanelCallback(action="modules", page=page).pack(),
+        )
+    )
+
+    builder.adjust(1)
+    return builder.as_markup()
@@ -0,0 +1,172 @@
+import os
+
+from aiogram import F, Router
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.fsm.context import FSMContext
+from aiogram.types import CallbackQuery
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from filters.admin import IsAdminFilter
+from handlers.admin.panel.keyboard import AdminPanelCallback
+from utils.modules_manager import manager
+
+from .keyboard import build_module_menu_kb, build_modules_kb
+
+
+router = Router()
+
+
+def list_installed_modules() -> list[tuple[str, str | None]]:
+    base = "modules"
+    if not os.path.isdir(base):
+        return []
+    items: list[tuple[str, str | None]] = []
+    for raw_name in sorted(os.listdir(base)):
+        path = os.path.join(base, raw_name)
+        if os.path.isdir(path) and not raw_name.startswith("."):
+            name = (raw_name or "").strip()
+            if not name:
+                continue
+            ver = None
+            vp = os.path.join(path, "VERSION")
+            if os.path.isfile(vp):
+                try:
+                    with open(vp, encoding="utf-8") as f:
+                        for line in f:
+                            line = line.strip()
+                            if line:
+                                ver = line
+                                break
+                except Exception:
+                    ver = None
+            items.append((name, ver))
+    return items
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "modules"), IsAdminFilter())
+async def handle_modules(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    await state.clear()
+
+    packed = AdminPanelCallback.unpack(callback_query.data)
+    page = max(1, packed.page or 1)
+
+    all_items = list_installed_modules()
+    items = [(n, v) for n, v in all_items if n != "web_admin_panel"]
+
+    per_page = 12
+    total_pages = max(1, (len(items) + per_page - 1) // per_page)
+    page = min(page, total_pages)
+    start = (page - 1) * per_page
+    chunk = items[start : start + per_page]
+
+    if chunk:
+
+        def fmt(n, v):
+            return f"{n} v{v}" if v else n
+
+        lines = "\n".join(f"• {fmt(n, v)}" for n, v in chunk)
+        text = f"🧩 Мои модули\n\nНайдено: {len(items)}\n<blockquote>{lines}</blockquote>"
+    else:
+        text = "🧩 Мои модули\n\nМодулей не найдено."
+
+    markup = build_modules_kb(page, total_pages, chunk)
+    try:
+        await callback_query.message.edit_text(text=text, reply_markup=markup, disable_web_page_preview=True)
+    except TelegramBadRequest as e:
+        if "message is not modified" in str(e).lower():
+            try:
+                await callback_query.message.edit_reply_markup(reply_markup=None)
+                await callback_query.message.edit_text(text=text, reply_markup=markup, disable_web_page_preview=True)
+            except TelegramBadRequest:
+                pass
+        else:
+            raise
+    finally:
+        await callback_query.answer()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("module_restart__")), IsAdminFilter())
+async def handle_module_restart(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    await state.clear()
+
+    packed = AdminPanelCallback.unpack(callback_query.data)
+    action = packed.action
+    page = packed.page or 1
+    name = action.split("module_restart__", 1)[-1]
+
+    try:
+        await manager.restart(name)
+        result = "✅ Модуль перезапущен."
+    except Exception as e:
+        result = f"❌ Ошибка перезапуска: {e}"
+
+    items = dict(list_installed_modules())
+    ver = items.get(name)
+    title = f"{name} v{ver}" if ver else name
+    text = f"🧩 Модуль: <b>{title}</b>\n\n{result}"
+
+    markup = build_module_menu_kb(name, page)
+    try:
+        await callback_query.message.edit_text(text=text, reply_markup=markup, disable_web_page_preview=True)
+    except TelegramBadRequest as e:
+        if "message is not modified" in str(e).lower():
+            return
+        raise
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("module_stop__")), IsAdminFilter())
+async def handle_module_stop(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    await state.clear()
+
+    packed = AdminPanelCallback.unpack(callback_query.data)
+    action = packed.action
+    page = packed.page or 1
+    name = action.split("module_stop__", 1)[-1]
+
+    try:
+        await manager.stop(name)
+        result = "🛑 Модуль остановлен."
+    except Exception as e:
+        result = f"❌ Ошибка остановки: {e}"
+
+    items = dict(list_installed_modules())
+    ver = items.get(name)
+    title = f"{name} v{ver}" if ver else name
+    text = f"🧩 Модуль: <b>{title}</b>\n\n{result}"
+
+    markup = build_module_menu_kb(name, page)
+    try:
+        await callback_query.message.edit_text(text=text, reply_markup=markup, disable_web_page_preview=True)
+    except TelegramBadRequest as e:
+        if "message is not modified" in str(e).lower():
+            return
+        raise
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action.startswith("module_start__")), IsAdminFilter())
+async def handle_module_start(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    await state.clear()
+
+    packed = AdminPanelCallback.unpack(callback_query.data)
+    action = packed.action
+    page = packed.page or 1
+    name = action.split("module_start__", 1)[-1]
+
+    try:
+        await manager.start(name)
+        result = "▶️ Модуль запущен."
+    except Exception as e:
+        result = f"❌ Ошибка запуска: {e}"
+
+    items = dict(list_installed_modules())
+    ver = items.get(name)
+    title = f"{name} v{ver}" if ver else name
+    text = f"🧩 Модуль: <b>{title}</b>\n\n{result}"
+
+    markup = build_module_menu_kb(name, page)
+    try:
+        await callback_query.message.edit_text(text=text, reply_markup=markup, disable_web_page_preview=True)
+    except TelegramBadRequest as e:
+        if "message is not modified" in str(e).lower():
+            return
+        raise
@@ -5,6 +5,8 @@ from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder

 from handlers.buttons import BACK, MAIN_MENU
+from hooks.hook_buttons import insert_hook_buttons
+from hooks.hooks import run_hooks


 class AdminPanelCallback(CallbackData, prefix="admin_panel"):
@@ -17,34 +19,63 @@ class AdminPanelCallback(CallbackData, prefix="admin_panel"):
        super().__init__(**data)


-def build_panel_kb(admin_role: str) -> InlineKeyboardMarkup:
+async def build_panel_kb(admin_role: str) -> InlineKeyboardMarkup:
    builder = InlineKeyboardBuilder()
-    builder.button(
-        text="👤 Поиск пользователя",
-        callback_data=AdminPanelCallback(action="search_user").pack(),
-    )
-    builder.button(
-        text="🔑 Поиск по подписке",
-        callback_data=AdminPanelCallback(action="search_key").pack(),
+    is_super = admin_role == "superadmin"
+    is_moderator = admin_role == "moderator"
+
+    builder.row(
+        InlineKeyboardButton(
+            text="👤 Поиск пользователя",
+            callback_data=AdminPanelCallback(action="search_user").pack(),
+        ),
+        InlineKeyboardButton(
+            text="🔑 Поиск подписок",
+            callback_data=AdminPanelCallback(action="search_key").pack(),
+        ),
    )

-    builder.button(
-        text="🖥️ Управление серверами",
-        callback_data=AdminPanelCallback(action="clusters").pack(),
-    )
+    if is_super:
+        builder.row(
+            InlineKeyboardButton(
+                text="🖥️ Управление серверами",
+                callback_data=AdminPanelCallback(action="clusters").pack(),
+            )
+        )
+        builder.row(
+            InlineKeyboardButton(
+                text="💸Управление тарифами",
+                callback_data=AdminPanelCallback(action="tariffs").pack(),
+            )
+        )
+        builder.row(
+            InlineKeyboardButton(
+                text="🤖 Управление ботом",
+                callback_data=AdminPanelCallback(action="management").pack(),
+            )
+        )
+
    builder.row(
-        InlineKeyboardButton(text="📢 Рассылка", callback_data=AdminPanelCallback(action="sender").pack()),
-        InlineKeyboardButton(text="🎟️ Купоны", callback_data=AdminPanelCallback(action="coupons").pack()),
-    )
-    builder.row(
-        InlineKeyboardButton(text="💸 Тарифы", callback_data=AdminPanelCallback(action="tariffs").pack()),
-        InlineKeyboardButton(text="🎁 Подарки", callback_data=AdminPanelCallback(action="gifts").pack()),
+        InlineKeyboardButton(
+            text="📢 Рассылка",
+            callback_data=AdminPanelCallback(action="sender").pack(),
+        ),
+        InlineKeyboardButton(
+            text="🎟️ Купоны",
+            callback_data=AdminPanelCallback(action="coupons").pack(),
+        ),
    )

-    if admin_role == "superadmin":
-        builder.button(
-            text="🤖 Управление ботом",
-            callback_data=AdminPanelCallback(action="management").pack(),
+    if is_super:
+        builder.row(
+            InlineKeyboardButton(
+                text="🎁 Подарки",
+                callback_data=AdminPanelCallback(action="gifts").pack(),
+            ),
+            InlineKeyboardButton(
+                text="🧩 Мои модули",
+                callback_data=AdminPanelCallback(action="modules").pack(),
+            ),
        )
        builder.row(
            InlineKeyboardButton(
@@ -56,13 +87,50 @@ def build_panel_kb(admin_role: str) -> InlineKeyboardMarkup:
                callback_data=AdminPanelCallback(action="ads").pack(),
            ),
        )
+    else:
+        builder.row(
+            InlineKeyboardButton(
+                text="🎁 Подарки",
+                callback_data=AdminPanelCallback(action="gifts").pack(),
+            )
+        )

-    builder.button(
-        text=MAIN_MENU,
-        callback_data="profile",
-    )
-    builder.adjust(1, 1, 1, 2, 2, 1, 2 if admin_role == "superadmin" else 0, 1)
-    return builder.as_markup()
+    module_buttons = await run_hooks("admin_panel", admin_role=admin_role)
+    builder = insert_hook_buttons(builder, module_buttons)
+
+    if not is_moderator:
+        builder.row(
+            InlineKeyboardButton(
+                text="⚙️ Настройки",
+                callback_data=AdminPanelCallback(action="settings").pack(),
+            )
+        )
+
+    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+    markup = builder.as_markup()
+
+    if is_super:
+        ads_callback = AdminPanelCallback(action="ads").pack()
+        emoji_button = InlineKeyboardButton(
+            text="😀 Эмоджи",
+            callback_data=AdminPanelCallback(action="emoji").pack(),
+        )
+
+        inserted = False
+        for index, row in enumerate(markup.inline_keyboard):
+            for button in row:
+                if getattr(button, "callback_data", None) == ads_callback:
+                    markup.inline_keyboard.insert(index + 1, [emoji_button])
+                    inserted = True
+                    break
+            if inserted:
+                break
+
+        if not inserted:
+            markup.inline_keyboard.append([emoji_button])
+
+    return markup


 def build_restart_kb() -> InlineKeyboardMarkup:
@@ -91,4 +159,7 @@ def build_admin_back_btn(action: str = "admin") -> InlineKeyboardButton:


 def build_admin_btn(text: str, action: str) -> InlineKeyboardButton:
-    return InlineKeyboardButton(text=text, callback_data=AdminPanelCallback(action=action).pack())
+    return InlineKeyboardButton(
+        text=text,
+        callback_data=AdminPanelCallback(action=action).pack(),
+    )
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`PAYMENT_SYSTEMS_EXCLUDED = ("referral", "coupon", "cashback", "admin")`