Fix special tariff notifications

Updated the README.md to enhance formatting, add images, and improve the overall presentation of SoloBot's features and capabilities.

.github/ISSUE_TEMPLATE/issue.md

@@ -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).

.github/pull_request_template.md

@@ -0,0 +1,21 @@
+### Описание изменений
+Опишите, что изменилось и зачем.
+
+### Ветка назначения
+- [ ] dev (основная ветка разработки)
+- [ ] main (только для критических исправлений безопасности)
+
+### Тип изменений
+- [ ] Новая функциональность
+- [ ] Исправление ошибки
+- [ ] Рефакторинг
+- [ ] Документация
+- [ ] Другое
+
+### Чек-лист
+- [ ] Изменения протестированы локально
+- [ ] Документация обновлена (если требуется)
+- [ ] Нет лишних изменений в коде
+
+### Связанные задачи
+Укажите номер issue, если PR его закрывает (например: Closes #123).

.gitignore

@@ -7,6 +7,7 @@ __pycache__/
 dist/
 build/
 *.egg-info/
+alembic/
 
 # Virtual environments
 venv/
@@ -28,6 +29,7 @@ env/
 # Sensitive configuration files
 config.py
 config.ini
+alembic.ini
 .env
 
 # Backup files
@@ -51,10 +53,11 @@ Thumbs.db
 
 nginx.conf
 scripts
-models.py
 Dockerfile
 .csv
 /logs
 setup.py
 .ruff_cache
-.github/workflows/
+.github/workflows/
+modules/
+storage/

.python-version

@@ -1 +0,0 @@
-3.12

CODE_OF_CONDUCT.md

@@ -0,0 +1,25 @@
+# Code of Conduct
+
+## Общие правила
+
+- Уважайте друг друга. Недопустимы оскорбления, дискриминация или токсичное поведение.  
+- Обсуждения должны оставаться по теме и в конструктивной форме.  
+- Личные и конфиденциальные данные публиковать запрещено.  
+- Нарушения могут привести к предупреждению, ограничению участия или блокировке по усмотрению мейнтейнеров.  
+
+## Участники GitHub
+
+- Могут предлагать изменения через **Issues** и **Pull Requests**.  
+- Их вклад рассматривается и принимается по решению мейнтейнеров.  
+- Дискуссии ограничены рамками кода и технических вопросов.  
+
+## Участники сообщества в Telegram
+
+- Имеют приоритетное взаимодействие с разработчиком.  
+- Могут обсуждать проект шире: идеи, улучшения, новые направления.  
+- Влияние на развитие кода выше, чем у участников извне.  
+- Общение остаётся в рамках уважения и конструктивности.  
+
+## Контакты
+
+По вопросам поведения используйте Issues с меткой `conduct` или обращайтесь через сообщество в Telegram.

CONTRIBUTING.md

@@ -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.
+
+Внося изменения, вы соглашаетесь, что ваш вклад распространяется на условиях этой лицензии. Перепродажа или коммерческое распространение этого кода без явного письменного согласия правообладателя не допускаются.
+---
+Ваш вклад помогает проекту расти и становиться лучше.

Makefile

@@ -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

README.md

@@ -1,106 +1,211 @@
-# 🚀 SoloBot
+<div align="center" style="max-width:980px;margin:0 auto;padding:0 12px">
 
-**SoloBot** — ваш идеальный помощник для управления API 3x-UI VPN на протоколе VLESS.
+![IMG_1565](https://github.com/user-attachments/assets/71cfb259-9889-4066-8626-b804ae4cf7fb)
 
-<img src=".github/images/preview.gif" alt="SoloBot" width="1600">
-
-# Описание
-Бот, предоставляющий инструменты под различные реализации. Хорошая кастомизация и подстройка под свой бренд.
-
-# Основные возможности
-
-**SoloBot** реализует множество функций, включая:
-
-### Управление подписками
-- Выдача подписок на различные периоды (**1 месяц, 3 месяца, полгода, год**).
-- Использование **тестового периода** подписки.
-- Продление ключей на указанные периоды.
-
-### Полный контроль клиента над своими ключами
-- Просмотр информации о ключе (**сервер, оставшееся время, сам ключ**).
-- Продление ключей.
-- Удаление ключей.
-- Просмотр полной информации вплоть до минут истечения
-- Смена локации (**перемещение ключа между серверами**).
-- Поддержка **нескольких ключей и устройств** для одного клиента.
-
-### Реферальная программа
-- Уникальная ссылка для приглашений.
-- Инлайн режим или обычные сообщения
-
-### Интеграция платёжных систем
-В боте реализована интеграция касс как для физических лиц, так и для самозанятых и ИП:
-- **Юкасса** (Самозанятость и ИП)
-- **Юмани** (Физические Лица) (TrackLine)
-- **Robokassa** (Физические Лица)
-- **Cryptobot** (Криптовалюта) (izzzzzi)
-- **Звезды Telegram**
-
-### Безопасность и стабильность
-- **Периодические бэкапы** базы данных клиентов и их восстановление.
-- **Смена домена** в случае переезда.
-
-### Уведомления
-- **Произвольные сообщения** через панель администратора.
-- Уведомления о **неиспользованных пробниках**.
-- Уведомления об **истекающих ключах** (_за сутки, за 6 часов и в момент истечения_).
-- **Воронка продаж**. Если клиент не взял пробник предлагаются более выгодные условия.
-- **Рассылка лично или всем.** С сохранением форматирования и отправкой картинок
-
-### Серверы
-- **Мультисерверность** — добавление сервера прямо в админке.
-- **Проверка на доступность** — бот следит за серверами и их откликом.
-- **Балансировка** — бот выдает подписку на наименее загруженный сервер.
-- **Сихронизация** — перемещайте клиентов на другие сервера бесшовно.
-
-### Удобная админ-панель
-- **Поиск клиента** — по айди, нику или ключу.
-- **Управление подпиской клиента** — перевыпуск, изменение баланса и остальное.
-- **Управление ботом** — перезагрузка, списки банов, смена домена.
-- *А также рассылки, создание купонов, просмотр детальной статистики и многое другое*
+  <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>
 
 
-<img src=".github/images/preview_2.gif" alt="SoloBot" width="1600">
+  <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>
 
-### Кастомизация
-- **Пробник** — Сами решаете будет или нет. Количество дней пробника также кастомизируется.
-- **Реферальная программа** — процент с каждого пополнения или фиксированная сумма.
-- **Все меню** — меняйте все меню как вам захочется, описания и тексты.
-- **Кешбэк** — начисляйте кэшбек за пополнения, если хотите.
-- **Настройки** — капча, подписка на канал, купоны и прочее.
-- **Автоматика** — удалять ли ключи после продления, продлевать ли их и остальное.
+  <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>
 
-### *Настраивайте как вам удобно!*
+  <hr style="height:1px;border:0;background:#222;margin:18px 0 16px">
+  <p><b>Многофункциональный бот, кастомизируемый под ваш бренд.</b></p>
+</div>
 
 
-## Список версий
+<h2 align="center">Основные возможности</h2>
 
-#### Бот постоянно развивается, обрастая новыми возможностями.
-#### Для полного рассмотрения каждой версии ознакомьтесь с [**релизами**](https://github.com/Vladless/Solo_bot/releases).
+<table align="center" style="max-width:980px;width:100%">
+  <tr>
+    <th align="left" style="width:30%">📌 Раздел</th>
+    <th align="left">💡 Возможности</th>
+  </tr>
+
+  <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>
+
+  <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 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 height="44" src="https://img.shields.io/badge/Отзывы-на_сайте-ff6a00?style=for-the-badge&labelColor=1f1f1f&logo=discourse&logoColor=ff6a00" alt="Reviews">
+  </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">
+  <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">
+
+<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 в Telegram и Полная версия
-
-#### Наш [**➡ сайт**](https://pocomacho.ru/solonetbot/):
-
-Всегда актуальные гайды по установке, файлы для запуска и ссылка на общий чат:
-![image](https://github.com/user-attachments/assets/28f317f0-6b26-4d86-a501-df9800646131)
-
-
-Попробовать SoloBot прямо сейчас в Telegram [**➡ Попробовать**](https://t.me/SoloNetVPN_bot).
-
-#### Отзывы пользователей:
-SoloBot уже помог сотням пользователей в нашем сообществе:
-![image](https://github.com/user-attachments/assets/fe13a00f-94d3-419c-afd0-d1c1efec5179)
-
-
- **Читать** [**➡ Отзывы**](https://pocomacho.ru/solonetbot/reviews/)
-
-Связаться с нами через [**➡ поддержку**](https://t.me/solonet_sup). Там вы сможете купить полную версию и получить логин
-и пароль от сайта, получить доступ в наш чат сообщества, а также задать необходимые вопросы!
-
-## Права на использование
-
-#### Перепродажа кода запрещена, ознакомьтесь с лицензией
-
-[Этот проект использует лицензию CC BY-NC 4.0](LICENSE)

SECURITY.md

@@ -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 без риска для данных и доступности.  
+- Чёткие и воспроизводимые шаги.  
+- Возможные предложения по снижению риска до исправления.  

api/depends.py

@@ -0,0 +1,32 @@
+import hashlib
+
+from collections.abc import AsyncGenerator
+
+from fastapi import Depends, HTTPException, Header, Query
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database import async_session_maker
+from database.models import Admin
+
+
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+
+
+def hash_token(token: str) -> str:
+    return hashlib.sha256(token.encode()).hexdigest()
+
+
+async def verify_admin_token(
+    admin_id: int = Query(..., alias="tg_id"),
+    token: str = Header(..., alias="X-Token"),
+    session: AsyncSession = Depends(get_session),
+) -> Admin:
+    hashed = hash_token(token)
+    result = await session.execute(select(Admin).where(Admin.tg_id == admin_id, Admin.token == hashed))
+    admin = result.scalar_one_or_none()
+    if not admin:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    return admin

api/main.py

@@ -0,0 +1,25 @@
+from fastapi import FastAPI
+from api.routes import users, keys, coupons, servers, tariffs, gifts, referrals, misc
+
+app = FastAPI(
+    title="SoloBot API (preAlpha)",
+    version="0.2.0",
+    docs_url="/api/docs",           
+    redoc_url="/api/redoc",         
+    openapi_url="/api/openapi.json" 
+)
+
+
+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"])
+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(misc.router, prefix="/api")
+
+
+@app.get("/api", include_in_schema=False)
+async def root():
+    return {"message": "Welcome to SoloBot API. Docs: /api/docs"}

api/routes/base_crud.py

@@ -0,0 +1,145 @@
+from fastapi import APIRouter, Depends, HTTPException, Path, Query
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+
+from api.depends import get_session, verify_admin_token
+from database.models import Admin
+
+
+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 generate_crud_router(
+    *,
+    model: type,
+    schema_response: type,
+    schema_create: type,
+    schema_update: type,
+    identifier_field: str = "tg_id",
+    parameter_name: str = "tg_id",
+    extra_get_by_email: bool = False,
+    enabled_methods: list[str] = ("get_all", "get_one", "get_by_email", "create", "update", "delete"),
+) -> APIRouter:
+    router = APIRouter()
+
+    if "get_all" in enabled_methods:
+
+        @router.get("/", response_model=list[schema_response])
+        async def get_all(
+            admin: Admin = Depends(verify_admin_token),
+            session: AsyncSession = Depends(get_session),
+        ):
+            result = await session.execute(select(model))
+            return result.scalars().all()
+
+    if "get_by_email" in enabled_methods and extra_get_by_email:
+
+        @router.get("/by_email", response_model=schema_response)
+        async def get_by_email(
+            email: str = Query(...),
+            admin: Admin = Depends(verify_admin_token),
+            session: AsyncSession = Depends(get_session),
+        ):
+            result = await session.execute(select(model).where(model.email == email))
+            obj = result.scalar_one_or_none()
+            if not obj:
+                raise HTTPException(status_code=404, detail="Not found by email")
+            return obj
+
+    if "get_one" in enabled_methods:
+
+        @router.get(f"/{{{parameter_name}}}", response_model=schema_response)
+        async def get_one(
+            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)
+            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
+
+    if "get_all_by_field" in enabled_methods:
+
+        @router.get(f"/all/{{{parameter_name}}}", response_model=list[schema_response])
+        async def get_all_by_field(
+            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)
+            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
+
+    if "create" in enabled_methods:
+
+        @router.post("/", response_model=schema_response)
+        async def create(
+            payload: schema_create,  # type: ignore
+            admin: Admin = Depends(verify_admin_token),
+            session: AsyncSession = Depends(get_session),
+        ):
+            data = payload.dict(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
+
+    if "update" in enabled_methods:
+
+        @router.patch(f"/{{{parameter_name}}}", response_model=schema_response)
+        async def update(
+            payload: schema_update,  # type: ignore
+            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)
+            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():
+                setattr(obj, k, v)
+
+            await session.commit()
+            await session.refresh(obj)
+            return obj
+
+    if "delete" in enabled_methods:
+
+        @router.delete(f"/{{{parameter_name}}}", response_model=dict)
+        async def delete(
+            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)
+            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")
+
+            await session.delete(obj)
+            await session.commit()
+            return {"detail": f"{model.__name__} deleted"}
+
+    return router

api/routes/coupons.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+
+from api.routes.base_crud import generate_crud_router
+from api.schemas import CouponBase, CouponResponse, CouponUpdate
+from database.models import Coupon
+
+
+router: APIRouter = generate_crud_router(
+    model=Coupon,
+    schema_response=CouponResponse,
+    schema_create=CouponBase,
+    schema_update=CouponUpdate,
+    identifier_field="code",
+    parameter_name="code",
+    enabled_methods=["get_all", "get_one", "create", "update", "delete"],
+)

api/routes/gifts.py

@@ -0,0 +1,65 @@
+from fastapi import APIRouter, Depends, HTTPException, Path
+from sqlalchemy import delete, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.depends import get_session, verify_admin_token
+from api.routes.base_crud import generate_crud_router
+from api.schemas import GiftBase, GiftResponse, GiftUpdate, GiftUsageResponse
+from database.models import Admin, Gift, GiftUsage
+
+
+router = APIRouter()
+
+
+gift_router = generate_crud_router(
+    model=Gift,
+    schema_response=GiftResponse,
+    schema_create=GiftBase,
+    schema_update=GiftUpdate,
+    identifier_field="gift_id",
+    parameter_name="gift_id",
+    enabled_methods=["get_all", "get_one", "create", "update"],
+)
+router.include_router(gift_router, prefix="", tags=["Gifts"])
+
+
+@router.get("/by_tg_id/{tg_id}", response_model=list[GiftResponse], tags=["Gifts"])
+async def get_gifts_by_tg_id(
+    tg_id: int = Path(...),
+    admin: Admin = Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(Gift).where(Gift.sender_tg_id == tg_id))
+    gifts = result.scalars().all()
+    if not gifts:
+        raise HTTPException(status_code=404, detail="Gifts not found")
+    return gifts
+
+
+gift_usage_router = generate_crud_router(
+    model=GiftUsage,
+    schema_response=GiftUsageResponse,
+    schema_create=None,
+    schema_update=None,
+    identifier_field="gift_id",
+    enabled_methods=["get_all", "get_one", "delete"],
+)
+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": "Подарок и связанные использования удалены"}

api/routes/keys.py

@@ -0,0 +1,141 @@
+from datetime import datetime
+
+from fastapi import Body, Depends, HTTPException, Path, status
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+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.operations import create_key_on_cluster, delete_key_from_cluster, renew_key_in_cluster
+from logger import logger
+
+
+router = generate_crud_router(
+    model=Key,
+    schema_response=KeyResponse,
+    schema_create=KeyBase,
+    schema_update=KeyUpdate,
+    identifier_field="tg_id",
+    extra_get_by_email=True,
+    enabled_methods=["get_all", "get_one", "get_by_email", "get_all_by_field"],
+)
+
+
+@router.delete("/by_email/{email}", response_model=dict)
+async def delete_key_by_email(
+    email: str = Path(..., description="Email клиента"),
+    session: AsyncSession = Depends(get_session),
+    admin: Admin = Depends(verify_admin_token),
+):
+    result = await session.execute(select(Key).where(Key.email == email))
+    db_key = result.scalar_one_or_none()
+
+    if not db_key:
+        raise HTTPException(status_code=404, detail="Ключ не найден")
+
+    try:
+        await delete_key_from_cluster(
+            session=session,
+            email=db_key.email,
+            client_id=db_key.client_id,
+            cluster_id=db_key.server_id,
+        )
+        await session.delete(db_key)
+        await session.commit()
+        logger.info(f"[API] Ключ удалён: {db_key.client_id}")
+        return {"message": "Ключ успешно удалён"}
+
+    except Exception as e:
+        logger.error(f"[API] Ошибка при удалении ключа: {e}")
+        raise HTTPException(status_code=500, detail="Ошибка при удалении ключа")
+
+
+@router.get("/routers/{tg_id}", response_model=list[KeyResponse])
+async def get_router_keys_by_tg_id(
+    tg_id: int = Path(..., description="Telegram ID пользователя"),
+    session: AsyncSession = Depends(get_session),
+    admin: Admin = Depends(verify_admin_token),
+):
+    tariffs_result = await session.execute(select(Tariff.id).where(Tariff.group_code == "routers"))
+    tariff_ids = [row[0] for row in tariffs_result.all()]
+    if not tariff_ids:
+        return []
+
+    keys_result = await session.execute(select(Key).where(Key.tg_id == tg_id, Key.tariff_id.in_(tariff_ids)))
+    keys = keys_result.scalars().all()
+    return keys
+
+
+@router.patch("/edit/by_email/{email}", response_model=KeyResponse)
+async def edit_key_by_email(
+    email: str = Path(..., description="Email клиента"),
+    key_update: KeyUpdate = Body(...),
+    session: AsyncSession = Depends(get_session),
+    admin: Admin = Depends(verify_admin_token),
+):
+    result = await session.execute(select(Key).where(Key.email == email))
+    db_key = result.scalar_one_or_none()
+    if not db_key:
+        raise HTTPException(status_code=404, detail="Ключ не найден")
+
+    for field, value in key_update.dict(exclude_unset=True).items():
+        if field == "expiry_time" and value is not None:
+            if isinstance(value, int):
+                ms = value
+            elif isinstance(value, datetime):
+                ms = int(value.timestamp() * 1000)
+            else:
+                raise HTTPException(status_code=400, detail="Некорректный формат времени")
+            setattr(db_key, field, ms)
+        else:
+            setattr(db_key, field, value)
+
+    try:
+        new_expiry_time = db_key.expiry_time
+        await renew_key_in_cluster(
+            cluster_id=db_key.server_id,
+            email=db_key.email,
+            client_id=db_key.client_id,
+            new_expiry_time=new_expiry_time,
+            total_gb=getattr(db_key, "traffic_limit", None),
+            session=session,
+            hwid_device_limit=getattr(db_key, "device_limit", None),
+            reset_traffic=True,
+        )
+        await session.commit()
+
+        logger.info(f"[API] Ключ обновлён: {db_key.client_id}")
+        return db_key
+
+    except Exception as e:
+        logger.error(f"[API] Ошибка при обновлении ключа: {e}")
+        raise HTTPException(status_code=500, detail="Ошибка при обновлении ключа")
+
+
+@router.post("/create", response_model=dict, status_code=status.HTTP_201_CREATED)
+async def create_key_api(
+    payload: KeyCreateRequest = Body(...),
+    session: AsyncSession = Depends(get_session),
+    admin: Admin = Depends(verify_admin_token),
+):
+    try:
+        await create_key_on_cluster(
+            cluster_id=payload.cluster_id,
+            tg_id=payload.tg_id,
+            client_id=payload.client_id,
+            email=payload.email or f"{payload.tg_id}_key",
+            expiry_timestamp=payload.expiry_timestamp,
+            plan=payload.tariff_id,
+            session=session,
+            remnawave_link=payload.remnawave_link,
+            hwid_limit=payload.hwid_limit,
+            traffic_limit_bytes=payload.traffic_limit_bytes,
+            is_trial=payload.is_trial or False,
+        )
+        return {"message": "Ключ успешно создан"}
+
+    except Exception as e:
+        logger.error(f"[API] Ошибка при создании ключа: {e}")
+        raise HTTPException(status_code=500, detail="Ошибка при создании ключа")

api/routes/misc.py

@@ -0,0 +1,171 @@
+from fastapi import APIRouter, Depends, HTTPException, Path
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.depends import get_session, verify_admin_token
+from api.routes.base_crud import generate_crud_router
+from api.schemas import (
+    BlockedUserResponse,
+    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,
+)
+
+
+router = APIRouter()
+
+router.include_router(
+    generate_crud_router(
+        model=Payment,
+        schema_response=PaymentResponse,
+        schema_create=None,
+        schema_update=None,
+        identifier_field="id",
+        enabled_methods=["get_all", "get_one", "delete"],
+    ),
+    prefix="/payments",
+    tags=["Payments"],
+    dependencies=[Depends(verify_admin_token)],
+)
+
+
+@router.get("/payments/by_tg_id/{tg_id}", response_model=list[PaymentResponse], tags=["Payments"])
+async def get_payments_by_tg_id(
+    tg_id: int = Path(...),
+    admin: Admin = Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(select(Payment).where(Payment.tg_id == tg_id))
+    payments = result.scalars().all()
+    if not payments:
+        raise HTTPException(status_code=404, detail="Payments not found")
+    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,
+        schema_response=NotificationResponse,
+        schema_create=None,
+        schema_update=None,
+        identifier_field="tg_id",
+        enabled_methods=["get_all", "get_one", "delete"],
+    ),
+    prefix="/notifications",
+    tags=["Notifications"],
+    dependencies=[Depends(verify_admin_token)],
+)
+
+
+router.include_router(
+    generate_crud_router(
+        model=ManualBan,
+        schema_response=ManualBanResponse,
+        schema_create=None,
+        schema_update=None,
+        identifier_field="tg_id",
+        enabled_methods=["get_all", "get_one", "delete"],
+    ),
+    prefix="/manual-bans",
+    tags=["Bans"],
+    dependencies=[Depends(verify_admin_token)],
+)
+
+router.include_router(
+    generate_crud_router(
+        model=BlockedUser,
+        schema_response=BlockedUserResponse,
+        schema_create=None,
+        schema_update=None,
+        identifier_field="tg_id",
+        enabled_methods=["get_all", "get_one", "delete"],
+    ),
+    prefix="/blocked-users",
+    tags=["Bans"],
+    dependencies=[Depends(verify_admin_token)],
+)
+
+router.include_router(
+    generate_crud_router(
+        model=TemporaryData,
+        schema_response=TemporaryDataResponse,
+        schema_create=None,
+        schema_update=None,
+        identifier_field="tg_id",
+        enabled_methods=["get_all", "get_one", "delete"],
+    ),
+    prefix="/temporary-data",
+    tags=["TemporaryData"],
+    dependencies=[Depends(verify_admin_token)],
+)
+
+router.include_router(
+    generate_crud_router(
+        model=TrackingSource,
+        schema_response=TrackingSourceResponse,
+        schema_create=None,
+        schema_update=None,
+        identifier_field="id",
+        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 []),
+    )

api/routes/referrals.py

@@ -0,0 +1,36 @@
+from fastapi import Depends, HTTPException, Query
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.depends import get_session, verify_admin_token
+from api.routes.base_crud import generate_crud_router
+from api.schemas import ReferralResponse
+from database.models import Admin, Referral
+
+
+router = generate_crud_router(
+    model=Referral,
+    schema_response=ReferralResponse,
+    schema_create=None,
+    schema_update=None,
+    identifier_field="referrer_tg_id",
+    enabled_methods=["get_all", "get_one", "get_all_by_field"],
+)
+
+
+@router.delete("/one")
+async def delete_one_referral(
+    referrer_tg_id: int = Query(..., description="ID пригласившего"),
+    referred_tg_id: int = Query(..., description="ID приглашённого"),
+    admin: Admin = Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    result = await session.execute(
+        select(Referral).where(Referral.referrer_tg_id == referrer_tg_id, Referral.referred_tg_id == referred_tg_id)
+    )
+    obj = result.scalar_one_or_none()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Referral not found")
+    await session.delete(obj)
+    await session.commit()
+    return {"status": "deleted_one"}

api/routes/servers.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+
+from api.routes.base_crud import generate_crud_router
+from api.schemas import ServerBase, ServerResponse, ServerUpdate
+from database.models import Server
+
+
+router: APIRouter = generate_crud_router(
+    model=Server,
+    schema_response=ServerResponse,
+    schema_create=ServerBase,
+    schema_update=ServerUpdate,
+    identifier_field="server_name",
+    parameter_name="server_name",
+    enabled_methods=["get_all", "get_one", "create", "update", "delete"],
+)

api/routes/tariffs.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+
+from api.routes.base_crud import generate_crud_router
+from api.schemas import TariffBase, TariffResponse, TariffUpdate
+from database.models import Tariff
+
+
+router: APIRouter = generate_crud_router(
+    model=Tariff,
+    schema_response=TariffResponse,
+    schema_create=TariffBase,
+    schema_update=TariffUpdate,
+    identifier_field="name",
+    parameter_name="name",
+    enabled_methods=["get_all", "get_one", "create", "update", "delete"],
+)

api/routes/users.py

@@ -0,0 +1,54 @@
+import asyncio
+
+from fastapi import Depends, HTTPException, Path
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.depends import get_session, verify_admin_token
+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.operations import delete_key_from_cluster
+from logger import logger
+
+
+router = generate_crud_router(
+    model=User,
+    schema_response=UserResponse,
+    schema_create=UserBase,
+    schema_update=UserUpdate,
+    identifier_field="tg_id",
+    enabled_methods=["get_all", "get_one", "get_by_email", "create", "update"],
+)
+
+
+@router.delete("/{tg_id}", response_model=dict)
+async def delete_user(
+    tg_id: int = Path(..., description="Telegram ID пользователя"),
+    admin=Depends(verify_admin_token),
+    session: AsyncSession = Depends(get_session),
+):
+    try:
+        result = await session.execute(select(Key.email, Key.client_id).where(Key.tg_id == tg_id))
+        key_records = result.all()
+
+        async def delete_keys_from_servers():
+            try:
+                servers = await get_servers(session=session)
+                tasks = []
+                for email, client_id in key_records:
+                    for cluster_id in servers:
+                        tasks.append(delete_key_from_cluster(cluster_id, email, client_id, session))
+                await asyncio.gather(*tasks, return_exceptions=True)
+            except Exception as e:
+                logger.error(f"[DELETE] Ошибка при удалении ключей с серверов для пользователя {tg_id}: {e}")
+
+        await delete_keys_from_servers()
+        await delete_user_data(session, tg_id)
+
+        return {"detail": f"Пользователь {tg_id} и его ключи успешно удалены."}
+
+    except Exception as e:
+        logger.error(f"[DELETE] Ошибка при удалении пользователя {tg_id}: {e}")
+        raise HTTPException(status_code=500, detail="Ошибка при удалении пользователя")

api/schemas/__init__.py

@@ -0,0 +1,15 @@
+from .coupons import CouponBase, CouponResponse, CouponUpdate, CouponUsageResponse
+from .gifts import GiftBase, GiftResponse, GiftUpdate, GiftUsageResponse
+from .keys import KeyDetailsResponse, KeyResponse
+from .misc import (
+    BlockedUserResponse,
+    ManualBanResponse,
+    NotificationResponse,
+    PaymentResponse,
+    TemporaryDataResponse,
+    TrackingSourceResponse,
+)
+from .referrals import ReferralResponse
+from .servers import ServerBase, ServerResponse, ServerUpdate
+from .tariffs import TariffBase, TariffResponse, TariffUpdate
+from .users import UserBase, UserResponse, UserUpdate

api/schemas/coupons.py

@@ -0,0 +1,56 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class CouponBase(BaseModel):
+    code: str
+    amount: int | None = Field(default=None)
+    usage_limit: int
+    usage_count: int = 0
+    is_used: bool = False
+    days: int | None = Field(default=None)
+
+    @model_validator(mode="after")
+    def check_exactly_one_of_amount_or_days(self) -> "CouponBase":
+        has_amount = self.amount not in (None, 0)
+        has_days = self.days is not None
+
+        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
+
+
+class CouponResponse(CouponBase):
+    id: int
+
+    class Config:
+        from_attributes = True
+
+
+class CouponUpdate(BaseModel):
+    code: str | None = None
+    amount: int | None = None
+    usage_limit: int | None = None
+    usage_count: int | None = None
+    is_used: bool | None = None
+    days: int | None = Field(default=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'")
+        return self
+
+
+class CouponUsageResponse(BaseModel):
+    coupon_id: int
+    user_id: int
+    used_at: datetime
+
+    class Config:
+        from_attributes = True

api/schemas/gifts.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class GiftBase(BaseModel):
+    sender_tg_id: int
+    recipient_tg_id: int | None = None
+    selected_months: int | None = None
+    expiry_time: datetime
+    gift_link: str
+    is_used: bool = False
+    is_unlimited: bool | None = False
+    max_usages: int | None = None
+    tariff_id: int | None = None
+
+
+class GiftResponse(GiftBase):
+    gift_id: str
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class GiftUsageResponse(BaseModel):
+    gift_id: str
+    tg_id: int
+    used_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class GiftUpdate(BaseModel):
+    recipient_tg_id: int | None = None
+    selected_months: int | None = None
+    expiry_time: datetime | None = None
+    gift_link: str | None = None
+    is_used: bool | None = None
+    is_unlimited: bool | None = None
+    max_usages: int | None = None
+    tariff_id: int | None = None
+
+    class Config:
+        from_attributes = True

api/schemas/keys.py

@@ -0,0 +1,76 @@
+from pydantic import BaseModel, Field
+
+
+class KeyBase(BaseModel):
+    tg_id: int
+    client_id: str
+    email: str | None = None
+    created_at: int | None = None
+    expiry_time: int
+    key: str | None = None
+    server_id: str | None = None
+    remnawave_link: str | None = None
+    tariff_id: int | None = None
+    is_frozen: bool | None = False
+    alias: str | None = None
+    notified: bool | None = False
+    notified_24h: bool | None = False
+
+
+class KeyResponse(KeyBase):
+    class Config:
+        from_attributes = True
+
+
+class KeyDetailsResponse(BaseModel):
+    key: str | None
+    remnawave_link: str | None
+    server_id: str | None
+    created_at: int | None
+    expiry_time: int | None
+    client_id: str
+    tg_id: int
+    email: str | None
+    is_frozen: bool
+    balance: float
+    alias: str | None
+    expiry_date: str
+    days_left_message: str
+    link: str | None
+    cluster_name: str | None
+    location_name: str | None
+    tariff_id: int | None
+
+    class Config:
+        from_attributes = True
+
+
+class KeyUpdate(BaseModel):
+    email: str | None = None
+    expiry_time: int | None = None
+    key: str | None = None
+    server_id: str | None = None
+    remnawave_link: str | None = None
+    tariff_id: int | None = None
+    is_frozen: bool | None = None
+    alias: str | None = None
+    notified: bool | None = None
+    notified_24h: bool | None = None
+
+    class Config:
+        from_attributes = True
+
+
+class KeyCreateRequest(BaseModel):
+    tg_id: int = Field(..., description="Telegram ID пользователя")
+    cluster_id: str = Field(..., description="Имя кластера или сервера")
+    tariff_id: int = Field(..., description="ID тарифа из базы данных")
+    client_id: str = Field(..., description="UUID клиента (уникальный)")
+    expiry_timestamp: int = Field(..., description="Срок окончания в миллисекундах")
+
+    email: str | None = Field(None, description="Условное имя подписки")
+    alias: str | None = Field(None, description="пользовательское имя")
+    remnawave_link: str | None = Field(None, description="Ссылка на подписку Remnawave")
+    hwid_limit: int | None = Field(None, description="Ограничение по HWID")
+    traffic_limit_bytes: int | None = Field(None, description="Ограничение трафика в байтах")
+    is_trial: bool | None = Field(False, description="Флаг триального ключа")

api/schemas/misc.py

@@ -0,0 +1,122 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class PaymentBase(BaseModel):
+    tg_id: int
+    amount: float
+    payment_system: str
+    status: str
+
+
+class PaymentResponse(PaymentBase):
+    id: int
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class ReferralResponse(BaseModel):
+    referred_tg_id: int
+    referrer_tg_id: int
+    reward_issued: bool = False
+
+    class Config:
+        from_attributes = True
+
+
+class NotificationResponse(BaseModel):
+    tg_id: int
+    notification_type: str
+    last_notification_time: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class GiftBase(BaseModel):
+    sender_tg_id: int
+    recipient_tg_id: int | None = None
+    selected_months: int
+    expiry_time: datetime
+    gift_link: str
+    is_used: bool = False
+    is_unlimited: bool = False
+    max_usages: int | None = None
+    tariff_id: int | None = None
+
+
+class GiftResponse(GiftBase):
+    gift_id: str
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class GiftUsageResponse(BaseModel):
+    gift_id: str
+    tg_id: int
+    used_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class ManualBanResponse(BaseModel):
+    tg_id: int
+    banned_at: datetime
+    reason: str
+    banned_by: int
+    until: datetime | None = None
+
+    class Config:
+        from_attributes = True
+
+
+class TemporaryDataResponse(BaseModel):
+    tg_id: int
+    state: str
+    data: dict
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class BlockedUserResponse(BaseModel):
+    tg_id: int
+
+    class Config:
+        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
+    code: str
+    type: str
+    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

api/schemas/referrals.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class ReferralResponse(BaseModel):
+    referred_tg_id: int
+    referrer_tg_id: int
+    reward_issued: bool = False
+
+    class Config:
+        from_attributes = True

api/schemas/servers.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel
+
+
+class ServerBase(BaseModel):
+    cluster_name: str
+    server_name: str
+    api_url: str
+    subscription_url: str | None = None
+    inbound_id: str
+    panel_type: str
+    max_keys: int | None = None
+    tariff_group: str | None = ""
+    enabled: bool = True
+
+
+class ServerResponse(ServerBase):
+    id: int
+
+    class Config:
+        from_attributes = True
+
+
+class ServerUpdate(BaseModel):
+    cluster_name: str | None = None
+    server_name: str | None = None
+    api_url: str | None = None
+    subscription_url: str | None = None
+    inbound_id: str | None = None
+    panel_type: str | None = None
+    max_keys: int | None = None
+    tariff_group: str | None = None
+    enabled: bool | None = None
+
+    class Config:
+        from_attributes = True

api/schemas/tariffs.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class TariffBase(BaseModel):
+    name: str
+    group_code: str
+    duration_days: int
+    price_rub: int
+    traffic_limit: int | None = None
+    device_limit: int | None = None
+    is_active: bool = True
+    subgroup_title: str | None = None
+    sort_order: int | None = None
+
+
+class TariffResponse(TariffBase):
+    id: int
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    class Config:
+        from_attributes = True
+
+
+class TariffUpdate(BaseModel):
+    name: str | None = None
+    group_code: str | None = None
+    duration_days: int | None = None
+    price_rub: int | None = None
+    traffic_limit: int | None = None
+    device_limit: int | None = None
+    is_active: bool | None = None
+    subgroup_title: str | None = None
+    sort_order: int | None = None
+
+    class Config:
+        from_attributes = True

api/schemas/users.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class UserBase(BaseModel):
+    tg_id: int
+    username: str | None = None
+    first_name: str | None = None
+    last_name: str | None = None
+    language_code: str | None = None
+    is_bot: bool | None = False
+    balance: float = 0.0
+    trial: int = 0
+    source_code: str | None = None
+
+
+class UserResponse(UserBase):
+    created_at: datetime | None
+    updated_at: datetime | None
+
+    class Config:
+        from_attributes = True
+
+
+class UserUpdate(BaseModel):
+    username: str | None = None
+    first_name: str | None = None
+    last_name: str | None = None
+    language_code: str | None = None
+    is_bot: bool | None = None
+    balance: float | None = None
+    trial: int | None = None
+    source_code: str | None = None
+
+    class Config:
+        from_attributes = True

assets/schema.sql

@@ -1,143 +0,0 @@
-CREATE TABLE IF NOT EXISTS users
-(
-    tg_id         BIGINT PRIMARY KEY NOT NULL,
-    username      TEXT,
-    first_name    TEXT,
-    last_name     TEXT,
-    language_code TEXT,
-    is_bot        BOOLEAN                  DEFAULT FALSE,
-    created_at    TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    updated_at    TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE TABLE IF NOT EXISTS connections
-(
-    tg_id   BIGINT PRIMARY KEY NOT NULL,
-    balance REAL               NOT NULL DEFAULT 0.0,
-    trial   INTEGER            NOT NULL DEFAULT 0
-);
-
-CREATE TABLE IF NOT EXISTS payments
-(
-    id             SERIAL PRIMARY KEY,
-    tg_id          BIGINT NOT NULL,
-    amount         REAL   NOT NULL,
-    payment_system TEXT   NOT NULL,
-    status         TEXT                     DEFAULT 'success',
-    created_at     TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY (tg_id) REFERENCES users (tg_id)
-);
-
-CREATE TABLE IF NOT EXISTS keys
-(
-    tg_id        BIGINT  NOT NULL,
-    client_id    TEXT    NOT NULL,
-    email        TEXT    NOT NULL,
-    created_at   BIGINT  NOT NULL,
-    expiry_time  BIGINT  NOT NULL,
-    key          TEXT    NOT NULL,
-    server_id    TEXT    NOT NULL DEFAULT 'cluster1',
-    notified     BOOLEAN NOT NULL DEFAULT FALSE,
-    notified_24h BOOLEAN NOT NULL DEFAULT FALSE,
-    PRIMARY KEY (tg_id, client_id)
-);
-
-DO $$
-BEGIN
-    IF NOT EXISTS (
-        SELECT 1 FROM information_schema.columns 
-        WHERE table_name = 'keys' AND column_name = 'is_frozen'
-    ) THEN
-        ALTER TABLE keys ADD COLUMN is_frozen BOOLEAN DEFAULT FALSE;
-    END IF;
-
-    IF NOT EXISTS (
-        SELECT 1 FROM information_schema.columns 
-        WHERE table_name = 'keys' AND column_name = 'alias'
-    ) THEN
-        ALTER TABLE keys ADD COLUMN alias TEXT;
-    END IF;
-END$$;
-
-
-CREATE TABLE IF NOT EXISTS referrals
-(
-    referred_tg_id BIGINT PRIMARY KEY NOT NULL,
-    referrer_tg_id BIGINT             NOT NULL,
-    reward_issued  BOOLEAN DEFAULT FALSE
-);
-
-CREATE TABLE IF NOT EXISTS coupons
-(
-    id          SERIAL PRIMARY KEY,
-    code        TEXT UNIQUE NOT NULL,
-    amount      INTEGER     NOT NULL,
-    days        INTEGER CHECK (days > 0 OR days IS NULL),
-    usage_limit INTEGER     NOT NULL DEFAULT 1,
-    usage_count INTEGER     NOT NULL DEFAULT 0,
-    is_used     BOOLEAN     NOT NULL DEFAULT FALSE
-);
-
-DO $$
-BEGIN
-    IF NOT EXISTS (
-        SELECT 1 FROM information_schema.columns 
-        WHERE table_name = 'coupons' AND column_name = 'days'
-    ) THEN
-        ALTER TABLE coupons ADD COLUMN days INTEGER CHECK (days > 0 OR days IS NULL);
-    END IF;
-END$$;
-
-CREATE TABLE IF NOT EXISTS coupon_usages
-(
-    coupon_id INTEGER   NOT NULL REFERENCES coupons (id) ON DELETE CASCADE,
-    user_id   BIGINT    NOT NULL,
-    used_at   TIMESTAMP NOT NULL DEFAULT NOW(),
-    PRIMARY KEY (coupon_id, user_id)
-);
-
-CREATE TABLE IF NOT EXISTS notifications
-(
-    tg_id                  BIGINT    NOT NULL,
-    last_notification_time TIMESTAMP NOT NULL DEFAULT NOW(),
-    notification_type      TEXT      NOT NULL,
-    PRIMARY KEY (tg_id, notification_type)
-);
-
-CREATE TABLE IF NOT EXISTS servers
-(
-    id               SERIAL PRIMARY KEY,
-    cluster_name     TEXT NOT NULL,
-    server_name      TEXT NOT NULL,
-    api_url          TEXT NOT NULL,
-    subscription_url TEXT NOT NULL,
-    inbound_id       TEXT NOT NULL,
-    UNIQUE (cluster_name, server_name) 
-);
-
-
-CREATE TABLE IF NOT EXISTS gifts
-(
-    gift_id        TEXT PRIMARY KEY NOT NULL,      
-    sender_tg_id   BIGINT NOT NULL,            
-    selected_months INTEGER NOT NULL,          
-    expiry_time    TIMESTAMP WITH TIME ZONE NOT NULL,   
-    gift_link      TEXT NOT NULL,                
-    created_at     TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, 
-    is_used        BOOLEAN NOT NULL DEFAULT FALSE,  
-    recipient_tg_id BIGINT,                            
-    CONSTRAINT fk_sender FOREIGN KEY (sender_tg_id) REFERENCES users (tg_id),  
-    CONSTRAINT fk_recipient FOREIGN KEY (recipient_tg_id) REFERENCES users (tg_id)
-);
-
-CREATE TABLE IF NOT EXISTS temporary_data (
-    tg_id BIGINT PRIMARY KEY NOT NULL,
-    state TEXT NOT NULL,
-    data JSONB NOT NULL,
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE TABLE IF NOT EXISTS blocked_users (
-    tg_id BIGINT PRIMARY KEY,
-    blocked_at TIMESTAMP DEFAULT NOW()
-);

bot.py

@@ -10,28 +10,26 @@ from aiogram.types import BufferedInputFile, ErrorEvent
 from aiogram.utils.markdown import hbold
 
 from config import ADMIN_ID, API_TOKEN
+from database import async_session_maker
 from filters.private import IsPrivateFilter
 from logger import logger
-from middlewares import register_middleware
+from utils.modules_loader import load_modules_from_folder, modules_hub
 
 
 bot = Bot(token=API_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
 storage = MemoryStorage()
 dp = Dispatcher(bot=bot, storage=storage)
 
-version = "4.1-Release"
+dp.include_router(modules_hub)
 
-register_middleware(dp)
+load_modules_from_folder()
 
 dp.message.filter(IsPrivateFilter())
 dp.callback_query.filter(IsPrivateFilter())
 
 
 @dp.errors(ExceptionTypeFilter(Exception))
-async def errors_handler(
-    event: ErrorEvent,
-    bot: Bot,
-) -> bool:
+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
@@ -44,26 +42,67 @@ async def errors_handler(
             or "message can't be deleted for everyone" in error_message
             or "message to delete not found" in error_message
         ):
-            logger.warning("Отправляем стартовое меню.")
+            try:
+                tb = "".join(
+                    traceback.format_exception(type(event.exception), event.exception, event.exception.__traceback__)
+                )
+                logger.warning(f"Показываем стартовое меню из-за TelegramBadRequest: {error_message}")
+                logger.error(f"Traceback:\n{tb}")
+
+                if ADMIN_ID:
+                    for admin_id in ADMIN_ID:
+                        await bot.send_document(
+                            chat_id=admin_id,
+                            document=BufferedInputFile(
+                                tb.encode(),
+                                filename=f"error_{event.update.update_id}.txt",
+                            ),
+                            caption=f"{hbold(type(event.exception).__name__)}: {error_message[:1021]}...",
+                        )
+            except Exception as e:
+                logger.error(f"Сбой при логировании/отправке ошибки админу: {e}", exc_info=True)
 
             try:
-                from handlers.start import handle_start_callback_query, start_command
+                from handlers.start import start_entry
 
                 if event.update.message:
-                    await start_command(
-                        event.update.message, state=dp.storage, session=None, admin=False, captcha=False
+                    fsm_context = dp.fsm.get_context(
+                        bot=bot,
+                        chat_id=event.update.message.chat.id,
+                        user_id=event.update.message.from_user.id,
                     )
+                    async with async_session_maker() as session:
+                        await start_entry(
+                            event=event.update.message,
+                            state=fsm_context,
+                            session=session,
+                            admin=False,
+                            captcha=False,
+                        )
                 elif event.update.callback_query:
-                    await handle_start_callback_query(
-                        event.update.callback_query, state=dp.storage, session=None, admin=False, captcha=False
+                    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,
                     )
+                    async with async_session_maker() as session:
+                        await start_entry(
+                            event=event.update.callback_query,
+                            state=fsm_context,
+                            session=session,
+                            admin=False,
+                            captcha=False,
+                        )
             except Exception as e:
-                logger.error(f"Ошибка при показе стартового меню после ошибки: {e}")
+                logger.error(f"Ошибка при показе стартового меню после ошибки: {e}", exc_info=True)
 
             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(
@@ -74,19 +113,39 @@ async def errors_handler(
                 ),
                 caption=f"{hbold(type(event.exception).__name__)}: {str(event.exception)[:1021]}...",
             )
-        try:
-            from handlers.start import handle_start_callback_query, start_command
 
-            if event.update.message:
-                await start_command(event.update.message, state=dp.storage, session=None, admin=False, captcha=False)
-            elif event.update.callback_query:
-                await handle_start_callback_query(
-                    event.update.callback_query, state=dp.storage, session=None, admin=False, captcha=False
+        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,
+            )
+            async with async_session_maker() as session:
+                await start_entry(
+                    event=event.update.message,
+                    state=fsm_context,
+                    session=session,
+                    admin=False,
+                    captcha=False,
                 )
-        except Exception as e:
-            logger.error(f"Ошибка при показе стартового меню после ошибки: {e}")
+        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,
+            )
+            async with async_session_maker() as session:
+                await start_entry(
+                    event=event.update.callback_query,
+                    state=fsm_context,
+                    session=session,
+                    admin=False,
+                    captcha=False,
+                )
+
     except TelegramBadRequest as exception:
-        logger.warning(f"Failed to send error details: {exception}")
+        logger.warning(f"Не удалось отправить детали ошибки: {exception}")
     except Exception as exception:
-        logger.error(f"Unexpected error in error handler: {exception}")
+        logger.error(f"Неожиданная ошибка в error handler: {exception}")
+
     return True

cli_launcher.py

@@ -1,60 +1,313 @@
+import locale
 import os
-import sys
-import subprocess
-import requests
-from rich.console import Console
-from rich.prompt import Prompt, Confirm
-from rich.table import Table
-from rich.text import Text
 import re
+import shutil
+import subprocess
+import sys
+
+from time import sleep
+
+import requests
+
+from rich.console import Console, Group
+from rich.live import Live
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
 
 from config import BOT_SERVICE
 
-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"):
+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"
 
-BACK_DIR = os.path.expanduser("~/.solobot_backup")
+    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
+
+console = Console()
+ensure_utf8_locale()
+
+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"
+
+if IS_ROOT_DIR:
+    console.print("[bold red]КРИТИЧЕСКАЯ ОШИБКА:[/bold red]")
+    console.print("[red]Обнаружена установка бота прямо в корневой папке (/root).[/red]")
+    console.print("[red]Это крайне опасно и может привести к потере данных![/red]")
+    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
 
-console = Console()
+
+def is_service_exists(service_name):
+    result = subprocess.run(["systemctl", "list-unit-files", service_name], capture_output=True, text=True)
+    return service_name in result.stdout
 
 
 def print_logo():
-    logo = Text("""
-███████╗ ██████╗ ██╗      ██████╗ ██████╗  ██████╗ ████████╗
-██╔════╝██╔═══██╗██║     ██╔═══██╗██╔══██╗██╔═══██╗╚══██╔══╝
-███████╗██║   ██║██║     ██║   ██║██████╔╝██║   ██║   ██║   
-╚════██║██║   ██║██║     ██║   ██║██╔══██╗██║   ██║   ██║   
-███████║╚██████╔╝███████╗╚██████╔╝██████╔╝╚██████╔╝   ██║   
-╚══════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝  ╚═════╝    ╚═╝   
-""", style="bold cyan")
-    console.print(logo)
+    logo_lines = [
+        "███████╗ ██████╗ ██╗      ██████╗ ██████╗  ██████╗ ████████╗",
+        "██╔════╝██╔═══██╗██║     ██╔═══██╗██╔══██╗██╔═══██╗╚══██╔══╝",
+        "███████╗██║   ██║██║     ██║   ██║██████╔╝██║   ██║   ██║   ",
+        "╚════██║██║   ██║██║     ██║   ██║██╔══██╗██║   ██║   ██║   ",
+        "███████║╚██████╔╝███████╗╚██████╔╝██████╔╝╚██████╔╝   ██║   ",
+        "╚══════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝  ╚═════╝    ╚═╝   ",
+    ]
+
+    with Live(refresh_per_second=10) as live:
+        display = []
+        for line in logo_lines:
+            display.append(f"[bold cyan]{line}[/bold cyan]")
+            panel = Panel(Group(*display), border_style="cyan", padding=(0, 2), expand=False)
+            live.update(panel)
+            sleep(0.07)
+
+    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():
-    console.print("[yellow]📦 Создаётся резервная копия проекта...[/yellow]")
+    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 = Prompt.ask(
+            "[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 Confirm.ask("[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(f"rsync -a --delete {sel_path}/ {PROJECT_DIR}/", shell=True).returncode
+    if rc != 0:
+        console.print("[red]❌ Ошибка rsync при восстановлении[/red]")
+        return
+
+    install_dependencies()
+    fix_permissions()
+    restart_service()
+    console.print("[green]✅ Восстановление из бэкапа завершено[/green]")
+
+
+def auto_update_cli():
+    console.print("[yellow]Проверка обновлений CLI...[/yellow]")
+    try:
+        url = "https://raw.githubusercontent.com/Vladless/Solo_bot/dev/cli_launcher.py"
+        response = requests.get(url, timeout=10)
+        if response.status_code != 200:
+            console.print("[red]Не удалось получить обновление CLI[/red]")
+            return
+
+        latest_text = response.text
+        current_path = os.path.realpath(__file__)
+        with open(current_path, encoding="utf-8") as f:
+            current_text = f.read()
+
+        if current_text != latest_text:
+            console.print("[green]Доступна новая версия CLI. Обновляю...[/green]")
+            with open(current_path, "w", encoding="utf-8") as f:
+                f.write(latest_text)
+            os.chmod(current_path, 0o755)
+            console.print("[green]CLI обновлён. Перезапуск...[/green]")
+            os.execv(sys.executable, [sys.executable, current_path])
+        else:
+            console.print("[green]CLI уже актуален[/green]")
+    except Exception as e:
+        console.print(f"[red]❌ Ошибка при автообновлении CLI: {e}[/red]")
+
+
+def fix_permissions():
+    console.print("[yellow]Восстанавливаю владельца и права доступа к проекту...[/yellow]")
+
+    try:
+        user = os.environ.get("SUDO_USER") or subprocess.check_output(["whoami"], text=True).strip()
+        console.log(f"[cyan]Используем пользователь: {user}[/cyan]")
+
+        for root, dirs, files in os.walk(PROJECT_DIR):
+            for dir in dirs:
+                if dir == "__pycache__":
+                    pycache_path = os.path.join(root, dir)
+                    subprocess.run(["sudo", "rm", "-rf", pycache_path], check=True)
+            for file in files:
+                if file.endswith(".pyc"):
+                    pyc_path = os.path.join(root, file)
+                    subprocess.run(["sudo", "rm", "-f", pyc_path], check=True)
+
+        console.log("[blue]Изменение владельца на весь проект...[/blue]")
+        subprocess.run(["sudo", "chown", "-R", f"{user}:{user}", PROJECT_DIR], check=True)
+
+        console.log("[blue]Изменение прав доступа (u=rwX,go=rX)...[/blue]")
+        subprocess.run(["sudo", "chmod", "-R", "u=rwX,go=rX", PROJECT_DIR], check=True)
+
+        launcher_path = os.path.join(PROJECT_DIR, "cli_launcher.py")
+        if os.path.exists(launcher_path):
+            console.log("[blue]Установка флага +x для cli_launcher.py...[/blue]")
+            subprocess.run(["chmod", "+x", launcher_path], check=True)
+
+        console.print(f"[green]Все права восстановлены для пользователя [bold]{user}[/bold][/green]")
+
+    except Exception as e:
+        console.print(f"[red]❌ Ошибка при установке прав: {e}[/red]")
 
 
 def install_rsync_if_needed():
     if subprocess.run(["which", "rsync"], capture_output=True).returncode != 0:
-        console.print("[blue]📦 Установка rsync...[/blue]")
+        console.print("[blue]Установка rsync...[/blue]")
         os.system("sudo apt update && sudo apt install -y rsync")
 
 
+def clean_project_dir_safe(update_buttons=False, update_img=False):
+    console.print("[yellow]Очистка проекта перед обновлением...[/yellow]")
+
+    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, 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:
+            path = os.path.join(root, file)
+            if path in preserved_paths:
+                continue
+            try:
+                os.remove(path)
+            except PermissionError:
+                subprocess.run(["sudo", "rm", "-f", path])
+            except Exception as e:
+                console.print(f"[red]Не удалось удалить файл: {path}: {e}[/red]")
+
+        for dir in dirs:
+            dir_path = os.path.join(root, dir)
+
+            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 os.path.abspath(dir_path).startswith(os.path.join(PROJECT_DIR, "modules") + os.sep):
+                continue
+
+            try:
+                os.rmdir(dir_path)
+            except Exception:
+                subprocess.run(["sudo", "rm", "-rf", dir_path])
+
+
 def install_git_if_needed():
     if subprocess.run(["which", "git"], capture_output=True).returncode != 0:
         console.print("[blue]Установка Git...[/blue]")
@@ -62,25 +315,55 @@ def install_git_if_needed():
 
 
 def install_dependencies():
-    console.print("[blue]🔧 Установка зависимостей...[/blue]")
-    with console.status("[bold green]Устанавливаются зависимости...[/bold green]"):
+    console.print("[blue]Установка зависимостей...[/blue]")
+
+    python312_path = shutil.which("python3.12")
+    if not python312_path:
+        console.print("[red]Не найден python3.12 в системе[/red]")
+        console.print("[yellow]Установите Python 3.12: sudo apt install python3.12 python3.12-venv[/yellow]")
+        sys.exit(1)
+
+    with Progress(
+        SpinnerColumn(style="green"),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        task_id = progress.add_task(description="Создание виртуального окружения...", total=None)
         try:
-            subprocess.run("bash -c 'source venv/bin/activate && pip install -r requirements.txt'", shell=True, check=True)
-        except subprocess.CalledProcessError:
-            console.print("[red]❌ Ошибка при установке зависимостей.[/red]")
+            if os.path.exists("venv"):
+                shutil.rmtree("venv")
+                console.print("[yellow]Удалён старый venv[/yellow]")
+
+            subprocess.run(f"{python312_path} -m venv venv", shell=True, check=True)
+
+            progress.update(task_id, description="Установка зависимостей...")
+            subprocess.run(
+                "bash -c 'source venv/bin/activate && pip install -r requirements.txt'",
+                shell=True,
+                check=True,
+            )
+
+            progress.update(task_id, description="Установка завершена")
+
+        except subprocess.CalledProcessError as e:
+            progress.update(task_id, description="❌ Ошибка при установке")
+            console.print(f"[red]❌ Ошибка: {e}[/red]")
 
 
 def restart_service():
-    console.print("[blue]🚀 Перезапуск службы...[/blue]")
-    with console.status("[bold yellow]Перезапуск...[/bold yellow]"):
-        subprocess.run(f"sudo systemctl restart {SERVICE_NAME}", shell=True)
+    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)
+    else:
+        console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
 
 
 def get_local_version():
     path = os.path.join(PROJECT_DIR, "bot.py")
     if not os.path.isfile(path):
         return None
-    with open(path, "r", encoding="utf-8") as f:
+    with open(path, encoding="utf-8") as f:
         for line in f:
             match = re.search(r'version\s*=\s*["\'](.+?)["\']', line)
             if match:
@@ -107,48 +390,83 @@ def update_from_beta():
     remote_version = get_remote_version(branch="dev")
 
     if local_version and remote_version:
-        console.print(f"[cyan]🔢 Локальная версия: {local_version} | Последняя в dev: {remote_version}[/cyan]")
+        console.print(f"[cyan]Локальная версия: {local_version} | Последняя в dev: {remote_version}[/cyan]")
         if local_version == remote_version:
-            if not Confirm.ask("[yellow]❗ Версия актуальна. Обновить всё равно?[/yellow]"):
+            if not Confirm.ask("[yellow]Версия актуальна. Обновить всё равно?[/yellow]"):
                 return
-    else:
-        console.print("[red]⚠️ Не удалось определить версии.[/red]")
 
-    if not Confirm.ask("[yellow]🔁 Подтвердите обновление Solobot с ветки DEV[/yellow]"):
+    if not Confirm.ask("[yellow]Подтвердите обновление Solobot с ветки DEV[/yellow]"):
         return
 
+    console.print("[red]ВНИМАНИЕ! Папка бота будет перезаписана![/red]")
+    if not Confirm.ask("[red]Продолжить обновление?[/red]"):
+        return
+
+    update_buttons = Confirm.ask("[yellow]Обновлять файл buttons.py?[/yellow]", default=False)
+    update_img = Confirm.ask("[yellow]Обновлять папку img?[/yellow]", default=False)
+
     backup_project()
     install_git_if_needed()
     install_rsync_if_needed()
 
     os.chdir(PROJECT_DIR)
-
-    console.print("[cyan]📥 Клонируем репозиторий dev во временную папку...[/cyan]")
+    console.print("[cyan]Клонируем временный репозиторий...[/cyan]")
     subprocess.run(["rm", "-rf", TEMP_DIR])
-    if os.system(f"git clone -b dev {GITHUB_REPO} {TEMP_DIR}") != 0:
+
+    if os.system(f"git clone --depth=1000000 -b dev {GITHUB_REPO} {TEMP_DIR}") != 0:
         console.print("[red]❌ Ошибка при клонировании. Обновление отменено.[/red]")
         return
 
-    subprocess.run(f'rsync -a --exclude=img --exclude=handlers/buttons.py {TEMP_DIR}/ {PROJECT_DIR}/', shell=True)
+    subprocess.run(["sudo", "rm", "-rf", os.path.join(PROJECT_DIR, "venv")])
+    clean_project_dir_safe(update_buttons=update_buttons, update_img=update_img)
+
+    exclude_options = ""
+    if not update_img:
+        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)
+
+    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])
+
     subprocess.run(["rm", "-rf", TEMP_DIR])
 
     install_dependencies()
+    fix_permissions()
     restart_service()
-    console.print("[green]✅ Обновление с ветки dev завершено.[/green]")
+    console.print("[green]Обновление с ветки dev завершено.[/green]")
 
 
 def update_from_release():
-    if not Confirm.ask("[yellow]🔁 Подтвердите обновление Solobot до одного из последних релизов[/yellow]"):
+    if not Confirm.ask("[yellow]Подтвердите обновление Solobot до одного из последних релизов[/yellow]"):
         return
 
+    console.print("[red]ВНИМАНИЕ! Папка бота будет полностью перезаписана![/red]")
+    console.print("[red]  Исключения: папка img и файл handlers/buttons.py[/red]")
+    if not Confirm.ask("[red]Вы точно хотите продолжить?[/red]"):
+        return
+
+    update_buttons = Confirm.ask("[yellow]Обновлять файл buttons.py?[/yellow]", default=False)
+    update_img = Confirm.ask("[yellow]Обновлять папку img?[/yellow]", default=False)
+
     backup_project()
     install_git_if_needed()
     install_rsync_if_needed()
 
     try:
-        response = requests.get(
-            "https://api.github.com/repos/Vladless/Solo_bot/releases", timeout=10
-        )
+        response = requests.get("https://api.github.com/repos/Vladless/Solo_bot/releases", timeout=10)
         releases = response.json()[:3]
         tag_choices = [r["tag_name"] for r in releases]
 
@@ -161,31 +479,68 @@ def update_from_release():
 
         selected = Prompt.ask(
             "[bold blue]Выберите номер релиза[/bold blue]",
-            choices=[str(i) for i in range(1, len(tag_choices) + 1)]
+            choices=[str(i) for i in range(1, len(tag_choices) + 1)],
         )
         tag_name = tag_choices[int(selected) - 1]
 
-        console.print(f"[cyan]📥 Клонируем релиз {tag_name} во временную папку...[/cyan]")
-        subprocess.run(["rm", "-rf", TEMP_DIR])
-        subprocess.run(f"git clone --depth 1 --branch {tag_name} {GITHUB_REPO} {TEMP_DIR}", shell=True, check=True)
+        if not Confirm.ask(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,
+            check=True,
+        )
+
+        console.print("[red]Начинается перезапись файлов бота![/red]")
+        subprocess.run(["sudo", "rm", "-rf", os.path.join(PROJECT_DIR, "venv")])
+        clean_project_dir_safe(update_buttons=update_buttons, update_img=update_img)
+
+        exclude_options = ""
+        if not update_img:
+            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)
+
+        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])
 
-        subprocess.run(f'rsync -a --exclude=img --exclude=handlers/buttons.py {TEMP_DIR}/ {PROJECT_DIR}/', shell=True)
         subprocess.run(["rm", "-rf", TEMP_DIR])
 
         install_dependencies()
+        fix_permissions()
         restart_service()
-        console.print(f"[green]✅ Обновление до релиза {tag_name} завершено.[/green]")
+        console.print(f"[green]Обновление до релиза {tag_name} завершено.[/green]")
 
     except Exception as e:
         console.print(f"[red]❌ Ошибка при обновлении: {e}[/red]")
 
 
 def show_update_menu():
+    if IS_ROOT_DIR:
+        console.print("[red]Обновление невозможно: бот находится в /root[/red]")
+        console.print("[yellow]Перенесите бота в отдельную папку и повторите попытку[/yellow]")
+        return
+
     table = Table(title="Выберите способ обновления", title_style="bold green")
     table.add_column("№", justify="center", style="cyan", no_wrap=True)
     table.add_column("Источник", style="white")
     table.add_row("1", "Обновить до BETA")
-    table.add_row("2", "Обновить до последнего релиза")
+    table.add_row("2", "Обновить/откатить до релиза")
     table.add_row("3", "Назад в меню")
 
     console.print(table)
@@ -198,11 +553,9 @@ def show_update_menu():
 
 
 def show_menu():
-    table = Table(title="Solobot CLI", title_style="bold magenta", header_style="bold blue")
-
+    table = Table(title="Solobot CLI v0.3.3", 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)")
     table.add_row("2", "Запустить напрямую: venv/bin/python main.py")
     table.add_row("3", "Перезапустить бота (systemd)")
@@ -210,45 +563,70 @@ 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)
 
 
 def main():
-    if os.geteuid() != 0:
-        console.print("[bold red]⛔ Требуется запуск от имени root или через sudo.[/bold red]")
-        sys.exit(1)
-    
-    os.chdir(PROJECT_DIR) 
-
+    os.chdir(PROJECT_DIR)
+    auto_update_cli()
     print_logo()
-
-    while True:
-        show_menu()
-        choice = Prompt.ask("[bold blue]Введите номер действия[/bold blue]", choices=[str(i) for i in range(1, 9)])
-
-        if choice == "1":
-            os.system(f"sudo systemctl start {SERVICE_NAME}")
-        elif choice == "2":
-            if Confirm.ask("[green]Вы действительно хотите запустить main.py вручную?[/green]"):
-                os.system("sudo venv/bin/python main.py")
-        elif choice == "3":
-            if Confirm.ask("[yellow]Вы действительно хотите перезапустить бота?[/yellow]"):
-                os.system(f"sudo systemctl restart {SERVICE_NAME}")
-        elif choice == "4":
-            if Confirm.ask("[red]Вы уверены, что хотите остановить бота?[/red]"):
-                os.system(f"sudo systemctl stop {SERVICE_NAME}")
-        elif choice == "5":
-            os.system(f"sudo journalctl -u {SERVICE_NAME} -n 80 --no-pager")
-        elif choice == "6":
-            os.system(f"sudo systemctl status {SERVICE_NAME}")
-        elif choice == "7":
-            show_update_menu()
-        elif choice == "8":
-            console.print("[bold cyan] Выход из CLI. Удачного дня![/bold cyan]")
-            break
-
+    try:
+        while True:
+            show_menu()
+            choice = Prompt.ask(
+                "[bold blue]👉 Введите номер действия[/bold blue]",
+                choices=[str(i) for i in range(1, 10)],
+                show_choices=False,
+            )
+            if choice == "1":
+                if is_service_exists(SERVICE_NAME):
+                    subprocess.run(["sudo", "systemctl", "start", SERVICE_NAME])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
+            elif choice == "2":
+                if Confirm.ask("[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]"):
+                        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]"):
+                        subprocess.run(["sudo", "systemctl", "stop", SERVICE_NAME])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
+            elif choice == "5":
+                if is_service_exists(SERVICE_NAME):
+                    subprocess.run([
+                        "sudo",
+                        "journalctl",
+                        "-u",
+                        SERVICE_NAME,
+                        "-n",
+                        "80",
+                        "--no-pager",
+                    ])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
+            elif choice == "6":
+                if is_service_exists(SERVICE_NAME):
+                    subprocess.run(["sudo", "systemctl", "status", SERVICE_NAME])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
+            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:
+        console.print("\n[bold red]⏹ Прерывание. Выход из CLI.[/bold red]")
 
 
 if __name__ == "__main__":

database/__init__.py

@@ -0,0 +1,16 @@
+from .bans import *
+from .coupons import *
+from .db import async_session_maker
+from .gifts import *
+from .hot_leads import *
+from .init_db import *
+from .keys import *
+from .notifications import *
+from .payments import *
+from .referrals import *
+from .servers import *
+from .statistics import *
+from .tariffs import *
+from .temporary_data import *
+from .tracking_sources import *
+from .users import *

database/bans.py

@@ -0,0 +1,10 @@
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import BlockedUser
+
+
+async def create_blocked_user(session: AsyncSession, tg_id: int):
+    stmt = insert(BlockedUser).values(tg_id=tg_id).on_conflict_do_nothing(index_elements=[BlockedUser.tg_id])
+    await session.execute(stmt)
+    await session.commit()

database/coupons.py

@@ -0,0 +1,109 @@
+from datetime import datetime
+
+from sqlalchemy import case, delete, func, insert, select, update
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+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:
+    try:
+        exists = await session.scalar(select(Coupon.id).where(Coupon.code == code))
+        if exists:
+            logger.warning(f"[Coupon] ⚠️ Купон с кодом {code} уже существует.")
+            return False
+
+        await session.execute(
+            insert(Coupon).values(
+                code=code,
+                amount=amount,
+                usage_limit=usage_limit,
+                usage_count=0,
+                is_used=False,
+                days=days,
+            )
+        )
+        await session.commit()
+        logger.info(f"[Coupon] ✅ Купон {code} успешно создан.")
+        return True
+    except SQLAlchemyError as e:
+        await session.rollback()
+        logger.error(f"[Coupon] ❌ Ошибка при создании купона {code}: {e}")
+        return False
+
+
+async def get_coupon_by_code(session: AsyncSession, code: str) -> Coupon | None:
+    stmt = select(Coupon).where(Coupon.code == code)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def get_all_coupons(session: AsyncSession, page: int = 1, per_page: int = 10) -> dict:
+    offset = (page - 1) * per_page
+
+    stmt = select(Coupon).order_by(Coupon.id.desc()).offset(offset).limit(per_page)
+    result = await session.execute(stmt)
+    coupons = result.scalars().all()
+
+    count_stmt = select(func.count()).select_from(Coupon)
+    total = await session.scalar(count_stmt)
+    pages = -(-total // per_page)
+
+    return {
+        "coupons": [c.to_dict() for c in coupons],
+        "total": total,
+        "pages": pages,
+        "current_page": page,
+    }
+
+
+async def delete_coupon(session: AsyncSession, code: str) -> bool:
+    result = await session.execute(select(Coupon).where(Coupon.code == code))
+    coupon = result.scalar_one_or_none()
+
+    if not coupon:
+        logger.info(f"❌ Купон {code} не найден")
+        return False
+
+    await session.execute(delete(CouponUsage).where(CouponUsage.coupon_id == coupon.id))
+
+    await session.delete(coupon)
+    await session.commit()
+    logger.info(f"🗑 Купон {code} удалён вместе с его использованиями")
+    return True
+
+
+async def create_coupon_usage(session: AsyncSession, coupon_id: int, user_id: int):
+    try:
+        stmt = insert(CouponUsage).values(coupon_id=coupon_id, user_id=user_id, used_at=datetime.utcnow())
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"✅ Купон {coupon_id} использован пользователем {user_id}")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при сохранении использования купона: {e}")
+        await session.rollback()
+
+
+async def check_coupon_usage(session: AsyncSession, coupon_id: int, user_id: int) -> bool:
+    stmt = select(CouponUsage).where(CouponUsage.coupon_id == coupon_id, CouponUsage.user_id == user_id)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none() is not None
+
+
+async def update_coupon_usage_count(session: AsyncSession, coupon_id: int):
+    try:
+        await session.execute(
+            update(Coupon)
+            .where(Coupon.id == coupon_id)
+            .values(
+                usage_count=Coupon.usage_count + 1,
+                is_used=case((Coupon.usage_count + 1 >= Coupon.usage_limit, True), else_=False),
+            )
+        )
+        await session.commit()
+        logger.info(f"🔁 Обновлён счётчик купона {coupon_id}")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при обновлении купона {coupon_id}: {e}")
+        await session.rollback()

database/db.py

@@ -0,0 +1,11 @@
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import declarative_base
+
+from config import DATABASE_URL
+
+
+engine = create_async_engine(DATABASE_URL, echo=False, future=True, pool_size=20, max_overflow=30, pool_timeout=15)
+
+async_session_maker = async_sessionmaker(bind=engine, expire_on_commit=False, class_=AsyncSession)
+
+Base = declarative_base()

database/gifts.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+
+from sqlalchemy import insert
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Gift
+from logger import logger
+
+
+async def store_gift_link(
+    session: AsyncSession,
+    gift_id: str,
+    sender_tg_id: int,
+    selected_months: int,
+    expiry_time: datetime,
+    gift_link: str,
+    tariff_id: int | None = None,
+    is_unlimited: bool = False,
+    max_usages: int | None = None,
+):
+    try:
+        stmt = insert(Gift).values(
+            gift_id=gift_id,
+            sender_tg_id=sender_tg_id,
+            recipient_tg_id=None,
+            selected_months=selected_months,
+            expiry_time=expiry_time,
+            gift_link=gift_link,
+            created_at=datetime.utcnow(),
+            is_used=False,
+            tariff_id=tariff_id,
+            is_unlimited=is_unlimited,
+            max_usages=max_usages,
+        )
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"🎁 Подарок {gift_id} сохранён (tariff_id={tariff_id}, max_usages={max_usages})")
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при сохранении подарка {gift_id}: {e}")
+        await session.rollback()
+        return False

database/hot_leads.py

@@ -0,0 +1,24 @@
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Key, Payment, User
+
+
+async def get_hot_leads(session: AsyncSession):
+    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_(sub_active))
+    )
+
+    result = await session.execute(stmt)
+    return result.scalars().all()

database/importer.py

@@ -0,0 +1,123 @@
+import json
+import sqlite3
+import time
+
+from datetime import datetime
+from itertools import cycle
+
+from sqlalchemy import select
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config import USE_COUNTRY_SELECTION
+from database.models import Key, Server, User
+
+
+async def import_keys_from_3xui_db(db_path: str, session: AsyncSession) -> tuple[int, int]:
+    imported = 0
+    skipped = 0
+
+    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))
+            .distinct()
+        )
+
+    server_ids = [row[0] for row in result.fetchall()]
+    if not server_ids:
+        raise RuntimeError("❌ Не найдено доступных серверов или кластеров для 3x-ui")
+
+    server_cycle = cycle(server_ids)
+
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        cursor.execute("SELECT id, remark, settings FROM inbounds")
+        inbounds = cursor.fetchall()
+    except Exception as e:
+        raise RuntimeError(f"Не удалось прочитать SQLite: {e}")
+    finally:
+        conn.close()
+
+    parsed_clients = []
+    for inbound_id, _remark, settings_raw in inbounds:
+        try:
+            settings = json.loads(settings_raw)
+            clients = settings.get("clients", [])
+            for c in clients:
+                expiry = c.get("expiryTime")
+                c["expiryTime"] = int(float(expiry)) if expiry else 0
+                c["limitIp"] = int(c.get("limitIp", 0) or 0)
+                c["inbound_id"] = inbound_id
+                parsed_clients.append(c)
+        except Exception:
+            continue
+
+    now_ts = int(time.time() * 1000)
+
+    for c in parsed_clients:
+        tg_id = c.get("tgId")
+        client_id = str(c.get("id"))
+        email = c.get("email")
+        expiry_time = int(c.get("expiryTime") or now_ts)
+        created_at = now_ts
+        server_id = next(server_cycle)
+
+        if not tg_id or not client_id:
+            continue
+
+        user_exists = await session.execute(select(User).where(User.tg_id == tg_id))
+        if not user_exists.scalar():
+            try:
+                session.add(
+                    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(),
+                    )
+                )
+            except SQLAlchemyError:
+                continue
+
+        key_exists = await session.execute(select(Key).where(Key.client_id == client_id))
+        if key_exists.scalar():
+            skipped += 1
+            continue
+
+        try:
+            session.add(
+                Key(
+                    tg_id=tg_id,
+                    client_id=client_id,
+                    email=email,
+                    created_at=created_at,
+                    expiry_time=expiry_time,
+                    key="",
+                    server_id=server_id,
+                    remnawave_link=None,
+                    tariff_id=None,
+                    is_frozen=False,
+                    alias=None,
+                    notified=False,
+                    notified_24h=False,
+                )
+            )
+            imported += 1
+        except SQLAlchemyError:
+            continue
+
+    await session.commit()
+    return imported, skipped

database/init_db.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+
+from sqlalchemy import select
+
+from config import ADMIN_ID
+from database.db import async_session_maker, engine
+from database.models import Admin, Base, User
+from database.tariffs import initialize_all_tariff_weights
+
+
+async def init_db():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    async with async_session_maker() as session:
+        result = await session.execute(select(User).where(User.tg_id == 0))
+        if not result.scalar_one_or_none():
+            session.add(
+                User(
+                    tg_id=0,
+                    username="system",
+                    first_name="System",
+                    is_bot=True,
+                    created_at=datetime.utcnow(),
+                    updated_at=datetime.utcnow(),
+                )
+            )
+
+        for tg_id in ADMIN_ID:
+            result = await session.execute(select(Admin).where(Admin.tg_id == tg_id))
+            if not result.scalar_one_or_none():
+                session.add(
+                    Admin(
+                        tg_id=tg_id, role="superadmin", description="Imported from config", added_at=datetime.utcnow()
+                    )
+                )
+        await session.commit()
+
+        await initialize_all_tariff_weights(session)

database/keys.py

@@ -0,0 +1,201 @@
+from datetime import datetime
+
+from sqlalchemy import delete, func, select, text, update
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Key, User
+from logger import logger
+
+
+async def store_key(
+    session: AsyncSession,
+    tg_id: int,
+    client_id: str,
+    email: str,
+    expiry_time: int,
+    key: str,
+    server_id: str,
+    remnawave_link: str = None,
+    tariff_id: int = None,
+    alias: str = None,
+):
+    try:
+        exists = await session.execute(select(Key).where(Key.tg_id == tg_id, Key.client_id == client_id))
+        existing_key = exists.scalar_one_or_none()
+        
+        if existing_key:
+            await session.execute(
+                update(Key)
+                .where(Key.tg_id == tg_id, Key.client_id == client_id)
+                .values(
+                    email=email,
+                    expiry_time=expiry_time,
+                    key=key,
+                    server_id=server_id,
+                    remnawave_link=remnawave_link,
+                    tariff_id=tariff_id,
+                    alias=alias,
+                )
+            )
+            logger.info(f"[Store Key] Ключ обновлён: tg_id={tg_id}, client_id={client_id}, server_id={server_id}")
+        else:
+            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)
+            logger.info(f"[Store Key] Ключ создан: tg_id={tg_id}, client_id={client_id}, server_id={server_id}")
+        
+        await session.commit()
+
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при сохранении ключа: {e}")
+        await session.rollback()
+
+
+async def get_keys(session: AsyncSession, tg_id: int):
+    result = await session.execute(select(Key).where(Key.tg_id == tg_id))
+    return result.scalars().all()
+
+
+async def get_all_keys(session: AsyncSession):
+    result = await session.execute(select(Key))
+    return result.scalars().all()
+
+
+async def get_key_by_server(session: AsyncSession, tg_id: int, client_id: str):
+    stmt = select(Key).where(Key.tg_id == tg_id, Key.client_id == client_id)
+    result = await session.execute(stmt)
+    return result.scalar_one_or_none()
+
+
+async def get_key_details(session: AsyncSession, email: str) -> dict | None:
+    stmt = select(Key, User).join(User, Key.tg_id == User.tg_id).where(Key.email == email)
+    result = await session.execute(stmt)
+    row = result.first()
+    if not row:
+        return None
+
+    key, user = row
+    expiry_date = datetime.utcfromtimestamp(key.expiry_time / 1000)
+    current_date = datetime.utcnow()
+    time_left = expiry_date - current_date
+
+    if time_left.total_seconds() <= 0:
+        days_left_message = "<b>Ключ истек.</b>"
+    elif time_left.days > 0:
+        days_left_message = f"Осталось дней: <b>{time_left.days}</b>"
+    else:
+        hours_left = time_left.seconds // 3600
+        days_left_message = f"Осталось часов: <b>{hours_left}</b>"
+
+    return {
+        "key": key.key,
+        "remnawave_link": key.remnawave_link,
+        "server_id": key.server_id,
+        "created_at": key.created_at,
+        "expiry_time": key.expiry_time,
+        "client_id": key.client_id,
+        "tg_id": user.tg_id,
+        "email": key.email,
+        "is_frozen": key.is_frozen,
+        "balance": user.balance,
+        "alias": key.alias,
+        "expiry_date": expiry_date.strftime("%d %B %Y года %H:%M"),
+        "days_left_message": days_left_message,
+        "link": key.key or key.remnawave_link,
+        "cluster_name": key.server_id,
+        "location_name": key.server_id,
+        "tariff_id": key.tariff_id,
+    }
+
+
+async def get_key_count(session: AsyncSession, tg_id: int) -> int:
+    result = await session.execute(select(func.count()).select_from(Key).where(Key.tg_id == tg_id))
+    return result.scalar() or 0
+
+
+async def delete_key(session: AsyncSession, identifier: int | str):
+    stmt = delete(Key).where(Key.tg_id == identifier if str(identifier).isdigit() else Key.client_id == identifier)
+    await session.execute(stmt)
+    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))
+    await session.commit()
+    logger.info(f"Срок действия ключа {client_id} обновлён до {new_expiry_time}")
+
+
+async def get_client_id_by_email(session: AsyncSession, email: str):
+    result = await session.execute(select(Key.client_id).where(Key.email == email))
+    return result.scalar_one_or_none()
+
+
+async def update_key_notified(session: AsyncSession, tg_id: int, client_id: str):
+    await session.execute(update(Key).where(Key.tg_id == tg_id, Key.client_id == client_id).values(notified=True))
+    await session.commit()
+
+
+async def mark_key_as_frozen(session: AsyncSession, tg_id: int, client_id: str, time_left: int):
+    await session.execute(
+        text(
+            """
+            UPDATE keys
+            SET expiry_time = :expiry,
+                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):
+    await session.execute(
+        text(
+            """
+            UPDATE keys
+            SET expiry_time = :expiry,
+                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},
+    )
+
+
+async def update_key_tariff(session: AsyncSession, client_id: str, tariff_id: int):
+    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

database/models.py

@@ -0,0 +1,264 @@
+import secrets
+import uuid
+
+from datetime import datetime
+
+from sqlalchemy import (
+    JSON,
+    BigInteger,
+    Boolean,
+    Column,
+    DateTime,
+    Float,
+    ForeignKey,
+    Integer,
+    Numeric,
+    String,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, declarative_base, mapped_column, relationship
+
+
+Base = declarative_base()
+
+
+class DictLikeMixin:
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def get(self, key, default=None):
+        return getattr(self, key, default)
+
+    def to_dict(self):
+        return {column.name: getattr(self, column.name) for column in self.__table__.columns}
+
+
+class User(DictLikeMixin, Base):
+    __tablename__ = "users"
+
+    tg_id = Column(BigInteger, primary_key=True)
+    username = Column(String)
+    first_name = Column(String)
+    last_name = Column(String)
+    language_code = Column(String)
+    is_bot = Column(Boolean, default=False)
+    balance = Column(Float, default=0.0)
+    trial = Column(Integer, default=0)
+    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)
+
+
+class Key(DictLikeMixin, Base):
+    __tablename__ = "keys"
+
+    tg_id = Column(BigInteger, ForeignKey("users.tg_id"), nullable=False)
+    client_id = Column(String, primary_key=True)
+    email = Column(String, unique=True)
+    created_at = Column(BigInteger)
+    expiry_time = Column(BigInteger)
+    key = Column(String)
+    server_id = Column(String)
+    remnawave_link = Column(String)
+    tariff_id = Column(Integer, ForeignKey("tariffs.id", ondelete="SET NULL"))
+    is_frozen = Column(Boolean, default=False)
+    alias = Column(String)
+    notified = Column(Boolean, default=False)
+    notified_24h = Column(Boolean, default=False)
+
+
+class Tariff(DictLikeMixin, Base):
+    __tablename__ = "tariffs"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    group_code = Column(String)
+    duration_days = Column(Integer)
+    price_rub = Column(Integer)
+    traffic_limit = Column(BigInteger, nullable=True)
+    device_limit = Column(Integer, nullable=True)
+    is_active = Column(Boolean, default=True)
+    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)
+
+
+class Server(DictLikeMixin, Base):
+    __tablename__ = "servers"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    cluster_name = Column(String)
+    server_name = Column(String, unique=True)
+    api_url = Column(String)
+    subscription_url = Column(String)
+    inbound_id = Column(String)
+    panel_type = Column(String)
+    max_keys = Column(Integer)
+    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"
+
+    id = Column(Integer, primary_key=True)
+    tg_id = Column(BigInteger, ForeignKey("users.tg_id"))
+    amount = Column(Float)
+    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):
+    __tablename__ = "coupons"
+
+    id = Column(Integer, primary_key=True)
+    code = Column(String, unique=True)
+    amount = Column(Integer)
+    usage_limit = Column(Integer)
+    usage_count = Column(Integer, default=0)
+    is_used = Column(Boolean, default=False)
+    days = Column(Integer, nullable=True)
+
+
+class CouponUsage(DictLikeMixin, Base):
+    __tablename__ = "coupon_usages"
+
+    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)
+
+
+class Referral(DictLikeMixin, Base):
+    __tablename__ = "referrals"
+
+    referred_tg_id = Column(BigInteger, ForeignKey("users.tg_id", ondelete="CASCADE"), primary_key=True)
+    referrer_tg_id = Column(BigInteger, ForeignKey("users.tg_id", ondelete="CASCADE"), primary_key=True)
+    reward_issued = Column(Boolean, default=False)
+
+
+class Notification(DictLikeMixin, Base):
+    __tablename__ = "notifications"
+
+    tg_id = Column(BigInteger, ForeignKey("users.tg_id", ondelete="CASCADE"), primary_key=True)
+    notification_type = Column(String, primary_key=True)
+    last_notification_time = Column(DateTime, default=datetime.utcnow)
+
+
+class Gift(DictLikeMixin, Base):
+    __tablename__ = "gifts"
+
+    gift_id = Column(String, primary_key=True, default=lambda: uuid.uuid4().hex)
+    sender_tg_id = Column(BigInteger, ForeignKey("users.tg_id"))
+    recipient_tg_id = Column(BigInteger, ForeignKey("users.tg_id"), nullable=True)
+    selected_months = Column(Integer)
+    expiry_time = Column(DateTime)
+    gift_link = Column(String)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    is_used = Column(Boolean, default=False)
+    is_unlimited = Column(Boolean, default=False)
+    max_usages = Column(Integer, nullable=True)
+    tariff_id: Mapped[int | None] = mapped_column(ForeignKey("tariffs.id"))
+
+
+class GiftUsage(DictLikeMixin, Base):
+    __tablename__ = "gift_usages"
+
+    gift_id = Column(String, ForeignKey("gifts.gift_id"), primary_key=True)
+    tg_id = Column(BigInteger, primary_key=True)
+    used_at = Column(DateTime, default=datetime.utcnow)
+
+
+class ManualBan(DictLikeMixin, Base):
+    __tablename__ = "manual_bans"
+
+    tg_id = Column(BigInteger, primary_key=True)
+    banned_at = Column(DateTime(timezone=True), default=datetime.utcnow)
+    reason = Column(Text)
+    banned_by = Column(BigInteger)
+    until = Column(DateTime(timezone=True), nullable=True)
+
+
+class TemporaryData(DictLikeMixin, Base):
+    __tablename__ = "temporary_data"
+
+    tg_id = Column(BigInteger, primary_key=True)
+    state = Column(String)
+    data = Column(JSON)
+    updated_at = Column(DateTime, default=datetime.utcnow)
+
+
+class BlockedUser(DictLikeMixin, Base):
+    __tablename__ = "blocked_users"
+
+    tg_id = Column(BigInteger, primary_key=True)
+
+
+class TrackingSource(DictLikeMixin, Base):
+    __tablename__ = "tracking_sources"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    code = Column(String, unique=True)
+    type = Column(String)
+    created_by = Column(BigInteger)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class Admin(Base):
+    __tablename__ = "admins"
+
+    tg_id = Column(BigInteger, primary_key=True)
+    token = Column(String, unique=True, nullable=True)
+    description = Column(String, nullable=True)
+    role = Column(String, nullable=False, default="admin")
+    added_at = Column(DateTime, default=datetime.utcnow)
+
+    @staticmethod
+    def generate_token() -> str:
+        return secrets.token_urlsafe(32)

database/notifications.py

@@ -0,0 +1,168 @@
+from datetime import datetime, timedelta
+
+from sqlalchemy import and_, delete, func, select
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config import DISCOUNT_ACTIVE_HOURS
+from database.models import Key, Notification, User
+from logger import logger
+
+
+async def add_notification(session: AsyncSession, tg_id: int, notification_type: str):
+    try:
+        stmt = (
+            insert(Notification)
+            .values(
+                tg_id=tg_id,
+                notification_type=notification_type,
+                last_notification_time=datetime.utcnow(),
+            )
+            .on_conflict_do_update(
+                index_elements=[Notification.tg_id, Notification.notification_type],
+                set_={"last_notification_time": datetime.utcnow()},
+            )
+        )
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"✅ Добавлено уведомление {notification_type} для пользователя {tg_id}")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при добавлении уведомления: {e}")
+        await session.rollback()
+
+
+async def delete_notification(session: AsyncSession, tg_id: int, notification_type: str):
+    await session.execute(
+        delete(Notification).where(
+            Notification.tg_id == tg_id,
+            Notification.notification_type == notification_type,
+        )
+    )
+    await session.commit()
+    logger.debug(f"🗑 Уведомление {notification_type} для пользователя {tg_id} удалено")
+
+
+async def check_notification_time(session: AsyncSession, tg_id: int, notification_type: str, hours: int = 12) -> bool:
+    stmt = select(Notification.last_notification_time).where(
+        Notification.tg_id == tg_id, Notification.notification_type == notification_type
+    )
+    result = await session.execute(stmt)
+    last_time = result.scalar_one_or_none()
+    if not last_time:
+        return True
+    return datetime.utcnow() - last_time > timedelta(hours=hours)
+
+
+async def get_last_notification_time(session: AsyncSession, tg_id: int, notification_type: str) -> int | None:
+    stmt = select(Notification.last_notification_time).where(
+        Notification.tg_id == tg_id, Notification.notification_type == notification_type
+    )
+    result = await session.execute(stmt)
+    ts = result.scalar_one_or_none()
+    if ts:
+        return int(ts.timestamp() * 1000)
+    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
+
+        expires_at = last_time + timedelta(hours=DISCOUNT_ACTIVE_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}")
+        return {"available": False}
+
+
+async def check_notifications_bulk(
+    session: AsyncSession,
+    notification_type: str,
+    hours: int,
+    tg_ids: list[int] = None,
+    emails: list[str] = None,
+) -> list[dict]:
+    from sqlalchemy import select
+
+    from database.models import BlockedUser, Notification
+
+    try:
+        now = datetime.utcnow()
+        subq_last_notification = (
+            select(Notification.tg_id, func.max(Notification.last_notification_time).label("last_notification_time"))
+            .where(Notification.notification_type == notification_type)
+            .group_by(Notification.tg_id)
+            .subquery()
+        )
+
+        stmt = (
+            select(
+                User.tg_id,
+                Key.email,
+                User.username,
+                User.first_name,
+                User.last_name,
+                subq_last_notification.c.last_notification_time,
+            )
+            .outerjoin(Key, Key.tg_id == User.tg_id)
+            .outerjoin(subq_last_notification, subq_last_notification.c.tg_id == User.tg_id)
+        )
+
+        if notification_type == "inactive_trial":
+            stmt = stmt.where(
+                and_(
+                    User.trial.in_([0, -1]),
+                    ~User.tg_id.in_(select(BlockedUser.tg_id)),
+                    ~User.tg_id.in_(select(Key.tg_id.distinct())),
+                )
+            )
+
+        if tg_ids:
+            stmt = stmt.where(User.tg_id.in_(tg_ids))
+        if emails:
+            stmt = stmt.where(Key.email.in_(emails))
+
+        result = await session.execute(stmt)
+        users = []
+
+        for row in result:
+            last_time = row.last_notification_time
+            can_notify = not last_time or (now - last_time > timedelta(hours=hours))
+
+            if can_notify:
+                users.append({
+                    "tg_id": row.tg_id,
+                    "email": row.email,
+                    "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),
+                })
+
+        logger.info(f"Найдено {len(users)} пользователей, готовых к уведомлению типа {notification_type}")
+        return users
+
+    except Exception as e:
+        logger.error(f"Ошибка при массовой проверке уведомлений типа {notification_type}: {e}")
+        return []

database/payments.py

@@ -0,0 +1,165 @@
+from datetime import datetime, timedelta
+from typing import Optional
+
+from pytz import timezone
+from sqlalchemy import and_, insert, select, update
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Payment
+from logger import logger
+
+
+MOSCOW_TZ = timezone("Europe/Moscow")
+
+
+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=status,
+                created_at=now_moscow,
+                currency=currency,
+                payment_id=payment_id,
+                metadata_=metadata,
+                original_amount=original_amount,
+            )
+            .returning(Payment.id)
+        )
+        result = await session.execute(stmt)
+        internal_id = result.scalar_one()
+        await session.commit()
+        logger.info(
+            f"Добавлен платёж id={internal_id}: tg_id={tg_id}, amount={amount}, system={payment_system}, status={status}"
+        )
+        return internal_id
+    except SQLAlchemyError as e:
+        await session.rollback()
+        logger.error(f"Ошибка при добавлении платежа: {e}")
+        raise
+
+
+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.id == internal_id).limit(1))
+        payment = result.scalar_one_or_none()
+        if payment:
+            logger.info(f"Найден платёж id={internal_id}")
+            return dict(payment.__dict__)
+        logger.info(f"Платёж id={internal_id} не найден")
+        return None
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при поиске платежа id={internal_id}: {e}")
+        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 payment:
+            logger.info(f"Найден платёж payment_id={pid}")
+            return dict(payment.__dict__)
+        logger.info(f"Платёж payment_id={pid} не найден")
+        return None
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при поиске платежа payment_id={pid}: {e}")
+        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")
+        .returning(Payment.id)
+    )
+    res = await session.execute(stmt)
+    await session.commit()
+    return len(res.fetchall())

database/referrals.py

@@ -0,0 +1,241 @@
+from sqlalchemy import and_, desc, func, insert, select, text, update
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config import CHECK_REFERRAL_REWARD_ISSUED, REFERRAL_BONUS_PERCENTAGES
+from database.models import Referral
+from logger import logger
+
+
+async def add_referral(session: AsyncSession, referred_tg_id: int, referrer_tg_id: int):
+    try:
+        if referred_tg_id == referrer_tg_id:
+            logger.warning(f"⚠️ Попытка самореферала: {referred_tg_id}")
+            return
+
+        stmt = insert(Referral).values(referred_tg_id=referred_tg_id, referrer_tg_id=referrer_tg_id)
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"✅ Добавлена реферальная связь: {referred_tg_id} → {referrer_tg_id}")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при добавлении реферала: {e}")
+        await session.rollback()
+        raise
+
+
+async def get_referral_by_referred_id(session: AsyncSession, referred_tg_id: int) -> dict | None:
+    stmt = select(Referral).where(Referral.referred_tg_id == referred_tg_id)
+    result = await session.execute(stmt)
+    row = result.scalar_one_or_none()
+    return dict(row.__dict__) if row else None
+
+
+async def get_total_referrals(session: AsyncSession, referrer_tg_id: int) -> int:
+    stmt = select(func.count()).select_from(Referral).where(Referral.referrer_tg_id == referrer_tg_id)
+    result = await session.execute(stmt)
+    return result.scalar()
+
+
+async def get_active_referrals(session: AsyncSession, referrer_tg_id: int) -> int:
+    stmt = (
+        select(func.count())
+        .select_from(Referral)
+        .where(
+            and_(
+                Referral.referrer_tg_id == referrer_tg_id,
+                Referral.reward_issued is True,
+            )
+        )
+    )
+    result = await session.execute(stmt)
+    return result.scalar()
+
+
+async def mark_referral_reward_issued(session: AsyncSession, referred_tg_id: int):
+    await session.execute(update(Referral).where(Referral.referred_tg_id == referred_tg_id).values(reward_issued=True))
+    await session.commit()
+
+
+async def get_total_referral_bonus(session: AsyncSession, referrer_tg_id: int, max_levels: int) -> float:
+    if CHECK_REFERRAL_REWARD_ISSUED:
+        bonus_cte = """
+            WITH RECURSIVE
+            referral_levels AS (
+                SELECT 
+                    referred_tg_id, 
+                    referrer_tg_id, 
+                    1 AS level
+                FROM referrals 
+                WHERE referrer_tg_id = :tg_id AND reward_issued = TRUE
+                
+                UNION
+                
+                SELECT 
+                    r.referred_tg_id, 
+                    r.referrer_tg_id, 
+                    rl.level + 1
+                FROM referrals r
+                JOIN referral_levels rl ON r.referrer_tg_id = rl.referred_tg_id
+                WHERE rl.level < :max_levels AND r.reward_issued = TRUE
+            ),
+            earliest_payments AS (
+                SELECT DISTINCT ON (tg_id) tg_id, amount, created_at
+                FROM payments
+                WHERE status = 'success'
+                ORDER BY tg_id, created_at
+            )
+        """
+        bonus_query = (
+            bonus_cte
+            + f"""
+            SELECT 
+                COALESCE(SUM(
+                    CASE
+                        {
+                " ".join([
+                    f"WHEN rl.level = {level} THEN {REFERRAL_BONUS_PERCENTAGES[level]} * ep.amount"
+                    if isinstance(REFERRAL_BONUS_PERCENTAGES[level], float)
+                    else f"WHEN rl.level = {level} THEN {REFERRAL_BONUS_PERCENTAGES[level]}"
+                    for level in REFERRAL_BONUS_PERCENTAGES
+                ])
+            }
+                        ELSE 0 
+                    END
+                ), 0) AS total_bonus
+            FROM referral_levels rl
+            JOIN earliest_payments ep ON rl.referred_tg_id = ep.tg_id
+            WHERE rl.level <= :max_levels
+        """
+        )
+    else:
+        bonus_cte = """
+            WITH RECURSIVE
+            referral_levels AS (
+                SELECT 
+                    referred_tg_id, 
+                    referrer_tg_id, 
+                    1 AS level
+                FROM referrals 
+                WHERE referrer_tg_id = :tg_id
+                
+                UNION
+                
+                SELECT 
+                    r.referred_tg_id, 
+                    r.referrer_tg_id, 
+                    rl.level + 1
+                FROM referrals r
+                JOIN referral_levels rl ON r.referrer_tg_id = rl.referred_tg_id
+                WHERE rl.level < :max_levels
+            )
+        """
+        bonus_query = (
+            bonus_cte
+            + f"""
+            SELECT 
+                COALESCE(SUM(
+                    CASE
+                        {
+                " ".join([
+                    f"WHEN rl.level = {level} THEN {REFERRAL_BONUS_PERCENTAGES[level]} * p.amount"
+                    if isinstance(REFERRAL_BONUS_PERCENTAGES[level], float)
+                    else f"WHEN rl.level = {level} THEN {REFERRAL_BONUS_PERCENTAGES[level]}"
+                    for level in REFERRAL_BONUS_PERCENTAGES
+                ])
+            }
+                        ELSE 0 
+                    END
+                ), 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
+        """
+        )
+
+    result = await session.execute(text(bonus_query), {"tg_id": referrer_tg_id, "max_levels": max_levels})
+    total_bonus_raw = result.scalar()
+    total_bonus = round(float(total_bonus_raw or 0), 2)
+
+    logger.debug(f"Получена общая сумма бонусов от рефералов: {total_bonus}")
+    return total_bonus
+
+
+async def get_referrals_by_level(session: AsyncSession, referrer_tg_id: int, max_levels: int) -> dict:
+    query = """
+        WITH RECURSIVE referral_levels AS (
+            SELECT referred_tg_id, referrer_tg_id, 1 AS level 
+            FROM referrals 
+            WHERE referrer_tg_id = :referrer_tg_id
+            UNION
+            SELECT r.referred_tg_id, r.referrer_tg_id, rl.level + 1
+            FROM referrals r
+            JOIN referral_levels rl ON r.referrer_tg_id = rl.referred_tg_id
+            WHERE rl.level < :max_levels
+        )
+        SELECT level, 
+               COUNT(*) AS level_count, 
+               COUNT(CASE WHEN reward_issued THEN 1 END) AS active_level_count
+        FROM referral_levels rl
+        JOIN referrals r ON rl.referred_tg_id = r.referred_tg_id
+        GROUP BY level
+        ORDER BY level
+    """
+    result = await session.execute(text(query), {"referrer_tg_id": referrer_tg_id, "max_levels": max_levels})
+    return {
+        row["level"]: {
+            "total": row["level_count"],
+            "active": row["active_level_count"],
+        }
+        for row in result.mappings()
+    }
+
+
+async def get_referral_stats(session: AsyncSession, referrer_tg_id: int):
+    try:
+        logger.info(f"[ReferralStats] Получение статистики для пользователя {referrer_tg_id}")
+
+        total_referrals = await get_total_referrals(session, referrer_tg_id)
+        active_referrals = await get_active_referrals(session, referrer_tg_id)
+        max_levels = len(REFERRAL_BONUS_PERCENTAGES)
+        referrals_by_level = await get_referrals_by_level(session, referrer_tg_id, max_levels)
+        total_referral_bonus = await get_total_referral_bonus(session, referrer_tg_id, max_levels)
+
+        return {
+            "total_referrals": total_referrals,
+            "active_referrals": active_referrals,
+            "referrals_by_level": referrals_by_level,
+            "total_referral_bonus": total_referral_bonus,
+        }
+
+    except Exception as e:
+        logger.error(f"[ReferralStats] Ошибка при получении статистики для пользователя {referrer_tg_id}: {e}")
+        raise
+
+
+async def get_user_referral_count(session: AsyncSession, tg_id: int) -> int:
+    result = await session.execute(select(func.count()).select_from(Referral).where(Referral.referrer_tg_id == tg_id))
+    return result.scalar_one() or 0
+
+
+async def get_referral_position(session: AsyncSession, referral_count: int) -> int:
+    subq = (
+        select(Referral.referrer_tg_id)
+        .group_by(Referral.referrer_tg_id)
+        .having(func.count() > referral_count)
+        .subquery()
+    )
+    query = select(func.count()).select_from(subq)
+    result = await session.execute(query)
+    count = result.scalar() or 0
+    return count + 1
+
+
+async def get_top_referrals(session: AsyncSession, limit: int = 5):
+    query = (
+        select(Referral.referrer_tg_id, func.count().label("referral_count"))
+        .group_by(Referral.referrer_tg_id)
+        .order_by(desc("referral_count"))
+        .limit(limit)
+    )
+    result = await session.execute(query)
+    return [{"referrer_tg_id": row.referrer_tg_id, "referral_count": row.referral_count} for row in result.all()]

database/servers.py

@@ -0,0 +1,315 @@
+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, ServerSpecialgroup, ServerSubgroup, Tariff
+from logger import logger
+
+
+async def create_server(
+    session: AsyncSession,
+    cluster_name: str,
+    server_name: str,
+    api_url: str,
+    subscription_url: str,
+    inbound_id: str,
+):
+    try:
+        stmt = insert(Server).values(
+            cluster_name=cluster_name,
+            server_name=server_name,
+            api_url=api_url,
+            subscription_url=subscription_url,
+            inbound_id=inbound_id,
+        )
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"✅ Сервер {server_name} добавлен в кластер {cluster_name}")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при добавлении сервера {server_name}: {e}")
+        await session.rollback()
+        raise
+
+
+async def delete_server(session: AsyncSession, server_name: str):
+    try:
+        stmt = delete(Server).where(Server.server_name == server_name)
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"🗑 Сервер {server_name} удалён")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при удалении сервера {server_name}: {e}")
+        await session.rollback()
+        raise
+
+
+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 = {}
+        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():
+                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,
+                "subscription_url": s.subscription_url,
+                "inbound_id": s.inbound_id,
+                "panel_type": s.panel_type,
+                "enabled": s.enabled,
+                "max_keys": s.max_keys,
+                "tariff_group": s.tariff_group,
+                "tariff_subgroups": subs_map.get(s.id, []),
+                "special_groups": special,
+                "cluster_name": cluster,
+            })
+        return grouped
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при получении серверов: {e}")
+        return {}
+
+
+async def get_clusters(session: AsyncSession) -> list[str]:
+    stmt = select(Server.cluster_name).distinct().order_by(Server.cluster_name)
+    result = await session.execute(stmt)
+    return [r[0] for r in result.all()]
+
+
+async def check_unique_server_name(session: AsyncSession, server_name: str, cluster_name: str | None = None) -> bool:
+    stmt = select(Server).where(Server.server_name == server_name)
+    if cluster_name:
+        stmt = stmt.where(Server.cluster_name == cluster_name)
+    result = await session.execute(stmt.limit(1))
+    return result.scalar_one_or_none() is None
+
+
+async def check_server_name_by_cluster(session: AsyncSession, server_name: str) -> dict | None:
+    try:
+        result = await session.execute(select(Server.cluster_name).where(Server.server_name == server_name))
+        row = result.first()
+        return {"cluster_name": row[0]} if row else None
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при поиске кластера для сервера {server_name}: {e}")
+        return None
+
+
+async def get_cluster_name_by_server(session: AsyncSession, server_id_or_name: str) -> str | None:
+    stmt = (
+        select(Server.cluster_name)
+        .where((Server.id == server_id_or_name) | (Server.server_name == server_id_or_name))
+        .limit(1)
+    )
+
+    result = await session.execute(stmt)
+    row = result.scalar_one_or_none()
+    return row
+
+
+async def get_server_by_name(session: AsyncSession, server_name: str) -> dict | None:
+    try:
+        stmt = select(Server).where(Server.server_name == server_name)
+        result = await session.execute(stmt)
+        server = result.scalar_one_or_none()
+
+        if server:
+            return {
+                "id": server.id,
+                "cluster_name": server.cluster_name,
+                "server_name": server.server_name,
+                "api_url": server.api_url,
+                "subscription_url": server.subscription_url,
+                "inbound_id": server.inbound_id,
+                "panel_type": server.panel_type,
+                "enabled": server.enabled,
+                "max_keys": server.max_keys,
+                "tariff_group": server.tariff_group,
+            }
+        return None
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при получении сервера {server_name}: {e}")
+        return None
+
+
+async def update_server_field(session: AsyncSession, server_name: str, field: str, value: any) -> bool:
+    try:
+        stmt = update(Server).where(Server.server_name == server_name).values(**{field: value})
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"✅ Поле {field} сервера {server_name} обновлено на {value}")
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при обновлении поля {field} сервера {server_name}: {e}")
+        await session.rollback()
+        return False
+
+
+async def update_server_name_with_keys(session: AsyncSession, old_name: str, new_name: str) -> bool:
+    try:
+        from sqlalchemy import update
+
+        from database.models import Key
+
+        if not await check_unique_server_name(session, new_name):
+            logger.error(f"❌ Сервер с именем {new_name} уже существует")
+            return False
+
+        stmt_server = update(Server).where(Server.server_name == old_name).values(server_name=new_name)
+        await session.execute(stmt_server)
+
+        stmt_keys = update(Key).where(Key.server_id == old_name).values(server_id=new_name)
+        await session.execute(stmt_keys)
+
+        await session.commit()
+        logger.info(f"✅ Сервер переименован с {old_name} на {new_name}")
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при переименовании сервера {old_name}: {e}")
+        await session.rollback()
+        return False
+
+
+async def get_available_clusters(session: AsyncSession) -> list[str]:
+    try:
+        stmt = select(Server.cluster_name).distinct().order_by(Server.cluster_name)
+        result = await session.execute(stmt)
+        return [row[0] for row in result.all()]
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при получении списка кластеров: {e}")
+        return []
+
+
+async def update_server_cluster(session: AsyncSession, server_name: str, new_cluster: str) -> bool:
+    try:
+        server_data = await get_server_by_name(session, server_name)
+        if not server_data:
+            return False
+
+        old_cluster = server_data["cluster_name"]
+
+        stmt_remaining = select(func.count()).where(
+            (Server.cluster_name == old_cluster) & (Server.server_name != server_name)
+        )
+        result = await session.execute(stmt_remaining)
+        remaining_servers = result.scalar_one()
+
+        if remaining_servers == 0:
+            stmt_update_keys = update(Key).where(Key.server_id == old_cluster).values(server_id=new_cluster)
+            await session.execute(stmt_update_keys)
+
+        stmt_new_cluster = select(Server.tariff_group).where(Server.cluster_name == new_cluster).limit(1)
+        result = await session.execute(stmt_new_cluster)
+        new_tariff_group = result.scalar_one_or_none()
+
+        await session.execute(
+            update(Server)
+            .where(Server.server_name == server_name)
+            .values(cluster_name=new_cluster, tariff_group=new_tariff_group)
+        )
+
+        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
+) -> list:
+    names = [s.get("server_name") for s in cluster if s.get("server_name")]
+    if not names:
+        return []
+
+    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]
+
+    total_for_subgroup = await session.scalar(
+        select(func.count()).select_from(ServerSubgroup).where(ServerSubgroup.subgroup_title == target_subgroup)
+    )
+    if not total_for_subgroup:
+        logger.info(f"Для подгруппы {target_subgroup} нет ни одного сервера. Используем весь кластер {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

database/statistics.py

@@ -0,0 +1,141 @@
+from datetime import date, datetime
+
+from sqlalchemy import and_, exists, func, not_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Key, Payment, Referral, Tariff, User
+
+
+async def count_total_users(session: AsyncSession) -> int:
+    return await session.scalar(select(func.count()).select_from(User))
+
+
+async def count_users_updated_today(session: AsyncSession, today: date) -> int:
+    return await session.scalar(select(func.count()).select_from(User).where(User.updated_at >= today))
+
+
+async def count_users_registered_since(session: AsyncSession, since: date) -> int:
+    return await session.scalar(select(func.count()).select_from(User).where(User.created_at >= since))
+
+
+async def count_users_registered_between(session: AsyncSession, start: date, end: date) -> int:
+    return await session.scalar(
+        select(func.count()).select_from(User).where(User.created_at >= start, User.created_at < end)
+    )
+
+
+async def count_total_keys(session: AsyncSession) -> int:
+    return await session.scalar(select(func.count()).select_from(Key))
+
+
+async def count_active_keys(session: AsyncSession) -> int:
+    current_time_ms = int(datetime.utcnow().timestamp() * 1000)
+    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:
+    trial_tariffs_subquery = select(Tariff.id).where(Tariff.group_code == "trial")
+
+    return await session.scalar(select(func.count()).select_from(Key).where(Key.tariff_id.in_(trial_tariffs_subquery)))
+
+
+async def get_tariff_distribution(
+    session: AsyncSession, include_unbound: bool = False
+) -> tuple[list[tuple[int, int]], list[dict]]:
+    result = await session.execute(
+        select(Key.tariff_id, func.count(Key.client_id)).where(Key.tariff_id.isnot(None)).group_by(Key.tariff_id)
+    )
+    tariff_counts = result.all()
+
+    if not include_unbound:
+        return tariff_counts
+
+    result = await session.execute(select(Key.expiry_time).where(Key.tariff_id.is_(None)))
+    no_tariff_keys = [{"expiry_time": row[0]} for row in result.all()]
+
+    return tariff_counts, no_tariff_keys
+
+
+async def get_tariff_names(session: AsyncSession, tariff_ids: list[int]) -> dict[int, str]:
+    if not tariff_ids:
+        return {}
+
+    result = await session.execute(select(Tariff.id, Tariff.name).where(Tariff.id.in_(tariff_ids)))
+    return dict(result.all())
+
+
+async def get_tariff_groups(session: AsyncSession, tariff_ids: list[int]) -> dict[int, str]:
+    if not tariff_ids:
+        return {}
+
+    result = await session.execute(select(Tariff.id, Tariff.group_code).where(Tariff.id.in_(tariff_ids)))
+    return dict(result.all())
+
+
+async def get_tariff_durations(session: AsyncSession, tariff_ids: list[int]) -> dict[int, int]:
+    if not tariff_ids:
+        return {}
+
+    result = await session.execute(select(Tariff.id, Tariff.duration_days).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))
+
+
+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.status == "success",
+                Payment.payment_system.notin_(["referral", "coupon", "cashback"]),
+            )
+        )
+    )
+    return round(float(result), 2)
+
+
+async def sum_payments_between(session: AsyncSession, start: date, end: date) -> float:
+    result = await session.scalar(
+        select(func.coalesce(func.sum(Payment.amount), 0)).where(
+            and_(
+                Payment.created_at >= start,
+                Payment.created_at < end,
+                Payment.status == "success",
+                Payment.payment_system.notin_(["referral", "coupon", "cashback"]),
+            )
+        )
+    )
+    return round(float(result), 2)
+
+
+async def sum_total_payments(session: AsyncSession) -> float:
+    result = await session.scalar(
+        select(func.coalesce(func.sum(Payment.amount), 0)).where(
+            and_(
+                Payment.status == "success",
+                Payment.payment_system.notin_(["referral", "coupon", "cashback"]),
+            )
+        )
+    )
+    return round(float(result), 2)
+
+
+async def count_hot_leads(session: AsyncSession) -> int:
+    subquery_active_keys = (
+        select(Key.tg_id).where(Key.expiry_time > int(datetime.utcnow().timestamp() * 1000)).distinct()
+    )
+
+    stmt = (
+        select(Payment.tg_id)
+        .where(Payment.amount > 0)
+        .where(Payment.status == "success")
+        .where(Payment.payment_system.notin_(["referral", "coupon", "cashback"]))
+        .where(not_(exists(subquery_active_keys.where(Key.tg_id == Payment.tg_id))))
+        .distinct()
+    )
+
+    result = await session.execute(select(func.count()).select_from(stmt.subquery()))
+    return result.scalar()

database/tariffs.py

@@ -0,0 +1,266 @@
+import hashlib
+
+from collections import defaultdict
+from datetime import datetime
+
+from sqlalchemy import delete, func, insert, select, update
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Server, Tariff
+from logger import logger
+
+
+def create_subgroup_hash(subgroup_title: str, group_code: str) -> str:
+    if not subgroup_title:
+        return ""
+
+    unique_key = f"{subgroup_title}:{group_code}"
+    hash_object = hashlib.md5(unique_key.encode("utf-8"))
+    return hash_object.hexdigest()[:8]
+
+
+async def find_subgroup_by_hash(session: AsyncSession, subgroup_hash: str, group_code: str) -> str | None:
+    result = await session.execute(
+        select(Tariff.subgroup_title)
+        .where(Tariff.group_code == group_code, Tariff.subgroup_title.isnot(None))
+        .distinct()
+    )
+    subgroups = [row[0] for row in result.fetchall()]
+
+    for subgroup_title in subgroups:
+        if create_subgroup_hash(subgroup_title, group_code) == subgroup_hash:
+            return subgroup_title
+
+    return 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.sort_order, Tariff.id)
+            )
+        else:
+            result = await session.execute(select(Tariff).order_by(Tariff.sort_order, Tariff.id))
+
+        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}")
+        return []
+
+
+async def get_tariff_by_id(session: AsyncSession, tariff_id: int):
+    try:
+        result = await session.execute(select(Tariff).where(Tariff.id == tariff_id))
+        tariff = result.scalar_one_or_none()
+        return dict(tariff.__dict__) if tariff else None
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при получении тарифа по ID {tariff_id}: {e}")
+        return None
+
+
+async def get_tariffs_for_cluster(session: AsyncSession, cluster_name: str):
+    try:
+        server_row = await session.execute(
+            select(Server.tariff_group).where(Server.cluster_name == cluster_name).limit(1)
+        )
+        row = server_row.first()
+
+        if not row:
+            server_row = await session.execute(
+                select(Server.tariff_group).where(Server.server_name == cluster_name).limit(1)
+            )
+            row = server_row.first()
+
+        if not row or not row[0]:
+            return []
+
+        group_code = row[0]
+        result = await session.execute(
+            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:
+        logger.error(f"[TARIFF] Ошибка при получении тарифов для кластера {cluster_name}: {e}")
+        return []
+
+
+async def create_tariff(session: AsyncSession, data: dict):
+    try:
+        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()
+        return result.scalar_one()
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при создании тарифа: {e}")
+        await session.rollback()
+        return None
+
+
+async def update_tariff(session: AsyncSession, tariff_id: int, updates: dict):
+    if not updates:
+        return False
+    try:
+        updates["updated_at"] = datetime.utcnow()
+        await session.execute(update(Tariff).where(Tariff.id == tariff_id).values(**updates))
+        await session.commit()
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при обновлении тарифа ID={tariff_id}: {e}")
+        await session.rollback()
+        return False
+
+
+async def delete_tariff(session: AsyncSession, tariff_id: int):
+    try:
+        await session.execute(delete(Tariff).where(Tariff.id == tariff_id))
+        await session.commit()
+        return True
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при удалении тарифа ID={tariff_id}: {e}")
+        await session.rollback()
+        return False
+
+
+async def check_tariff_exists(session: AsyncSession, tariff_id: int):
+    try:
+        result = await session.execute(select(Tariff).where(Tariff.id == tariff_id, Tariff.is_active.is_(True)))
+        tariff = result.scalar_one_or_none()
+        if tariff:
+            return True
+        logger.warning(f"[TARIFF] Тариф {tariff_id} не найден в БД")
+        return False
+    except SQLAlchemyError as e:
+        logger.error(f"[TARIFF] Ошибка при проверке тарифа {tariff_id}: {e}")
+        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}")
+        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

database/temporary_data.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+from sqlalchemy import delete, select
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import TemporaryData
+from logger import logger
+
+
+async def create_temporary_data(session: AsyncSession, tg_id: int, state: str, data: dict):
+    try:
+        stmt = (
+            insert(TemporaryData)
+            .values(tg_id=tg_id, state=state, data=data, updated_at=datetime.utcnow())
+            .on_conflict_do_update(
+                index_elements=[TemporaryData.tg_id],
+                set_={"state": state, "data": data, "updated_at": datetime.utcnow()},
+            )
+        )
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"📝 Временные данные сохранены для {tg_id}")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при сохранении временных данных для {tg_id}: {e}")
+        await session.rollback()
+
+
+async def get_temporary_data(session: AsyncSession, tg_id: int) -> dict | None:
+    stmt = select(TemporaryData).where(TemporaryData.tg_id == tg_id)
+    result = await session.execute(stmt)
+    row = result.scalar_one_or_none()
+    if row:
+        return {"state": row.state, "data": row.data}
+    return None
+
+
+async def clear_temporary_data(session: AsyncSession, tg_id: int):
+    await session.execute(delete(TemporaryData).where(TemporaryData.tg_id == tg_id))
+    await session.commit()
+    logger.info(f"🗑 Временные данные очищены для {tg_id}")

database/tracking_sources.py

@@ -0,0 +1,252 @@
+from sqlalchemy import and_, func, insert, not_, select
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from database.models import Payment, TrackingSource, User
+from logger import logger
+
+
+EXCLUDED_PAYMENT_MARKERS = ["coupon", "referral", "cashback"]
+
+
+async def create_tracking_source(session: AsyncSession, name: str, code: str, type_: str, created_by: int):
+    try:
+        stmt = insert(TrackingSource).values(
+            name=name,
+            code=code,
+            type=type_,
+            created_by=created_by,
+        )
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"🆕 Источник трафика {code} создан")
+    except SQLAlchemyError as e:
+        logger.error(f"❌ Ошибка при создании источника {code}: {e}")
+        await session.rollback()
+
+
+async def get_all_tracking_sources(session: AsyncSession) -> list[dict]:
+    registrations_subq = (
+        select(func.count(func.distinct(User.tg_id)))
+        .where(User.source_code == TrackingSource.code)
+        .correlate(TrackingSource)
+        .scalar_subquery()
+    )
+
+    trials_subq = (
+        select(func.count(func.distinct(User.tg_id)))
+        .where((User.source_code == TrackingSource.code) & (User.trial == 1))
+        .correlate(TrackingSource)
+        .scalar_subquery()
+    )
+
+    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"))
+        .correlate(TrackingSource)
+        .scalar_subquery()
+    )
+
+    query = select(
+        TrackingSource.code,
+        TrackingSource.name,
+        TrackingSource.created_at,
+        registrations_subq.label("registrations"),
+        trials_subq.label("trials"),
+        payments_subq.label("payments"),
+    ).order_by(TrackingSource.created_at.desc())
+
+    result = await session.execute(query)
+    rows = result.all()
+    return [
+        {
+            "code": r.code,
+            "name": r.name,
+            "created_at": r.created_at,
+            "registrations": r.registrations or 0,
+            "trials": r.trials or 0,
+            "payments": r.payments or 0,
+        }
+        for r in rows
+    ]
+
+
+async def get_tracking_source_stats(session: AsyncSession, code: str) -> dict | None:
+    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
+
+    _src_name, _src_code, created_at = src
+
+    reg_subq = (
+        select(func.count(func.distinct(User.tg_id)))
+        .where((User.source_code == code) & (User.created_at >= created_at))
+        .scalar_subquery()
+    )
+
+    trial_subq = (
+        select(func.count(func.distinct(User.tg_id)))
+        .where((User.source_code == code) & (User.trial == 1) & (User.created_at >= created_at))
+        .scalar_subquery()
+    )
+
+    payments_subq = (
+        select(func.count(func.distinct(Payment.tg_id)))
+        .join(User, Payment.tg_id == User.tg_id)
+        .where(
+            (User.source_code == code)
+            & (Payment.status == "success")
+            & not_(Payment.payment_system.in_(EXCLUDED_PAYMENT_MARKERS))
+            & (Payment.created_at >= created_at)
+        )
+        .scalar_subquery()
+    )
+
+    amount_subq = (
+        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_(EXCLUDED_PAYMENT_MARKERS))
+            & (Payment.created_at >= created_at)
+        )
+        .scalar_subquery()
+    )
+
+    header_q = select(
+        TrackingSource.name,
+        TrackingSource.code,
+        TrackingSource.created_at,
+        reg_subq.label("registrations"),
+        trial_subq.label("trials"),
+        payments_subq.label("payments"),
+        amount_subq.label("total_amount"),
+    ).where(TrackingSource.code == code)
+
+    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")
+            & not_(Payment.payment_system.in_(EXCLUDED_PAYMENT_MARKERS))
+            & (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,
+        "created_at": row.created_at,
+        "registrations": row.registrations or 0,
+        "trials": row.trials or 0,
+        "payments": row.payments or 0,
+        "total_amount": float(row.total_amount or 0),
+        "monthly": monthly,
+    }

database/users.py

@@ -0,0 +1,237 @@
+from datetime import datetime
+
+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
+
+from database.keys import delete_key
+from database.models import (
+    BlockedUser,
+    CouponUsage,
+    Gift,
+    GiftUsage,
+    Key,
+    Notification,
+    Payment,
+    Referral,
+    TemporaryData,
+    User,
+)
+from logger import logger
+
+
+async def add_user(
+    session: AsyncSession,
+    tg_id: int,
+    username: str = None,
+    first_name: str = None,
+    last_name: str = None,
+    language_code: str = None,
+    is_bot: bool = False,
+    source_code: str = None,
+):
+    try:
+        stmt = (
+            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,
+                source_code=source_code,
+            )
+            .on_conflict_do_nothing(index_elements=[User.tg_id])
+        )
+        await session.execute(stmt)
+        await session.commit()
+        logger.info(f"[DB] Новый пользователь добавлен: {tg_id} (source: {source_code})")
+    except SQLAlchemyError as e:
+        logger.error(f"[DB] Ошибка при добавлении пользователя {tg_id}: {e}")
+        await session.rollback()
+        raise
+
+
+async def update_balance(session: AsyncSession, tg_id: int, amount: float) -> None:
+    try:
+        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()
+        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()
+
+
+async def check_user_exists(session: AsyncSession, tg_id: int) -> bool:
+    stmt = select(exists().where(User.tg_id == tg_id))
+    result = await session.execute(stmt)
+    return result.scalar()
+
+
+async def get_balance(session: AsyncSession, tg_id: int) -> float:
+    result = await session.execute(select(func.coalesce(User.balance, 0.0)).where(User.tg_id == tg_id))
+    return round(float(result.scalar_one()), 1)
+
+
+async def set_user_balance(session: AsyncSession, tg_id: int, balance: float) -> None:
+    try:
+        await session.execute(update(User).where(User.tg_id == tg_id).values(balance=balance))
+        await session.commit()
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при установке баланса для пользователя {tg_id}: {e}")
+        await session.rollback()
+
+
+async def update_trial(session: AsyncSession, tg_id: int, status: int):
+    try:
+        await session.execute(update(User).where(User.tg_id == tg_id).values(trial=status))
+        await session.commit()
+        logger.info(f"[DB] Триал статус обновлён для пользователя {tg_id}: {status}")
+    except SQLAlchemyError as e:
+        logger.error(f"[DB] Ошибка при обновлении триала пользователя {tg_id}: {e}")
+        await session.rollback()
+
+
+async def get_trial(session: AsyncSession, tg_id: int) -> int:
+    result = await session.execute(select(func.coalesce(User.trial, 0)).where(User.tg_id == tg_id))
+    return int(result.scalar_one())
+
+
+async def upsert_user(
+    session: AsyncSession,
+    tg_id: int,
+    username: str = None,
+    first_name: str = None,
+    last_name: str = None,
+    language_code: str = None,
+    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
+            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,
+                    is_bot=is_bot,
+                    updated_at=datetime.utcnow(),
+                )
+            )
+            await session.commit()
+            result = await session.execute(select(User).where(User.tg_id == tg_id))
+            return dict(result.scalar_one().__dict__)
+        else:
+            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=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(),
+                    },
+                )
+                .returning(User)
+            )
+            obj = res.scalar_one()
+            await session.commit()
+            d = obj.__dict__.copy()
+            d.pop("_sa_instance_state", None)
+            return d
+    except SQLAlchemyError as e:
+        logger.error(f"[DB] Ошибка при UPSERT пользователя {tg_id}: {e}")
+        await session.rollback()
+        raise
+
+
+async def delete_user_data(session: AsyncSession, tg_id: int):
+    try:
+        await session.execute(delete(Notification).where(Notification.tg_id == tg_id))
+        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 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}")
+        raise
+
+
+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:
+    res = await session.execute(
+        select(func.coalesce(User.trial, 0), func.count(Key.client_id))
+        .select_from(User)
+        .join(Key, Key.tg_id == User.tg_id, isouter=True)
+        .where(User.tg_id == tg_id)
+        .group_by(User.tg_id, User.trial)
+    )
+    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) -> None:
+    if not source_code:
+        return
+    stmt = (
+        insert(User)
+        .values(tg_id=tg_id, source_code=source_code)
+        .on_conflict_do_update(
+            index_elements=[User.tg_id],
+            set_={"source_code": insert(User).excluded.source_code},
+            where=(User.source_code.is_(None)),
+        )
+    )
+    await session.execute(stmt)
+    await session.commit()

filters/admin.py

@@ -1,12 +1,17 @@
 from aiogram.filters import BaseFilter
-from aiogram.types import Message
+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
 
 
 class IsAdminFilter(BaseFilter):
-    async def __call__(self, message: Message) -> bool:
+    async def __call__(self, event: Message | CallbackQuery) -> bool:
         try:
-            return message.from_user.id in ADMIN_ID
+            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:
             return False

handlers/__init__.py

@@ -9,9 +9,9 @@ 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
 
 
@@ -21,7 +21,6 @@ router.include_routers(
     start_router,
     captcha_router,
     profile_router,
-    pay_router,
     donate_router,
     coupons_router,
     notifications_router,
@@ -29,4 +28,5 @@ router.include_routers(
     keys_router,
     instructions_router,
     admin_router,
+    refferal_router,
 )

handlers/admin/__init__.py

@@ -2,22 +2,27 @@ __all__ = ("router",)
 
 from aiogram import Router
 
+from .ads import router as ads_router
 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 .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 .stats import router as stats_router
+from .tariffs import router as tariffs_router
 from .users import router as users_router
 
 
 router = Router(name="admins_main_router")
 
 router.include_routers(
+    modules_router,
     panel_router,
     management_router,
     servers_router,
@@ -29,4 +34,7 @@ router.include_routers(
     coupons_router,
     restart_router,
     bans_router,
+    ads_router,
+    tariffs_router,
+    gifts_router,
 )

handlers/admin/ads/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ("router",)
+
+from .ads_handler import router

handlers/admin/ads/ads_handler.py

@@ -0,0 +1,194 @@
+import re
+
+from datetime import datetime
+
+import pytz
+
+from aiogram import F, Router
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+from sqlalchemy import delete, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config import USERNAME_BOT
+from database import create_tracking_source, get_tracking_source_stats
+from database.models import TrackingSource, User
+from filters.admin import IsAdminFilter
+from logger import logger
+
+from ..panel.keyboard import AdminPanelCallback
+from .keyboard import (
+    AdminAdsCallback,
+    build_ads_delete_confirm_kb,
+    build_ads_kb,
+    build_ads_list_kb,
+    build_ads_stats_kb,
+    build_cancel_input_kb,
+)
+
+
+router = Router()
+
+
+class AdminAdsState(StatesGroup):
+    waiting_for_new_name = State()
+    waiting_for_new_code = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "ads"), IsAdminFilter())
+async def handle_ads_menu(callback_query: CallbackQuery):
+    await callback_query.message.edit_text(text="📊 <b>Аналитика рекламы:</b>", reply_markup=build_ads_kb())
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "create"), IsAdminFilter())
+async def handle_ads_create(callback_query: CallbackQuery, state: FSMContext):
+    await state.set_state(AdminAdsState.waiting_for_new_name)
+    await callback_query.message.edit_text(
+        "📝 Введите <b>название</b> новой ссылки:", reply_markup=build_cancel_input_kb()
+    )
+
+
+@router.message(AdminAdsState.waiting_for_new_name, IsAdminFilter())
+async def handle_ads_name_input(message: Message, state: FSMContext):
+    name = message.text.strip()
+    await state.update_data(name=name)
+    await state.set_state(AdminAdsState.waiting_for_new_code)
+    await message.answer(
+        f"🔗 Введите <b>код ссылки</b> для: <code>{name}</code>.\n\n💡 <b>Правила:</b> только латинские буквы и цифры",
+        reply_markup=build_cancel_input_kb(),
+    )
+
+
+@router.message(AdminAdsState.waiting_for_new_code, IsAdminFilter())
+async def handle_ads_code_input(message: Message, state: FSMContext, session: AsyncSession):
+    code = message.text.strip()
+    data = await state.get_data()
+    name = data["name"]
+
+    if not re.match(r"^[a-zA-Z0-9]+$", code):
+        await message.answer(
+            "❌ Код может содержать только латинские буквы и цифры\nВведите код заново:",
+            reply_markup=build_cancel_input_kb(),
+        )
+        return
+
+    code_with_prefix = f"utm_{code}"
+
+    try:
+        await create_tracking_source(
+            name=name,
+            code=code_with_prefix,
+            type_="utm",
+            created_by=message.from_user.id,
+            session=session,
+        )
+        stats = await get_tracking_source_stats(session, code_with_prefix)
+        if not stats:
+            await message.answer("❌ Источник не найден или не содержит данных.")
+            return
+        msg = format_ads_stats(stats, USERNAME_BOT)
+        await message.answer(
+            text=msg,
+            reply_markup=build_ads_stats_kb(code_with_prefix),
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка при создании ссылки: {e}", exc_info=True)
+        await message.answer("❌ Произошла ошибка при создании ссылки.")
+    finally:
+        await state.clear()
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "list"), IsAdminFilter())
+async def handle_ads_list(callback_query: CallbackQuery, session: AsyncSession, callback_data: AdminAdsCallback):
+    try:
+        result = await session.execute(select(TrackingSource).order_by(TrackingSource.created_at.desc()))
+        ads = result.scalars().all()
+        items_per_page = 6
+        if callback_data.code and callback_data.code.isdigit():
+            current_page = int(callback_data.code)
+        else:
+            current_page = 1
+        total_pages = (len(ads) + items_per_page - 1) // items_per_page
+        reply_markup = build_ads_list_kb(ads, current_page, total_pages)
+        await callback_query.message.edit_text(
+            "📋 Выберите ссылку для просмотра статистики:", reply_markup=reply_markup
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при получении списка UTM: {e}", exc_info=True)
+        await callback_query.message.edit_text("❌ Произошла ошибка при получении списка.")
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "view"), IsAdminFilter())
+async def handle_ads_view(
+    callback_query: CallbackQuery,
+    callback_data: AdminAdsCallback,
+    session: AsyncSession,
+):
+    code = callback_data.code
+    try:
+        stats = await get_tracking_source_stats(session, code)
+        if not stats:
+            await callback_query.message.edit_text("❌ Источник не найден или не содержит данных.")
+            return
+        msg = format_ads_stats(stats, USERNAME_BOT)
+        await callback_query.message.edit_text(text=msg, reply_markup=build_ads_stats_kb(code))
+    except Exception as e:
+        logger.error(f"Ошибка при просмотре статистики: {e}", exc_info=True)
+        await callback_query.message.edit_text("❌ Ошибка при получении статистики.")
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "delete_confirm"), IsAdminFilter())
+async def handle_ads_delete_confirm(callback_query: CallbackQuery, callback_data: AdminAdsCallback):
+    code = callback_data.code
+    await callback_query.message.edit_text(
+        text=f"Вы уверены, что хотите удалить ссылку <code>{code}</code>?",
+        reply_markup=build_ads_delete_confirm_kb(code),
+    )
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "delete"), IsAdminFilter())
+async def handle_ads_delete(
+    callback_query: CallbackQuery,
+    callback_data: AdminAdsCallback,
+    session: AsyncSession,
+):
+    code = callback_data.code
+    try:
+        await session.execute(update(User).where(User.source_code == code).values(source_code=None))
+        await session.execute(delete(TrackingSource).where(TrackingSource.code == code))
+        await session.commit()
+        await callback_query.message.edit_text(
+            f"🗑️ Ссылка <code>{code}</code> удалена.",
+            reply_markup=build_ads_kb(),
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при удалении метки {code}: {e}", exc_info=True)
+        await callback_query.message.edit_text("❌ Не удалось удалить ссылку.")
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "cancel_input"), IsAdminFilter())
+async def handle_ads_cancel_input(callback_query: CallbackQuery, state: FSMContext):
+    await state.clear()
+    await callback_query.message.edit_text(text="📊 <b>Аналитика рекламы:</b>", reply_markup=build_ads_kb())
+
+
+def format_ads_stats(stats: dict, username_bot: str) -> str:
+    moscow_tz = pytz.timezone("Europe/Moscow")
+    now = datetime.now(moscow_tz)
+    update_time = now.strftime("%d.%m.%y %H:%M:%S")
+
+    return (
+        f"<b>📊 <u>Статистика по рекламной ссылке</u></b>\n\n"
+        f"📌 <b>Название:</b> {stats['name']}\n"
+        f"🔗 <b>Ссылка:</b> <code>https://t.me/{username_bot}?start={stats['code']}</code>\n"
+        f"🕓 <b>Создана:</b> {stats['created_at'].strftime('%d.%m.%Y %H:%M')}\n\n"
+        f"💡 <b>Активность:</b>\n"
+        f"└ 🆕 <b>Регистраций:</b> <b>{stats.get('registrations', 0)}</b>\n"
+        f"└ 🧪 <b>Триалов:</b> <b>{stats.get('trials', 0)}</b>\n\n"
+        f"💰 <b>Финансовая информация:</b>\n"
+        f"├ 💳 <b>Покупок:</b> <b>{stats.get('payments', 0)}</b>\n"
+        f"└ 💸 <b>Сумма:</b> <b>{round(stats.get('total_amount', 0), 2)} ₽</b>\n\n"
+        f"⏱️ <i>Последнее обновление:</i> <code>{update_time}</code>"
+    )

handlers/admin/ads/keyboard.py

@@ -0,0 +1,102 @@
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from ..panel.keyboard import build_admin_back_btn
+
+
+class AdminAdsCallback(CallbackData, prefix="admin_ads"):
+    action: str
+    code: str | None = None
+
+
+def build_ads_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(text="➕ Новая ссылка", callback_data=AdminAdsCallback(action="create").pack())
+    builder.button(text="📊 Список", callback_data=AdminAdsCallback(action="list").pack())
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_ads_list_kb(ads: list, current_page: int, total_pages: int) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    items_per_page = 6
+
+    start = (current_page - 1) * items_per_page
+    end = start + items_per_page
+    page_ads = ads[start:end]
+
+    row = []
+    for i, ad in enumerate(page_ads, 1):
+        row.append(
+            InlineKeyboardButton(
+                text=f"📎 {ad['name']}",
+                callback_data=AdminAdsCallback(action="view", code=ad["code"]).pack(),
+            )
+        )
+        if i % 2 == 0 or i == len(page_ads):
+            builder.row(*row)
+            row = []
+
+    pagination_buttons = []
+    if current_page > 1:
+        pagination_buttons.append(
+            InlineKeyboardButton(
+                text="⬅️ Назад",
+                callback_data=AdminAdsCallback(action="list", code=f"{current_page - 1}").pack(),
+            )
+        )
+    if current_page < total_pages:
+        pagination_buttons.append(
+            InlineKeyboardButton(
+                text="Вперед ➡️",
+                callback_data=AdminAdsCallback(action="list", code=f"{current_page + 1}").pack(),
+            )
+        )
+    if pagination_buttons:
+        builder.row(*pagination_buttons)
+
+    builder.row(build_admin_back_btn("ads"))
+    return builder.as_markup()
+
+
+def build_ads_stats_kb(code: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(
+        text="🔄 Обновить",
+        callback_data=AdminAdsCallback(action="view", code=code).pack(),
+    )
+    builder.button(
+        text="🗑️ Удалить",
+        callback_data=AdminAdsCallback(action="delete_confirm", code=code).pack(),
+    )
+    builder.row(build_admin_back_btn("ads"))
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_ads_delete_confirm_kb(code: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(
+        text="✅ Да, удалить",
+        callback_data=AdminAdsCallback(
+            action="delete",
+            code=code,
+        ).pack(),
+    )
+    builder.button(
+        text="❌ Отмена",
+        callback_data=AdminAdsCallback(action="view", code=code).pack(),
+    )
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_cancel_input_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(
+        text="❌ Отмена",
+        callback_data=AdminAdsCallback(action="cancel_input", code="none").pack(),
+    )
+    return builder.as_markup()

handlers/admin/backups/backups_handler.py

@@ -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
 
@@ -18,14 +18,19 @@ async def handle_backups(callback_query: CallbackQuery):
     kb = build_admin_back_kb("management")
 
     await callback_query.message.edit_text(
-        text="💾 Инициализация резервного копирования базы данных...", reply_markup=kb
+        text="💾 Инициализация резервного копирования базы данных...",
+        reply_markup=kb,
     )
 
-    exception = await backup_database()
+    try:
+        exception = await backup_database()
 
-    if exception:
-        text = f"❌ Ошибка при создании резервной копии: {exception}"
-    else:
-        text = "✅ Резервная копия успешно создана и отправлена администраторам."
+        if exception:
+            text = f"❌ Ошибка при создании резервной копии:\n<code>{exception}</code>"
+        else:
+            text = "✅ Резервная копия успешно создана и отправлена администраторам."
+
+    except Exception as e:
+        text = f"❌ Непредвиденная ошибка: <code>{e}</code>"
 
     await callback_query.message.edit_text(text=text, reply_markup=kb)

handlers/admin/bans/bans_handler.py

@@ -1,10 +1,20 @@
-from typing import Any
+import csv
+import io
+
+from datetime import datetime, timezone
 
 from aiogram import F, Router
-from aiogram.types import BufferedInputFile, CallbackQuery
+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 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 filters.admin import IsAdminFilter
+from logger import logger
 
 from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
 from .keyboard import build_bans_kb
@@ -13,45 +23,41 @@ from .keyboard import build_bans_kb
 router = Router()
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "bans"),
-    IsAdminFilter(),
-)
+class PreemptiveBanStates(StatesGroup):
+    waiting_for_preemptive_ids = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "bans"), IsAdminFilter())
 async def handle_bans(callback_query: CallbackQuery):
-    text = "🚫 Заблокировавшие бота\n\nЗдесь можно просматривать и удалять пользователей, которые забанили вашего бота!"
-
-    await callback_query.message.edit_text(
-        text=text,
-        reply_markup=build_bans_kb(),
+    text_ = (
+        "🚫 <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_export"),
-    IsAdminFilter(),
-)
-async def handle_bans_export(callback_query: CallbackQuery, session: Any):
+@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")
-
     try:
-        banned_users = await session.fetch("SELECT tg_id, blocked_at FROM blocked_users")
-
-        import csv
-        import io
+        result = await session.execute(text("SELECT tg_id FROM blocked_users"))
+        banned_users = result.all()
 
         csv_output = io.StringIO()
         writer = csv.writer(csv_output)
-        writer.writerow(["tg_id", "blocked_at"])
+        writer.writerow(["tg_id"])
+
         for user in banned_users:
-            writer.writerow([user["tg_id"], user["blocked_at"]])
+            writer.writerow([user.tg_id])
 
         csv_output.seek(0)
-
         document = BufferedInputFile(file=csv_output.getvalue().encode("utf-8"), filename="banned_users.csv")
 
         await callback_query.message.answer_document(
             document=document,
-            caption="📥 Экспорт пользователей, заблокировавших бота в CSV",
+            caption="📥 Экспорт пользователей, заблокировавших бота (CSV)",
         )
     except Exception as e:
         await callback_query.message.answer(
@@ -60,16 +66,13 @@ async def handle_bans_export(callback_query: CallbackQuery, session: Any):
         )
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "bans_delete_banned"),
-    IsAdminFilter(),
-)
-async def handle_bans_delete_banned(callback_query: CallbackQuery, session: Any):
+@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")
-
     try:
-        blocked_users = await session.fetch("SELECT tg_id FROM blocked_users")
-        blocked_ids = [record["tg_id"] for record in blocked_users]
+        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]
 
         if not blocked_ids:
             await callback_query.message.answer(
@@ -81,7 +84,11 @@ async def handle_bans_delete_banned(callback_query: CallbackQuery, session: Any)
         for tg_id in blocked_ids:
             await delete_user_data(session, tg_id)
 
-        await session.execute("DELETE FROM blocked_users WHERE tg_id = ANY($1)", blocked_ids)
+        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)} пользователях и связанных записях.",
@@ -92,3 +99,103 @@ async def handle_bans_delete_banned(callback_query: CallbackQuery, session: Any)
             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):
+    build_admin_back_kb("bans")
+    try:
+        result = await session.execute(text("SELECT tg_id, banned_at, reason, until FROM manual_bans"))
+        rows = result.all()
+
+        csv_output = io.StringIO()
+        writer = csv.writer(csv_output)
+        writer.writerow(["tg_id", "banned_at", "reason", "until"])
+
+        for user in rows:
+            writer.writerow([user.tg_id, user.banned_at, user.reason, user.until])
+
+        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="📥 Экспорт вручную забаненных пользователей",
+        )
+    except Exception as e:
+        await callback_query.message.answer(
+            text=f"❗ Ошибка при экспорте: {e}",
+            reply_markup=build_admin_back_kb("bans"),
+        )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "bans_delete_manual"), IsAdminFilter())
+async def handle_delete_manual_banned(callback_query: CallbackQuery, session: AsyncSession):
+    try:
+        await session.execute(delete(ManualBan))
+        await session.commit()
+        await callback_query.message.edit_text(
+            "🗑️ Вручную забаненные пользователи удалены.",
+            reply_markup=build_bans_kb(),
+        )
+        logger.info("[BANS] Очищены записи из manual_bans")
+    except Exception as e:
+        logger.error(f"[BANS] Ошибка при очистке manual_bans: {e}")
+        await callback_query.message.edit_text("❌ Ошибка при удалении вручную забаненных пользователей.")
+
+
+@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)
+
+    await callback.message.edit_text(
+        "📥 Отправьте список Telegram ID (один на строке), которых нужно заранее забанить (теневой бан).\n\n"
+        "Пример:\n<code>123456789\n987654321</code>",
+        reply_markup=build_admin_back_kb("bans"),
+    )
+
+
+@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()
+    tg_ids = set()
+
+    for line in lines:
+        line = line.strip()
+        if line.isdigit():
+            tg_ids.add(int(line))
+
+    if not tg_ids:
+        await message.answer("❌ Не найдено ни одного корректного Telegram ID.")
+        return
+
+    now = datetime.now(timezone.utc)
+
+    stmt = (
+        pg_insert(ManualBan)
+        .values([
+            {
+                "tg_id": tg_id,
+                "reason": "shadow",
+                "banned_by": message.from_user.id,
+                "until": None,
+                "banned_at": now,
+            }
+            for tg_id in tg_ids
+        ])
+        .on_conflict_do_update(
+            index_elements=[ManualBan.tg_id],
+            set_={
+                "reason": "shadow",
+                "until": None,
+                "banned_by": message.from_user.id,
+                "banned_at": now,
+            },
+        )
+    )
+
+    await session.execute(stmt)
+    await session.commit()
+
+    await message.answer(f"✅ Успешно добавлено в теневой бан: <b>{len(tg_ids)}</b> пользователей.")
+    await state.clear()

handlers/admin/bans/keyboard.py

@@ -1,13 +1,35 @@
-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
 
 
-def build_bans_kb() -> InlineKeyboardMarkup:
+def build_bans_kb():
     builder = InlineKeyboardBuilder()
-    builder.button(text="📄 Выгрузить в CSV", callback_data=AdminPanelCallback(action="bans_export").pack())
-    builder.button(text="🗑️ Удалить из БД", callback_data=AdminPanelCallback(action="bans_delete_banned").pack())
-    builder.row(build_admin_back_btn("management"))
+
+    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(),
+    )
+    builder.button(
+        text="🔙 Назад",
+        callback_data=AdminPanelCallback(action="management").pack(),
+    )
+
     builder.adjust(1)
     return builder.as_markup()

handlers/admin/clusters/keyboard.py

@@ -1,12 +1,8 @@
-from typing import Optional
-
 from aiogram.filters.callback_data import CallbackData
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
-from handlers.buttons import BACK
-
-from ..panel.keyboard import build_admin_back_btn
+from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
 from ..servers.keyboard import AdminServerCallback
 
 
@@ -20,16 +16,23 @@ def build_clusters_editor_kb(servers: dict) -> InlineKeyboardMarkup:
 
     cluster_names = list(servers.keys())
     for i in range(0, len(cluster_names), 2):
-        builder.row(*[
-            InlineKeyboardButton(
-                text=f"⚙️ {name}",
-                callback_data=AdminClusterCallback(action="manage", data=name).pack(),
+        row_buttons = []
+        for name in cluster_names[i : i + 2]:
+            servers_in_cluster = servers[name]
+            all_disabled = all(not s["enabled"] for s in servers_in_cluster)
+            label = f"❌ {name} (отключен)" if all_disabled else f"⚙️ {name}"
+            row_buttons.append(
+                InlineKeyboardButton(
+                    text=label,
+                    callback_data=AdminClusterCallback(action="manage", data=name).pack(),
+                )
             )
-            for name in cluster_names[i : i + 2]
-        ])
-
+        builder.row(*row_buttons)
     builder.row(
-        InlineKeyboardButton(text="➕ Добавить кластер", callback_data=AdminClusterCallback(action="add").pack())
+        InlineKeyboardButton(
+            text="➕ Добавить кластер",
+            callback_data=AdminClusterCallback(action="add").pack(),
+        )
     )
 
     builder.row(build_admin_back_btn())
@@ -54,21 +57,123 @@ 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="manage_cluster", data=cluster_name).pack(),
+            text="💸 Тариф(Установить/изменить)",
+            callback_data=AdminClusterCallback(action="attach_tariff_menu", data=cluster_name).pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="🔙 Назад",
+            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
         )
     )
 
-    builder.row(build_admin_back_btn("clusters"))
+    return builder.as_markup()
+
+
+def build_attach_tariff_kb(cluster_name: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    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="🗂 Подгруппы",
+            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="manage", 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="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="🔙 Назад",
+            callback_data=AdminClusterCallback(action="manage", 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_cluster_management_kb(cluster_name: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
 
+    builder.row(
+        InlineKeyboardButton(
+            text="📡 Серверы",
+            callback_data=f"cluster_servers|{cluster_name}",
+        )
+    )
     builder.row(
         InlineKeyboardButton(
             text="🌐 Доступность",
@@ -101,10 +206,11 @@ def build_cluster_management_kb(cluster_name: str) -> InlineKeyboardMarkup:
     )
     builder.row(
         InlineKeyboardButton(
-            text="🔙 Назад",
-            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
+            text="💸 Тариф(Установить/изменить)",
+            callback_data=AdminClusterCallback(action="set_tariff", data=cluster_name).pack(),
         )
     )
+    builder.row(InlineKeyboardButton(text="🔙 Назад", callback_data=AdminPanelCallback(action="clusters").pack()))
 
     return builder.as_markup()
 
@@ -130,3 +236,93 @@ def build_sync_cluster_kb(cluster_servers: list, cluster_name: str) -> InlineKey
     builder.row(build_admin_back_btn("clusters"))
 
     return builder.as_markup()
+
+
+def build_panel_type_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(text="🌐 3X-UI", callback_data=AdminClusterCallback(action="panel_3xui").pack())
+    builder.button(
+        text="🌀 Remnawave",
+        callback_data=AdminClusterCallback(action="panel_remnawave").pack(),
+    )
+    builder.row(build_admin_back_btn("clusters"))
+    return builder.as_markup()
+
+
+def build_tariff_group_selection_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_tariff_group", data=f"{cluster_name}|{group_id}").pack(),
+        )
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад",
+            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="🔙 Назад",
+            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="⬅️ Назад",
+            callback_data=AdminClusterCallback(action="set_group", data=cluster_name).pack(),
+        )
+    )
+    builder.adjust(2, 1)
+    return builder.as_markup()

handlers/admin/coupons/coupons_handler.py

@@ -1,6 +1,3 @@
-from datetime import datetime
-import html
-import pytz
 from typing import Any
 
 from aiogram import F, Router
@@ -17,25 +14,19 @@ from aiogram.types import (
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from config import INLINE_MODE, USERNAME_BOT
-from database import (
-    add_connection,
-    check_connection_exists,
-    create_coupon,
-    create_coupon_usage,
-    delete_coupon,
-    get_all_coupons,
-    get_keys,
-    update_key_expiry,
-)
+from database import create_coupon, delete_coupon, get_all_coupons
 from filters.admin import IsAdminFilter
 from handlers.buttons import BACK
-from handlers.keys.key_utils import renew_key_in_cluster
-from handlers.profile import process_callback_view_profile
 from handlers.utils import format_days
 from logger import logger
 
 from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
-from .keyboard import AdminCouponDeleteCallback, build_coupons_kb, build_coupons_list_kb, format_coupons_list
+from .keyboard import (
+    AdminCouponDeleteCallback,
+    build_coupons_kb,
+    build_coupons_list_kb,
+    format_coupons_list,
+)
 
 
 router = Router()
@@ -45,7 +36,6 @@ class AdminCouponsState(StatesGroup):
     waiting_for_coupon_type = State()
     waiting_for_balance_data = State()
     waiting_for_days_data = State()
-    waiting_for_key_selection = State()
 
 
 @router.callback_query(
@@ -129,7 +119,7 @@ async def handle_balance_coupon_input(message: Message, state: FSMContext, sessi
         return
 
     try:
-        await create_coupon(coupon_code, coupon_amount, usage_limit, session, days=None)
+        await create_coupon(session, coupon_code, coupon_amount, usage_limit, days=None)
 
         coupon_link = f"https://t.me/{USERNAME_BOT}?start=coupons_{coupon_code}"
         text = (
@@ -182,7 +172,7 @@ async def handle_days_coupon_input(message: Message, state: FSMContext, session:
         return
 
     try:
-        await create_coupon(coupon_code, 0, usage_limit, session, days=days)
+        await create_coupon(session, coupon_code, 0, usage_limit, days=days)
 
         coupon_link = f"https://t.me/{USERNAME_BOT}?start=coupons_{coupon_code}"
         text = (
@@ -221,44 +211,52 @@ async def handle_coupons_list(callback_query: CallbackQuery, session: Any):
 
 
 @router.callback_query(AdminCouponDeleteCallback.filter(F.confirm.is_(None)), IsAdminFilter())
-async def handle_coupon_delete(callback_query: CallbackQuery, callback_data: AdminCouponDeleteCallback, session: Any):
+async def handle_coupon_delete(
+    callback_query: CallbackQuery,
+    callback_data: AdminCouponDeleteCallback,
+    session: Any,
+):
     coupon_code = callback_data.coupon_code
     kb = InlineKeyboardBuilder()
     kb.button(
         text="✅ Да, удалить",
-        callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=True).pack()
+        callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=True).pack(),
     )
     kb.button(
         text="❌ Нет, отменить",
-        callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=False).pack()
+        callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=False).pack(),
     )
     kb.adjust(1)
 
     await callback_query.message.edit_text(
         f"Вы уверены, что хотите удалить купон <b>{coupon_code}</b>?",
-        reply_markup=kb.as_markup()
+        reply_markup=kb.as_markup(),
     )
 
 
 @router.callback_query(AdminCouponDeleteCallback.filter(F.confirm.is_not(None)), IsAdminFilter())
-async def confirm_coupon_delete(callback_query: CallbackQuery, callback_data: AdminCouponDeleteCallback, session: Any):
+async def confirm_coupon_delete(
+    callback_query: CallbackQuery,
+    callback_data: AdminCouponDeleteCallback,
+    session: Any,
+):
     coupon_code = callback_data.coupon_code
     confirm = callback_data.confirm
 
     if confirm:
         try:
-            result = await delete_coupon(coupon_code, session)
+            result = await delete_coupon(session, coupon_code)
             if not result:
                 await callback_query.message.edit_text(
                     f"❌ Купон с кодом {coupon_code} не найден.",
-                    reply_markup=build_admin_back_kb("coupons")
+                    reply_markup=build_admin_back_kb("coupons"),
                 )
                 return
         except Exception as e:
             logger.error(f"Ошибка при удалении купона: {e}")
             await callback_query.message.edit_text(
                 "Произошла ошибка при удалении купона.",
-                reply_markup=build_admin_back_kb("coupons")
+                reply_markup=build_admin_back_kb("coupons"),
             )
             return
 
@@ -303,7 +301,11 @@ async def inline_coupon_handler(inline_query: InlineQuery, session: Any):
         return
 
     title = f"Купон {coupon['code']}"
-    description = f"Получи {coupon['amount']} рублей!" if coupon["amount"] > 0 else f"Продли подписку на {format_days(coupon['days'])}!"
+    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"
@@ -317,173 +319,8 @@ async def inline_coupon_handler(inline_query: InlineQuery, session: Any):
         id=coupon_code,
         title=title,
         description=description,
-        input_message_content=InputTextMessageContent(
-            message_text=message_text,
-            parse_mode=ParseMode.HTML
-        ),
+        input_message_content=InputTextMessageContent(message_text=message_text, parse_mode=ParseMode.HTML),
         reply_markup=builder.as_markup(),
     )
 
-    await inline_query.answer(
-        results=[result],
-        cache_time=86400,
-        is_personal=True
-    )
-
-@router.message(F.text.regexp(r"^/start coupons_(.+)$"))
-async def handle_coupon_activation(
-    message: Message, state: FSMContext, session: Any, admin: bool = False, text: str = None, user_id: int = None
-):
-    coupon_text = text if text is not None else message.text
-    logger.info(f"Текст купона в handle_coupon_activation: {coupon_text}")
-    coupon_code = coupon_text.split("coupons_")[1]
-
-    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)
-
-    if not coupon:
-        await message.answer("❌ Купон не найден.")
-        return
-
-    if coupon["usage_count"] >= coupon["usage_limit"] or coupon["is_used"]:
-        await message.answer("❌ Лимит активаций купона исчерпан.")
-        return
-
-    effective_user_id = user_id if user_id is not None else message.from_user.id
-
-    usage = await session.fetchrow(
-        "SELECT * FROM coupon_usages WHERE coupon_id = $1 AND user_id = $2",
-        coupon["id"],
-        effective_user_id
-    )
-    if usage:
-        await message.answer("❌ Вы уже активировали этот купон.")
-        return
-
-    connection_exists = await check_connection_exists(effective_user_id)
-    if not connection_exists:
-        await add_connection(tg_id=effective_user_id, session=session)
-
-    if coupon["amount"] > 0:
-        await session.execute(
-            "UPDATE connections SET balance = balance + $1 WHERE tg_id = $2",
-            coupon["amount"],
-            effective_user_id
-        )
-        await session.execute(
-            "UPDATE coupons SET usage_count = usage_count + 1, is_used = $1 WHERE id = $2",
-            coupon["usage_count"] + 1 >= coupon["usage_limit"],
-            coupon["id"]
-        )
-        await create_coupon_usage(coupon["id"], effective_user_id, session)
-        await message.answer(f"✅ Купон активирован, на баланс начислено {coupon['amount']} рублей.")
-        await process_callback_view_profile(message, state, admin)
-        return
-
-    if coupon["days"] is not None and coupon["days"] > 0:
-        keys = await get_keys(effective_user_id, session)
-        active_keys = [k for k in keys if not k["is_frozen"]]
-
-        if not active_keys:
-            await message.answer("❌ У вас нет активных подписок для продления.")
-            return
-
-        builder = InlineKeyboardBuilder()
-        moscow_tz = pytz.timezone("Europe/Moscow")
-        response_message = "<b>🔑 Выберите подписку для продления:</b>\n\n<blockquote>"
-
-        for key in active_keys:
-            alias = key.get("alias")
-            email = key["email"]
-            client_id = key["client_id"]
-            expiry_time = key.get("expiry_time")
-
-            key_display = html.escape(alias.strip() if alias else email)
-            expiry_date = datetime.fromtimestamp(expiry_time / 1000, tz=moscow_tz).strftime("до %d.%m.%y, %H:%M")
-            response_message += f"• <b>{key_display}</b> ({expiry_date})\n"
-            builder.button(text=key_display, callback_data=f"extend_key|{client_id}|{coupon['id']}")
-
-        response_message += "</blockquote>"
-        builder.button(text="Отмена", callback_data="cancel_coupon_activation")
-        builder.adjust(1)
-
-        await message.answer(response_message, reply_markup=builder.as_markup())
-        await state.set_state(AdminCouponsState.waiting_for_key_selection)
-        await state.update_data(coupon_id=coupon["id"], user_id=effective_user_id)
-        return
-
-    await message.answer("❌ Купон недействителен (нет суммы или дней).")
-
-
-@router.callback_query(F.data.startswith("extend_key|"))
-async def handle_key_extension(callback_query: CallbackQuery, state: FSMContext, session: Any, admin: bool = False):
-    parts = callback_query.data.split("|")
-    client_id = parts[1]
-    coupon_id = int(parts[2])
-
-    coupon = await session.fetchrow("SELECT * FROM coupons WHERE id = $1", coupon_id)
-    if not coupon or coupon["usage_count"] >= coupon["usage_limit"]:
-        await callback_query.message.edit_text("❌ Купон недействителен или лимит исчерпан.")
-        await state.clear()
-        return
-
-    usage = await session.fetchrow(
-        "SELECT * FROM coupon_usages WHERE coupon_id = $1 AND user_id = $2",
-        coupon_id,
-        callback_query.from_user.id
-    )
-    if usage:
-        await callback_query.message.edit_text("❌ Вы уже активировали этот купон.")
-        await state.clear()
-        return
-
-    key = await session.fetchrow(
-        "SELECT * FROM keys WHERE tg_id = $1 AND client_id = $2",
-        callback_query.from_user.id,
-        client_id
-    )
-    if not key or key["is_frozen"]:
-        await callback_query.message.edit_text("❌ Выбранная подписка не найдена или заморожена.")
-        await state.clear()
-        return
-
-    now_ms = int(datetime.now().timestamp() * 1000)
-    current_expiry = key["expiry_time"]
-    new_expiry = max(now_ms, current_expiry) + (coupon["days"] * 86400 * 1000)
-
-    try:
-        await renew_key_in_cluster(
-            cluster_id=key["server_id"],
-            email=key["email"],
-            client_id=client_id,
-            new_expiry_time=new_expiry,
-            total_gb=0
-        )
-        await update_key_expiry(client_id, new_expiry, session)
-
-        await session.execute(
-            "UPDATE coupons SET usage_count = usage_count + 1, is_used = $1 WHERE id = $2",
-            coupon["usage_count"] + 1 >= coupon["usage_limit"],
-            coupon["id"]
-        )
-        await create_coupon_usage(coupon["id"], callback_query.from_user.id, session)
-
-        alias = key.get("alias") or key["email"]
-        expiry_date = datetime.fromtimestamp(new_expiry / 1000, tz=pytz.timezone("Europe/Moscow")).strftime("%d.%m.%y, %H:%M")
-        text = f"✅ Купон активирован, подписка <b>{alias}</b> продлена на {format_days(coupon['days'])}⏳ до {expiry_date}📆."
-
-        await callback_query.message.answer(text)
-        await process_callback_view_profile(callback_query.message, state, admin)
-        await state.clear()
-
-    except Exception as e:
-        logger.error(f"Ошибка при продлении ключа: {e}")
-        await callback_query.message.edit_text("❌ Произошла ошибка при продлении подписки.")
-        await state.clear()
-
-
-@router.callback_query(F.data == "cancel_coupon_activation")
-async def cancel_coupon_activation(callback_query: CallbackQuery, state: FSMContext, admin: bool = False):
-    await callback_query.message.answer("⚠️ Активация купона отменена.")
-    await process_callback_view_profile(callback_query.message, state, admin)
-    await state.clear()
+    await inline_query.answer(results=[result], cache_time=86400, is_personal=True)

handlers/admin/coupons/keyboard.py

@@ -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
@@ -12,14 +10,26 @@ from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
 
 class AdminCouponDeleteCallback(CallbackData, prefix="admin_coupon_delete"):
     coupon_code: str
-    confirm: Optional[bool] = None
+    confirm: bool | None = None
 
 
 def build_coupons_kb() -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
-    builder.button(text="➕ Создать купон", callback_data=AdminPanelCallback(action="coupons_create").pack())
-    builder.button(text="Купоны", callback_data=AdminPanelCallback(action="coupons_list").pack())
+
+    builder.row(
+        InlineKeyboardButton(
+            text="➕ Создать купон",
+            callback_data=AdminPanelCallback(action="coupons_create").pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="Купоны",
+            callback_data=AdminPanelCallback(action="coupons_list").pack(),
+        )
+    )
     builder.row(build_admin_back_btn())
+
     return builder.as_markup()
 
 
@@ -59,7 +69,11 @@ 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>"
+        value_text = (
+            f"💰 <b>Сумма:</b> {coupon['amount']} рублей"
+            if coupon["amount"] > 0
+            else f"⏳ <b>{format_days(coupon['days'])}</b>"
+        )
         coupon_list += (
             f"🏷️ <b>Код:</b> {coupon['code']}\n"
             f"{value_text}\n"

handlers/admin/gifts/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ("router",)
+
+from .gifts_handler import router

handlers/admin/gifts/gifts_handler.py

@@ -0,0 +1,273 @@
+from collections import defaultdict
+
+from aiogram import Bot, F, Router, types
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery
+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, 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
+
+
+router = Router()
+
+
+class GiftCreationState(StatesGroup):
+    waiting_for_gift_limit = State()
+    waiting_for_limit_input_or_unlimited = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "gifts"))
+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")
+async def admin_create_gift_step1(callback: CallbackQuery, session: AsyncSession):
+    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())
+        await callback.message.edit_text("❌ Нет активных тарифов в группе 'gifts'.", reply_markup=builder.as_markup())
+        return
+
+    grouped_tariffs = defaultdict(list)
+    for t in tariffs:
+        grouped_tariffs[t.get("subgroup_title")].append(t)
+
+    builder = InlineKeyboardBuilder()
+
+    for t in grouped_tariffs.get(None, []):
+        if t.get("duration_days") % 30 == 0:
+            duration_text = format_months(t.get("duration_days") // 30)
+        else:
+            duration_text = format_days(t.get("duration_days"))
+
+        builder.row(
+            types.InlineKeyboardButton(
+                text=f"{t.get('name')} – {duration_text}", callback_data=f"admin_gift_select|{t.get('id')}"
+            )
+        )
+
+    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(
+                text=subgroup,
+                callback_data=f"admin_gift_subgroup|{subgroup_hash}",
+            )
+        )
+
+    builder.row(types.InlineKeyboardButton(text="🔙 Назад", 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|"))
+async def admin_gift_show_tariffs_in_subgroup(callback: CallbackQuery, session: AsyncSession):
+    try:
+        subgroup_hash = callback.data.split("|", 1)[1]
+
+        subgroup = await find_subgroup_by_hash(session, subgroup_hash, "gifts")
+        if not subgroup:
+            await callback.message.edit_text("❌ Подгруппа не найдена.")
+            return
+
+        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.get("duration_days") % 30 == 0:
+                duration_text = format_months(t.get("duration_days") // 30)
+            else:
+                duration_text = format_days(t.get("duration_days"))
+
+            builder.row(
+                types.InlineKeyboardButton(
+                    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"))
+
+        await edit_or_send_message(
+            target_message=callback.message,
+            text=f"<b>{subgroup}</b>\n\nВыберите тариф:",
+            reply_markup=builder.as_markup(),
+        )
+
+    except Exception as e:
+        logger.error(f"[ADMIN_GIFT_SUBGROUP] Ошибка при отображении подгруппы: {e}")
+        await callback.message.answer("❌ Произошла ошибка при отображении тарифов.")
+
+
+@router.callback_query(F.data.startswith("admin_gift_select|"))
+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")
+    await callback.message.edit_text(
+        "🔢 Введите максимальное количество активаций подарка:", reply_markup=kb.as_markup()
+    )
+
+
+@router.callback_query(F.data == "gift_limit_unlimited")
+async def handle_unlimited_gift(callback: CallbackQuery, state: FSMContext, bot: Bot):
+    from handlers.payments.gift import finalize_gift
+
+    data = await state.get_data()
+    session: AsyncSession = callback.bot["session"]
+    await state.clear()
+    await finalize_gift(callback.message, session, bot, data, is_unlimited=True)
+
+
+@router.message(GiftCreationState.waiting_for_limit_input_or_unlimited)
+async def handle_limited_gift_input(message: types.Message, session: AsyncSession, state: FSMContext, bot: Bot):
+    from handlers.payments.gift import finalize_gift
+
+    try:
+        max_usages = int(message.text.strip())
+        if max_usages <= 0:
+            raise ValueError
+    except ValueError:
+        await message.answer("❌ Введите корректное положительное число.")
+        return
+
+    data = await state.get_data()
+    data["max_usages"] = max_usages
+    await state.clear()
+    await finalize_gift(message, session, bot, data, is_unlimited=False)
+
+
+@router.callback_query(F.data == "admin_gifts_all")
+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|"))
+async def paginate_gifts(callback: CallbackQuery, session: AsyncSession):
+    page = int(callback.data.split("|")[1])
+    await show_gift_list(callback, session, page)
+
+
+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()
+
+    from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+    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))
+
+    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())
+
+
+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|"))
+async def view_gift(callback: CallbackQuery, session: AsyncSession):
+    gift_id = callback.data.split("|")[1]
+
+    result = await session.execute(select(Gift).where(Gift.gift_id == gift_id))
+    gift = result.scalar_one_or_none()
+
+    if not gift:
+        await callback.message.edit_text("❌ Подарок не найден.")
+        return
+
+    usage_result = await session.execute(
+        select(func.count()).select_from(GiftUsage).where(GiftUsage.gift_id == gift_id)
+    )
+    used_count = usage_result.scalar_one()
+    usage_text = f"{used_count}/{gift.max_usages}" if gift.max_usages else "∞"
+
+    duration_days = (gift.expiry_time.date() - gift.created_at.date()).days
+    if duration_days % 30 == 0:
+        duration_text = format_months(duration_days // 30)
+    else:
+        duration_text = format_days(duration_days)
+
+    text = (
+        f"🎁 <b>Подарок</b>\n"
+        f"ID: <code>{gift.gift_id}</code>\n"
+        f"Срок: <b>{duration_text}</b>\n"
+        f"Активаций: <b>{usage_text}</b>\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")
+
+    await callback.message.edit_text(text, reply_markup=builder.as_markup())
+
+
+@router.callback_query(F.data.startswith("gift_delete|"))
+async def delete_gift(callback: CallbackQuery, session: AsyncSession):
+    gift_id = callback.data.split("|")[1]
+
+    await session.execute(delete(GiftUsage).where(GiftUsage.gift_id == gift_id))
+    await session.execute(delete(Gift).where(Gift.gift_id == gift_id))
+    await session.commit()
+
+    builder = InlineKeyboardBuilder()
+    builder.button(text="🔙 Назад к списку", callback_data="admin_gifts_all")
+
+    await callback.message.edit_text("✅ Подарок удалён.", reply_markup=builder.as_markup())

handlers/admin/gifts/keyboard.py

@@ -0,0 +1,69 @@
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+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
+
+from ..panel.keyboard import AdminPanelCallback
+
+
+def build_admin_gifts_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    builder.row(InlineKeyboardButton(text="🎁 Создать подарок", callback_data="admin_gift_create"))
+    builder.row(
+        InlineKeyboardButton(text="📦 Все подарки", callback_data="admin_gifts_all"),
+    )
+    builder.row(InlineKeyboardButton(text=BACK, callback_data="admin"))
+
+    return builder.as_markup()
+
+
+def build_gift_tariffs_kb(tariffs: list[Tariff]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    for tariff in tariffs:
+        builder.button(
+            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.adjust(1)
+    return builder.as_markup()
+
+
+def build_gifts_list_kb(gifts: list[Gift], page: int, total: int) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    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)
+
+        button_text = f"{gift.gift_id[:6]}... — {duration_text}"
+
+        row.append(
+            InlineKeyboardButton(
+                text=button_text,
+                callback_data=f"gift_view|{gift.gift_id}",
+            )
+        )
+
+        if len(row) == 2 or i == len(gifts) - 1:
+            builder.row(*row)
+            row = []
+
+    nav = []
+    if page > 1:
+        nav.append(InlineKeyboardButton(text="⬅️ Назад", callback_data=f"gifts_page|{page - 1}"))
+    if len(gifts) == 10:
+        nav.append(InlineKeyboardButton(text="➡️ Далее", callback_data=f"gifts_page|{page + 1}"))
+    if nav:
+        builder.row(*nav)
+
+    builder.row(InlineKeyboardButton(text="🔙 Назад", callback_data=AdminPanelCallback(action="gifts").pack()))
+
+    return builder.as_markup()

handlers/admin/management/keyboard.py

@@ -1,16 +1,161 @@
 from aiogram.types import InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
+from middlewares import maintenance
+
 from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
 
 
-def build_management_kb() -> InlineKeyboardMarkup:
+def build_management_kb(admin_role: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
-    builder.button(text="💾 Создать резервную копию", callback_data=AdminPanelCallback(action="backups").pack())
-    builder.button(text="🚫 Заблокировавшие бота", callback_data=AdminPanelCallback(action="bans").pack())
-    builder.button(text="🔄 Перезагрузить бота", callback_data=AdminPanelCallback(action="restart").pack())
-    builder.button(text="🌐 Сменить домен", callback_data=AdminPanelCallback(action="change_domain").pack())
-    builder.button(text="🔑 Восстановить пробники", callback_data=AdminPanelCallback(action="restore_trials").pack())
+
+    if admin_role == "superadmin":
+        builder.button(
+            text="👑 Управление админами",
+            callback_data=AdminPanelCallback(action="admins").pack(),
+        )
+
+    builder.button(
+        text="🗄 Управление БД",
+        callback_data=AdminPanelCallback(action="database").pack(),
+    )
+    builder.button(
+        text="📛 Управление банами",
+        callback_data=AdminPanelCallback(action="bans").pack(),
+    )
+    builder.button(
+        text="🔄 Перезагрузить бота",
+        callback_data=AdminPanelCallback(action="restart").pack(),
+    )
+    builder.button(
+        text="🌐 Сменить домен подписок",
+        callback_data=AdminPanelCallback(action="change_domain").pack(),
+    )
+    builder.button(
+        text="🔑 Восстановить пробники",
+        callback_data=AdminPanelCallback(action="restore_trials").pack(),
+    )
+    builder.button(
+        text="📤 Загрузить файл",
+        callback_data=AdminPanelCallback(action="upload_file").pack(),
+    )
+    maintenance_text = "🛠️ Выключить тех. работы" if maintenance.maintenance_mode else "🛠️ Включить тех. работы"
+    builder.button(
+        text=maintenance_text,
+        callback_data=AdminPanelCallback(action="toggle_maintenance").pack(),
+    )
+
     builder.row(build_admin_back_btn())
     builder.adjust(1)
     return builder.as_markup()
+
+
+def build_database_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    builder.button(
+        text="💾 Создать резервную копию",
+        callback_data=AdminPanelCallback(action="backups").pack(),
+    )
+    builder.button(
+        text="♻️ Восстановить БД из бэкапа",
+        callback_data=AdminPanelCallback(action="restore_db").pack(),
+    )
+    builder.button(
+        text="📤 Получить данные БД из панели",
+        callback_data=AdminPanelCallback(action="export_db").pack(),
+    )
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_back_to_db_menu() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(text="⬅️ Назад", callback_data=AdminPanelCallback(action="database").pack())
+    return builder.as_markup()
+
+
+def build_export_db_sources_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    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.adjust(1)
+    return builder.as_markup()
+
+
+def build_admins_kb(admins: list[tuple[int, str]]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    for tg_id, role in admins:
+        builder.button(
+            text=f"🧑 {tg_id} ({role})", callback_data=AdminPanelCallback(action=f"admin_menu|{tg_id}").pack()
+        )
+
+    builder.button(text="➕ Добавить админа", callback_data=AdminPanelCallback(action="add_admin").pack())
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_single_admin_menu(tg_id: int, role: str = "moderator") -> InlineKeyboardMarkup:
+    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":
+        builder.button(
+            text="🎟 Выпустить токен", callback_data=AdminPanelCallback(action=f"generate_token|{tg_id}").pack()
+        )
+
+    builder.button(text="🔙 Назад", callback_data=AdminPanelCallback(action="admins").pack())
+
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+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.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.adjust(1)
+    return builder.as_markup()
+
+
+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.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.adjust(1)
+    return builder.as_markup()

handlers/admin/management/management_handler.py

@@ -1,14 +1,47 @@
-from aiogram import F, Router
+import hashlib
+import json
+import os
+import re
+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 asyncpg import Connection
+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.operations 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_management_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()
@@ -18,11 +51,36 @@ 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):
+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(),
+        reply_markup=build_management_kb(admin.role),
     )
 
 
@@ -36,12 +94,11 @@ async def request_new_domain(callback_query: CallbackQuery, state: FSMContext):
 
 
 @router.message(AdminManagementStates.waiting_for_new_domain)
-async def process_new_domain(message: Message, state: FSMContext, session: Connection):
+async def process_new_domain(message: Message, state: FSMContext, session: AsyncSession):
     """Обновляет домен в таблице keys."""
     new_domain = message.text.strip()
-    logger.info(f"[DomainChange] Новый домен, введённый администратором: '{new_domain}'")
 
-    if not new_domain or " " in new_domain or not new_domain.replace(".", "").isalnum():
+    if not re.fullmatch(r"[a-zA-Z0-9.-]+", new_domain) or " " in new_domain:
         logger.warning("[DomainChange] Некорректный домен")
         await message.answer(
             "🚫 Некорректный домен! Введите домен без http:// и без пробелов.",
@@ -50,26 +107,581 @@ async def process_new_domain(message: Message, state: FSMContext, session: Conne
         return
 
     new_domain_url = f"https://{new_domain}"
-    logger.info(f"[DomainChange] Новый домен с протоколом: '{new_domain_url}'")
 
-    query = """
-        UPDATE keys
-        SET key = regexp_replace(key, '^https://[^/]+', $1::TEXT)
-        WHERE key NOT LIKE $1 || '%'
-    """
     try:
-        await session.execute(query, new_domain_url)
+        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"))
+        await message.answer(
+            f"❌ Ошибка при обновлении домена: {e}",
+            reply_markup=build_admin_back_kb("admin"),
+        )
         return
 
     try:
-        sample = await session.fetchrow("SELECT key FROM keys LIMIT 1")
-        logger.info(f"[DomainChange] Пример обновленной записи: {sample}")
+        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 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):
+    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()

handlers/admin/module/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ("router",)
+
+from .module_handler import router

handlers/admin/module/keyboard.py

@@ -0,0 +1,93 @@
+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="⬅️ Назад",
+                    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.row(
+        InlineKeyboardButton(
+            text="⬅️ К списку",
+            callback_data=AdminPanelCallback(action="modules", page=page).pack(),
+        )
+    )
+    builder.adjust(1)
+    return builder.as_markup()

handlers/admin/module/module_handler.py

@@ -0,0 +1,171 @@
+import os
+
+from math import ceil
+
+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 name in sorted(os.listdir(base)):
+        path = os.path.join(base, name)
+        if os.path.isdir(path) and not name.startswith("."):
+            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

handlers/admin/panel/keyboard.py

@@ -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,27 +19,72 @@ class AdminPanelCallback(CallbackData, prefix="admin_panel"):
         super().__init__(**data)
 
 
-def build_panel_kb() -> 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())
+
     builder.row(
-        InlineKeyboardButton(text="🖥️ Серверы", callback_data=AdminPanelCallback(action="clusters").pack()),
+        InlineKeyboardButton(
+            text="👤 Поиск пользователя", callback_data=AdminPanelCallback(action="search_user").pack()
+        ),
+        InlineKeyboardButton(text="🔑 Поиск подписок", callback_data=AdminPanelCallback(action="search_key").pack()),
+    )
+
+    if admin_role == "superadmin":
+        builder.button(
+            text="🖥️ Управление серверами",
+            callback_data=AdminPanelCallback(action="clusters").pack(),
+        )
+        builder.button(
+            text="💸Управление тарифами",
+            callback_data=AdminPanelCallback(action="tariffs").pack(),
+        )
+        builder.button(
+            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.button(text="📢 Рассылка", callback_data=AdminPanelCallback(action="sender").pack())
-    builder.row(
-        InlineKeyboardButton(text="📊 Статистика", callback_data=AdminPanelCallback(action="stats").pack()),
-        InlineKeyboardButton(text="🤖 Управление", callback_data=AdminPanelCallback(action="management").pack()),
+
+    if admin_role == "superadmin":
+        builder.row(
+            InlineKeyboardButton(text="🎁 Подарки", callback_data=AdminPanelCallback(action="gifts").pack()),
+            InlineKeyboardButton(text="🧩 Мои модули", callback_data=AdminPanelCallback(action="modules").pack()),
+        )
+        builder.row(
+            InlineKeyboardButton(text="📊 Статистика", callback_data=AdminPanelCallback(action="stats").pack()),
+            InlineKeyboardButton(text="📈 Аналитика", callback_data=AdminPanelCallback(action="ads").pack()),
+        )
+    else:
+        builder.button(
+            text="🎁 Подарки",
+            callback_data=AdminPanelCallback(action="gifts").pack(),
+        )
+
+    module_buttons = await run_hooks("admin_panel", admin_role=admin_role)
+    builder = insert_hook_buttons(builder, module_buttons)
+
+    builder.button(
+        text=MAIN_MENU,
+        callback_data="profile",
     )
-    builder.button(text=MAIN_MENU, callback_data="profile")
-    builder.adjust(1, 1, 2, 1, 2, 1)
+
+    if admin_role == "superadmin":
+        builder.adjust(2, 1, 1, 1, 2, 2, 2, 1)
+    else:
+        builder.adjust(2, 2, 1, 1)
+
     return builder.as_markup()
 
 
 def build_restart_kb() -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
-    builder.button(text="✅ Да, перезагрузить", callback_data=AdminPanelCallback(action="restart_confirm").pack())
+    builder.button(
+        text="✅ Да, перезагрузить",
+        callback_data=AdminPanelCallback(action="restart_confirm").pack(),
+    )
     builder.row(build_admin_back_btn())
     builder.adjust(1)
     return builder.as_markup()

handlers/admin/panel/panel_handler.py

@@ -1,29 +1,40 @@
 from aiogram import F, Router
+from aiogram.exceptions import TelegramBadRequest
 from aiogram.filters import Command
 from aiogram.fsm.context import FSMContext
 from aiogram.types import CallbackQuery, Message
-from aiogram.exceptions import TelegramBadRequest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 
-from bot import version
+from database.models import Admin
 from filters.admin import IsAdminFilter
+from logger import logger
+from utils.versioning import get_version
 
 from .keyboard import AdminPanelCallback, build_panel_kb
 
-from logger import logger
-
 
 router = Router()
 
 
 @router.callback_query(AdminPanelCallback.filter(F.action == "admin"), IsAdminFilter())
-async def handle_admin_callback_query(callback_query: CallbackQuery, state: FSMContext):
-    text = f"🤖 Панель администратора\n📌 Версия бота: {version}"
+async def handle_admin_callback_query(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    text = f"🤖 Панель администратора\n\nВерсия бота:\n<blockquote>{get_version()}</blockquote>"
 
     await state.clear()
 
+    result = await session.execute(select(Admin.role).where(Admin.tg_id == callback_query.from_user.id))
+    role = result.scalar_one_or_none() or "admin"
+
+    markup = await build_panel_kb(admin_role=role)
+
     if callback_query.message.text:
         try:
-            await callback_query.message.edit_text(text=text, reply_markup=build_panel_kb())
+            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):
                 logger.warning("🔄 Попытка редактировать сообщение без изменений — пропущено.")
@@ -35,17 +46,29 @@ async def handle_admin_callback_query(callback_query: CallbackQuery, state: FSMC
         except Exception as e:
             logger.error(f"Ошибка при удалении сообщения: {e}")
 
-        await callback_query.message.answer(text=text, reply_markup=build_panel_kb())
+        await callback_query.message.answer(
+            text=text,
+            reply_markup=markup,
+            disable_web_page_preview=True,
+        )
 
 
 @router.callback_query(F.data == "admin", IsAdminFilter())
-async def handle_admin_callback_query(callback_query: CallbackQuery, state: FSMContext):
-    await handle_admin_message(callback_query.message, state)
+async def handle_admin_callback_query_simple(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    await handle_admin_callback_query(callback_query, state, session)
 
 
 @router.message(Command("admin"), IsAdminFilter())
-async def handle_admin_message(message: Message, state: FSMContext):
-    text = f"🤖 Панель администратора\n📌 Версия бота: {version}"
+async def handle_admin_message(message: Message, state: FSMContext, session: AsyncSession):
+    text = f"🤖 Панель администратора\n\nВерсия бота:\n<blockquote>{get_version()}</blockquote>"
 
     await state.clear()
-    await message.answer(text=text, reply_markup=build_panel_kb())
+
+    result = await session.execute(select(Admin.role).where(Admin.tg_id == message.from_user.id))
+    role = result.scalar_one_or_none() or "admin"
+
+    await message.answer(
+        text=text,
+        reply_markup=await build_panel_kb(admin_role=role),
+        disable_web_page_preview=True,
+    )

handlers/admin/restart/restart_handler.py

@@ -1,42 +1,46 @@
+import asyncio
+import os
 import subprocess
+import sys
+
+import psutil
 
 from aiogram import F, Router
 from aiogram.types import CallbackQuery
 
 from filters.admin import IsAdminFilter
 
-from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb, build_restart_kb
+from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
 
 
 router = Router()
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "restart"),
-    IsAdminFilter(),
-)
-async def handle_restart(callback_query: CallbackQuery):
-    await callback_query.message.edit_text(
-        text="🤔 Вы уверены, что хотите перезагрузить бота?",
-        reply_markup=build_restart_kb(),
-    )
-
-
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "restart_confirm"),
-    IsAdminFilter(),
-)
-async def handle_restart_confirm(callback_query: CallbackQuery):
+@router.callback_query(AdminPanelCallback.filter(F.action == "restart"), IsAdminFilter())
+async def handle_restart_confirm(callback_query: CallbackQuery, callback_data: AdminPanelCallback):
     kb = build_admin_back_kb()
+    await callback_query.message.edit_text("🔄 Перезапускаем бота...", reply_markup=kb)
+
+    asyncio.create_task(restart_bot())
+
+
+async def restart_bot():
+    await asyncio.sleep(1)
+
     try:
-        subprocess.run(
-            ["sudo", "systemctl", "restart", "bot.service"],
-            check=True,
-            capture_output=True,
-            text=True,
-        )
-        await callback_query.message.edit_text(text="🔄 Бот успешно перезагружен!", reply_markup=kb)
-    except subprocess.CalledProcessError:
-        await callback_query.message.edit_text(text="🔄 Бот успешно перезагружен!", reply_markup=kb)
+        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 as e:
-        await callback_query.message.edit_text(text=f"⚠️ Ошибка при перезагрузке бота: {e.stderr}", reply_markup=kb)
+        print(f"[Restart] Ошибка при перезапуске: {e}")
+        os._exit(1)

handlers/admin/sender/keyboard.py

@@ -13,18 +13,45 @@ class AdminSenderCallback(CallbackData, prefix="admin_sender"):
 def build_sender_kb() -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
 
-    builder.row(InlineKeyboardButton(text="👥 Все пользователи", callback_data=AdminSenderCallback(type="all").pack()))
-    builder.row(
-        InlineKeyboardButton(text="✅ С подпиской", callback_data=AdminSenderCallback(type="subscribed").pack()),
-        InlineKeyboardButton(text="❌ Без подписки", callback_data=AdminSenderCallback(type="unsubscribed").pack()),
-    )
     builder.row(
         InlineKeyboardButton(
-            text="📍 Не использовавшие триал", callback_data=AdminSenderCallback(type="untrial").pack()
+            text="👥 Все пользователи",
+            callback_data=AdminSenderCallback(type="all").pack(),
         )
     )
     builder.row(
-        InlineKeyboardButton(text="📢 Кластер", callback_data=AdminSenderCallback(type="cluster-select").pack())
+        InlineKeyboardButton(
+            text="✅ С подпиской",
+            callback_data=AdminSenderCallback(type="subscribed").pack(),
+        ),
+        InlineKeyboardButton(
+            text="❌ Без подписки",
+            callback_data=AdminSenderCallback(type="unsubscribed").pack(),
+        ),
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="📍 Не использовавшие триал",
+            callback_data=AdminSenderCallback(type="untrial").pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="🧪 Триал",
+            callback_data=AdminSenderCallback(type="trial").pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="🔥 Горячие лиды",
+            callback_data=AdminSenderCallback(type="hotleads").pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="📢 Кластер",
+            callback_data=AdminSenderCallback(type="cluster-select").pack(),
+        )
     )
     builder.row(build_admin_back_btn())
 
@@ -36,7 +63,10 @@ def build_clusters_kb(clusters: list) -> InlineKeyboardMarkup:
 
     for cluster in clusters:
         name = cluster["cluster_name"]
-        builder.button(text=f"🌐 {name}", callback_data=AdminSenderCallback(type="cluster", data=name).pack())
+        builder.button(
+            text=f"🌐 {name}",
+            callback_data=AdminSenderCallback(type="cluster", data=name).pack(),
+        )
 
     builder.adjust(2)
     builder.row(build_admin_back_btn())

handlers/admin/sender/sender_handler.py

@@ -1,11 +1,19 @@
+import asyncio
+import json
+import re
+
 from datetime import datetime
-from typing import Any
 
 from aiogram import F, Router
+from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError, TelegramRetryAfter
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
-from aiogram.types import CallbackQuery, Message
+from aiogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, Message
+from sqlalchemy import distinct, exists, func, not_, select
+from sqlalchemy.ext.asyncio import AsyncSession
 
+from database import create_blocked_user
+from database.models import BlockedUser, Key, ManualBan, Payment, Server, Tariff, User
 from filters.admin import IsAdminFilter
 from logger import logger
 
@@ -16,8 +24,205 @@ from .keyboard import AdminSenderCallback, build_clusters_kb, build_sender_kb
 router = Router()
 
 
+async def try_add_blocked_user(tg_id: int, session: AsyncSession):
+    if session:
+        try:
+            await create_blocked_user(session, tg_id)
+            logger.info(f"Пользователь {tg_id} добавлен в blocked_users.")
+        except Exception as e:
+            logger.warning(f"Не удалось добавить {tg_id} в blocked_users: {e}")
+
+
+async def send_broadcast_batch(bot, messages, batch_size=15, session=None):
+    results = []
+    min_interval = 1.0 / 15
+
+    for msg in messages:
+        tg_id = msg["tg_id"]
+        text = msg["text"]
+        photo = msg.get("photo")
+        keyboard = msg.get("keyboard")
+
+        try:
+            if photo:
+                await bot.send_photo(chat_id=tg_id, photo=photo, caption=text, parse_mode="HTML", reply_markup=keyboard)
+            else:
+                await bot.send_message(chat_id=tg_id, text=text, parse_mode="HTML", reply_markup=keyboard)
+            results.append(True)
+
+        except TelegramRetryAfter as e:
+            retry_in = int(e.retry_after) + 1
+            logger.warning(f"⚠️ Flood control: повтор через {retry_in} сек. для пользователя {tg_id}")
+            await asyncio.sleep(e.retry_after)
+            try:
+                if photo:
+                    await bot.send_photo(
+                        chat_id=tg_id, photo=photo, caption=text, parse_mode="HTML", reply_markup=keyboard
+                    )
+                else:
+                    await bot.send_message(chat_id=tg_id, text=text, parse_mode="HTML", reply_markup=keyboard)
+                results.append(True)
+            except TelegramForbiddenError:
+                logger.warning(f"🚫 Бот заблокирован пользователем {tg_id}.")
+                await try_add_blocked_user(tg_id, session)
+                results.append(False)
+            except TelegramBadRequest as bad_request:
+                error_msg = str(bad_request).lower()
+                if "chat not found" in error_msg:
+                    logger.warning(f"🚫 Чат не найден для пользователя {tg_id}.")
+                    await try_add_blocked_user(tg_id, session)
+                else:
+                    logger.warning(f"📩 Не удалось отправить сообщение пользователю {tg_id}: {bad_request}")
+                results.append(False)
+            except Exception as retry_error:
+                logger.error(f"❌ Ошибка повторной отправки пользователю {tg_id}: {retry_error}")
+                results.append(False)
+
+        except TelegramForbiddenError:
+            logger.warning(f"🚫 Бот заблокирован пользователем {tg_id}.")
+            await try_add_blocked_user(tg_id, session)
+            results.append(False)
+        except TelegramBadRequest as bad_request:
+            error_msg = str(bad_request).lower()
+            if "chat not found" in error_msg:
+                logger.warning(f"🚫 Чат не найден для пользователя {tg_id}.")
+                await try_add_blocked_user(tg_id, session)
+            else:
+                logger.warning(f"📩 Не удалось отправить сообщение пользователю {tg_id}: {bad_request}")
+            results.append(False)
+        except Exception as e:
+            logger.error(f"❌ Ошибка отправки сообщения пользователю {tg_id}: {e}")
+            results.append(False)
+
+        await asyncio.sleep(min_interval)
+
+    return results
+
+
 class AdminSender(StatesGroup):
     waiting_for_message = State()
+    preview = State()
+
+
+async def get_recipients(session: AsyncSession, send_to: str, cluster_name: str = None) -> tuple[list[int], int]:
+    now_ms = int(datetime.utcnow().timestamp() * 1000)
+    banned_tg_ids = select(BlockedUser.tg_id).union_all(
+        select(ManualBan.tg_id).where((ManualBan.until.is_(None)) | (ManualBan.until > datetime.utcnow()))
+    )
+
+    query = None
+    if send_to == "subscribed":
+        query = (
+            select(distinct(User.tg_id)).join(Key).where(Key.expiry_time > now_ms).where(~User.tg_id.in_(banned_tg_ids))
+        )
+    elif send_to == "unsubscribed":
+        subquery = (
+            select(User.tg_id)
+            .outerjoin(Key, User.tg_id == Key.tg_id)
+            .group_by(User.tg_id)
+            .having(func.count(Key.tg_id) == 0)
+            .union_all(
+                select(User.tg_id)
+                .join(Key, User.tg_id == Key.tg_id)
+                .group_by(User.tg_id)
+                .having(func.max(Key.expiry_time) <= now_ms)
+            )
+        )
+        query = select(distinct(subquery.c.tg_id)).where(~subquery.c.tg_id.in_(banned_tg_ids))
+    elif send_to == "untrial":
+        subquery = select(Key.tg_id)
+        query = (
+            select(distinct(User.tg_id))
+            .where(~User.tg_id.in_(subquery) & User.trial.in_([0, -1]))
+            .where(~User.tg_id.in_(banned_tg_ids))
+        )
+    elif send_to == "cluster":
+        query = (
+            select(distinct(User.tg_id))
+            .join(Key, User.tg_id == Key.tg_id)
+            .join(Server, Key.server_id == Server.cluster_name)
+            .where(Server.cluster_name == cluster_name)
+            .where(~User.tg_id.in_(banned_tg_ids))
+        )
+    elif send_to == "hotleads":
+        subquery_active_keys = select(Key.tg_id).where(Key.expiry_time > now_ms).distinct()
+        query = (
+            select(distinct(User.tg_id))
+            .join(Payment, User.tg_id == Payment.tg_id)
+            .where(Payment.status == "success")
+            .where(Payment.amount > 0)
+            .where(Payment.payment_system.notin_(["referral", "coupon", "cashback"]))
+            .where(not_(exists(subquery_active_keys.where(Key.tg_id == User.tg_id))))
+            .where(~User.tg_id.in_(banned_tg_ids))
+        )
+    elif send_to == "trial":
+        trial_tariff_subquery = select(Tariff.id).where(Tariff.group_code == "trial")
+        query = (
+            select(distinct(Key.tg_id))
+            .where(Key.tariff_id.in_(trial_tariff_subquery))
+            .where(~Key.tg_id.in_(banned_tg_ids))
+        )
+    else:
+        query = select(distinct(User.tg_id)).where(~User.tg_id.in_(banned_tg_ids))
+
+    result = await session.execute(query)
+    tg_ids = [row[0] for row in result.all()]
+    return tg_ids, len(tg_ids)
+
+
+def parse_message_buttons(text: str) -> tuple[str, InlineKeyboardMarkup | None]:
+    if "BUTTONS:" not in text:
+        return text, None
+
+    parts = text.split("BUTTONS:", 1)
+    clean_text = parts[0].strip()
+    buttons_text = parts[1].strip()
+
+    if not buttons_text:
+        return clean_text, None
+
+    buttons = []
+    button_lines = [line.strip() for line in buttons_text.split("\n") if line.strip()]
+
+    for line in button_lines:
+        try:
+            cleaned_line = re.sub(r'<tg-emoji emoji-id="[^"]*">([^<]*)</tg-emoji>', r"\1", line)
+
+            button_data = json.loads(cleaned_line)
+
+            if not isinstance(button_data, dict) or "text" not in button_data:
+                logger.warning(f"Неверный формат кнопки: {line}")
+                continue
+
+            text_btn = button_data["text"]
+
+            if "callback" in button_data:
+                callback_data = button_data["callback"]
+                if len(callback_data) > 64:
+                    logger.warning(f"Callback слишком длинный: {callback_data}")
+                    continue
+                button = InlineKeyboardButton(text=text_btn, callback_data=callback_data)
+            elif "url" in button_data:
+                url = button_data["url"]
+                button = InlineKeyboardButton(text=text_btn, url=url)
+            else:
+                logger.warning(f"Кнопка без действия: {line}")
+                continue
+
+            buttons.append([button])
+
+        except json.JSONDecodeError as e:
+            logger.warning(f"Ошибка парсинга JSON кнопки: {line} - {e}")
+            continue
+        except Exception as e:
+            logger.error(f"Ошибка создания кнопки: {line} - {e}")
+            continue
+
+    if not buttons:
+        return clean_text, None
+
+    keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
+    return clean_text, keyboard
 
 
 @router.callback_query(
@@ -25,10 +230,16 @@ class AdminSender(StatesGroup):
     IsAdminFilter(),
 )
 async def handle_sender(callback_query: CallbackQuery):
-    await callback_query.message.edit_text(
-        text="✍️ Выберите группу пользователей для рассылки:",
-        reply_markup=build_sender_kb(),
-    )
+    try:
+        await callback_query.message.edit_text(
+            text="✍️ Выберите группу пользователей для рассылки:",
+            reply_markup=build_sender_kb(),
+        )
+    except TelegramBadRequest as e:
+        if "message is not modified" in str(e):
+            logger.debug("[Sender] Сообщение не изменено, Telegram отклонил редактирование")
+        else:
+            raise
 
 
 @router.callback_query(
@@ -39,7 +250,22 @@ async def handle_sender_callback_text(
     callback_query: CallbackQuery, callback_data: AdminSenderCallback, state: FSMContext
 ):
     await callback_query.message.edit_text(
-        text="✍️ Введите текст сообщения для рассылки:",
+        text=(
+            "✍️ Введите текст сообщения для рассылки\n\n"
+            "Поддерживается только Telegram-форматирование — <b>жирный</b>, <i>курсив</i> и другие стили через редактор Telegram.\n\n"
+            "Вы можете отправить:\n"
+            "• Только <b>текст</b>\n"
+            "• Только <b>картинку</b>\n"
+            "• <b>Текст + картинку</b>\n"
+            "• <b>Сообщение + кнопки</b> (см. формат ниже)\n\n"
+            "<b>📋 Пример формата кнопок:</b>\n"
+            "<code>Ваше сообщение</code>\n\n"
+            "<code>BUTTONS:</code>\n"
+            '<code>{"text": "👤 Личный кабинет", "callback": "profile"}</code>\n'
+            '<code>{"text": "➕ Купить подписку", "callback": "buy"}</code>\n'
+            '<code>{"text": "🎁 Забрать купон", "url": "https://t.me/cupons"}</code>\n'
+            '<code>{"text": "📢 Канал", "url": "https://t.me/channel"}</code>'
+        ),
         reply_markup=build_admin_back_kb("sender"),
     )
     await state.update_data(type=callback_data.type, cluster_name=callback_data.data)
@@ -50,8 +276,10 @@ async def handle_sender_callback_text(
     AdminSenderCallback.filter(F.type == "cluster-select"),
     IsAdminFilter(),
 )
-async def handle_sender_callback(callback_query: CallbackQuery, session: Any):
-    clusters = await session.fetch("SELECT DISTINCT cluster_name FROM servers")
+async def handle_sender_callback(callback_query: CallbackQuery, session: AsyncSession):
+    result = await session.execute(select(Server.cluster_name).distinct())
+    clusters = result.mappings().all()
+
     await callback_query.message.answer(
         "✍️ Выберите кластер для рассылки сообщений:",
         reply_markup=build_clusters_kb(clusters),
@@ -59,89 +287,91 @@ async def handle_sender_callback(callback_query: CallbackQuery, session: Any):
 
 
 @router.message(AdminSender.waiting_for_message, IsAdminFilter())
-async def handle_message_input(message: Message, state: FSMContext, session: Any):
-    """
-    Обрабатывает ввод сообщения для рассылки (поддержка текста + фото).
-    """
-    text_message = message.html_text if message.text else None
+async def handle_message_input(message: Message, state: FSMContext, session: AsyncSession):
+    original_text = message.html_text or message.text or message.caption or ""
     photo = message.photo[-1].file_id if message.photo else None
-    photo_url = message.caption if message.photo and message.caption and message.caption.startswith("http") else None
 
-    if not text_message and message.caption:
-        text_message = message.caption
+    clean_text, keyboard = parse_message_buttons(original_text)
 
-    if not text_message and not photo and not photo_url:
-        await message.answer("⚠ Ошибка! Отправьте текст или изображение для рассылки.")
+    max_len = 1024 if photo else 4096
+    if len(clean_text) > max_len:
+        await message.answer(
+            f"⚠️ Сообщение слишком длинное.\nМаксимум: <b>{max_len}</b> символов, сейчас: <b>{len(clean_text)}</b>.",
+            reply_markup=build_admin_back_kb("sender"),
+        )
+        await state.clear()
         return
 
-    state_data = await state.get_data()
-    send_to = state_data.get("type", "all")
+    data = await state.get_data()
+    send_to = data.get("type", "all")
+    cluster_name = data.get("cluster_name")
+    _, user_count = await get_recipients(session, send_to, cluster_name)
 
-    if send_to == "subscribed":
-        tg_ids = await session.fetch(
-            """
-            SELECT DISTINCT c.tg_id 
-            FROM connections c
-            JOIN keys k ON c.tg_id = k.tg_id
-            WHERE k.expiry_time > $1
-            """,
-            int(datetime.utcnow().timestamp() * 1000),
-        )
-    elif send_to == "unsubscribed":
-        tg_ids = await session.fetch(
-            """
-            SELECT c.tg_id 
-            FROM connections c
-            LEFT JOIN keys k ON c.tg_id = k.tg_id
-            GROUP BY c.tg_id
-            HAVING COUNT(k.tg_id) = 0 OR MAX(k.expiry_time) <= $1
-            """,
-            int(datetime.utcnow().timestamp() * 1000),
-        )
-    elif send_to == "untrial":
-        tg_ids = await session.fetch("SELECT DISTINCT tg_id FROM connections WHERE trial = 0")
-    elif send_to == "cluster":
-        cluster_name = state_data.get("cluster_name")
-        tg_ids = await session.fetch(
-            """
-            SELECT DISTINCT c.tg_id
-            FROM connections c
-            JOIN keys k ON c.tg_id = k.tg_id
-            JOIN servers s ON k.server_id = s.cluster_name
-            WHERE s.cluster_name = $1
-            """,
-            cluster_name,
-        )
+    await state.update_data(text=clean_text, photo=photo, keyboard=keyboard.model_dump() if keyboard else None)
+    await state.set_state(AdminSender.preview)
+
+    if photo:
+        await message.answer_photo(photo=photo, caption=clean_text, parse_mode="HTML", reply_markup=keyboard)
     else:
-        tg_ids = await session.fetch("SELECT DISTINCT tg_id FROM connections")
+        await message.answer(text=clean_text, parse_mode="HTML", reply_markup=keyboard)
 
-    total_users = len(tg_ids)
-    success_count = 0
-
-    text = f"📤 <b>Рассылка начата!</b>\n👥 Количество получателей: {total_users}"
-
-    await message.answer(text=text)
-
-    for record in tg_ids:
-        tg_id = record["tg_id"]
-        try:
-            if photo or photo_url:
-                await message.bot.send_photo(
-                    chat_id=tg_id, photo=photo if photo else photo_url, caption=text_message, parse_mode="HTML"
-                )
-            else:
-                await message.bot.send_message(chat_id=tg_id, text=text_message, parse_mode="HTML")
-
-            success_count += 1
-        except Exception as e:
-            logger.error(f"❌ Ошибка отправки пользователю {tg_id}: {e}")
-
-    text = (
-        f"📤 <b>Рассылка завершена!</b>\n\n"
-        f"👥 <b>Количество получателей:</b> {total_users}\n"
-        f"✅ <b>Доставлено:</b> {success_count}\n"
-        f"❌ <b>Не доставлено:</b> {total_users - success_count}"
+    await message.answer(
+        f"👀 Это предпросмотр рассылки.\n👥 Количество получателей: <b>{user_count}</b>\n\nОтправить?",
+        reply_markup=InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(text="📤 Отправить", callback_data="send_message"),
+                    InlineKeyboardButton(text="❌ Отмена", callback_data="cancel_message"),
+                ]
+            ]
+        ),
     )
 
-    await message.answer(text=text, reply_markup=build_admin_back_kb("sender"))
+
+@router.callback_query(F.data == "send_message", IsAdminFilter())
+async def handle_send_confirm(callback_query: CallbackQuery, state: FSMContext, session: AsyncSession):
+    data = await state.get_data()
+    text_message = data.get("text")
+    photo = data.get("photo")
+    keyboard_data = data.get("keyboard")
+    send_to = data.get("type", "all")
+    cluster_name = data.get("cluster_name")
+
+    keyboard = None
+    if keyboard_data:
+        try:
+            keyboard = InlineKeyboardMarkup.model_validate(keyboard_data)
+        except Exception as e:
+            logger.error(f"Ошибка восстановления клавиатуры: {e}")
+
+    tg_ids, total_users = await get_recipients(session, send_to, cluster_name)
+
+    await callback_query.message.edit_text(f"📤 <b>Рассылка начата!</b>\n👥 Количество получателей: {total_users}")
+
+    messages = []
+    for tg_id in tg_ids:
+        message_data = {"tg_id": tg_id, "text": text_message, "photo": photo, "keyboard": keyboard}
+        messages.append(message_data)
+
+    results = await send_broadcast_batch(bot=callback_query.bot, messages=messages, batch_size=15, session=session)
+    success_count = sum(1 for result in results if result)
+
+    await callback_query.message.answer(
+        text=(
+            f"📤 <b>Рассылка завершена!</b>\n\n"
+            f"👥 <b>Количество получателей:</b> {total_users}\n"
+            f"✅ <b>Доставлено:</b> {success_count}\n"
+            f"❌ <b>Не доставлено:</b> {total_users - success_count}"
+        ),
+        reply_markup=build_admin_back_kb("sender"),
+    )
+    await state.clear()
+
+
+@router.callback_query(F.data == "cancel_message", IsAdminFilter())
+async def handle_send_cancel(callback_query: CallbackQuery, state: FSMContext):
+    await callback_query.message.edit_text(
+        "🚫 Рассылка отменена.",
+        reply_markup=build_admin_back_kb("sender"),
+    )
     await state.clear()

handlers/admin/servers/keyboard.py

@@ -1,5 +1,5 @@
 from aiogram.filters.callback_data import CallbackData
-from aiogram.types import InlineKeyboardMarkup
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from handlers.buttons import BACK
@@ -10,12 +10,96 @@ class AdminServerCallback(CallbackData, prefix="admin_server"):
     data: str
 
 
-def build_manage_server_kb(server_name: str, cluster_name: str) -> InlineKeyboardMarkup:
-    from ..clusters.keyboard import AdminClusterCallback
-
+def build_manage_server_kb(server_name: str, cluster_name: str, enabled: bool) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
-    builder.button(text="🗑️ Удалить", callback_data=AdminServerCallback(action="delete", data=server_name).pack())
-    builder.button(text="✏️ Сменить название", callback_data=AdminServerCallback(action="rename", data=server_name).pack())
-    builder.button(text=BACK, callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack())
+
+    toggle_text = "🔴 Отключить" if enabled else "🟢 Включить"
+    toggle_action = "disable" if enabled else "enable"
+
+    builder.button(
+        text=toggle_text,
+        callback_data=AdminServerCallback(action=toggle_action, data=server_name).pack(),
+    )
+
+    builder.button(
+        text="📈 Задать лимит",
+        callback_data=AdminServerCallback(action="set_limit", data=server_name).pack(),
+    )
+
+    builder.button(
+        text="🗑️ Удалить",
+        callback_data=AdminServerCallback(action="delete", data=server_name).pack(),
+    )
+
+    builder.button(
+        text="✏️ Редактировать",
+        callback_data=f"edit_server|{server_name}",
+    )
+
+    builder.button(
+        text="🔙 Назад",
+        callback_data=f"cluster_servers|{cluster_name}",
+    )
+
     builder.adjust(1)
     return builder.as_markup()
+
+
+def build_edit_server_fields_kb(server_name: str, server_data: dict) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    builder.row(
+        InlineKeyboardButton(text="📝 Имя сервера", callback_data=f"edit_server_field|{server_name}|server_name")
+    )
+
+    builder.row(InlineKeyboardButton(text="🗂 Кластер", callback_data=f"edit_server_field|{server_name}|cluster_name"))
+
+    builder.row(InlineKeyboardButton(text="🌐 API URL", callback_data=f"edit_server_field|{server_name}|api_url"))
+
+    if server_data.get("subscription_url"):
+        builder.row(
+            InlineKeyboardButton(
+                text="📡 Subscription URL", callback_data=f"edit_server_field|{server_name}|subscription_url"
+            )
+        )
+
+    builder.row(
+        InlineKeyboardButton(text="🔑 Inbound ID/Squads", callback_data=f"edit_server_field|{server_name}|inbound_id")
+    )
+
+    builder.row(InlineKeyboardButton(text="⚙️ Тип панели", callback_data=f"select_panel_type|{server_name}"))
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад", callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+        )
+    )
+
+    return builder.as_markup()
+
+
+def build_panel_type_selection_kb(server_name: str) -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[
+            [InlineKeyboardButton(text="🌐 3x-ui", callback_data=f"set_panel_type|{server_name}|3x-ui")],
+            [InlineKeyboardButton(text="🌀 remnawave", callback_data=f"set_panel_type|{server_name}|remnawave")],
+            [InlineKeyboardButton(text="⬅️ Назад", callback_data=f"edit_server|{server_name}")],
+        ]
+    )
+
+
+def build_cluster_selection_kb(server_name: str, clusters: list[str]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    for cluster in clusters:
+        builder.row(InlineKeyboardButton(text=cluster, callback_data=f"set_cluster|{server_name}|{cluster}"))
+
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data=f"edit_server|{server_name}"))
+
+    return builder.as_markup()
+
+
+def build_cancel_edit_kb(server_name: str) -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[[InlineKeyboardButton(text="❌ Отменить", callback_data=f"edit_server|{server_name}")]]
+    )

handlers/admin/servers/servers_handler.py

@@ -1,48 +1,95 @@
-from typing import Any
-
 from aiogram import F, Router, types
 from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
 from aiogram.types import CallbackQuery, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
-from handlers.buttons import BACK
+from sqlalchemy import delete, func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
 
-from database import delete_server, get_servers
+from database import get_servers
+from database.models import Key, Server
+from database.servers import (
+    get_available_clusters,
+    get_server_by_name,
+    update_server_cluster,
+    update_server_field,
+    update_server_name_with_keys,
+)
 from filters.admin import IsAdminFilter
+from handlers.buttons import BACK
 
 from ..panel.keyboard import build_admin_back_kb
 from .keyboard import (
     AdminServerCallback,
+    build_cancel_edit_kb,
+    build_cluster_selection_kb,
+    build_edit_server_fields_kb,
     build_manage_server_kb,
+    build_panel_type_selection_kb,
 )
 
 
 router = Router()
 
 
+class ServerLimitState(StatesGroup):
+    waiting_for_limit = State()
+
+
+class ServerEditState(StatesGroup):
+    choosing_field = State()
+    editing_value = State()
+
+
 @router.callback_query(AdminServerCallback.filter(F.action == "manage"), IsAdminFilter())
-async def handle_server_manage(callback_query: CallbackQuery, callback_data: AdminServerCallback):
+async def handle_server_manage(
+    callback_query: CallbackQuery,
+    callback_data: AdminServerCallback,
+    session: AsyncSession,
+):
     server_name = callback_data.data
-    servers = await get_servers()
+    servers = await get_servers(session=session, include_enabled=True)
 
     cluster_name, server = next(
-        ((c, s) for c, cs in servers.items() for s in cs if s["server_name"] == server_name), (None, None)
+        ((c, s) for c, cs in servers.items() for s in cs if s["server_name"] == server_name),
+        (None, None),
     )
 
     if server:
         api_url = server["api_url"]
         subscription_url = server["subscription_url"]
         inbound_id = server["inbound_id"]
+        panel_type = server.get("panel_type") or "не указан"
+        max_keys = server.get("max_keys")
+        limit_display = f"{max_keys}" if max_keys else "не задан"
+
+        result = await session.execute(select(func.count()).where(Key.server_id == server_name))
+        subscription_count = result.scalar() or 0
 
         text = (
-            f"<b>🔧 Информация о сервере {server_name}:</b>\n\n"
-            f"<b>📡 API URL:</b> {api_url}\n"
-            f"<b>🌐 Subscription URL:</b> {subscription_url}\n"
-            f"<b>🔑 Inbound ID:</b> {inbound_id}"
+            f"<b>🔧 Информация о сервере {server_name}:</b>\n"
+            f"<blockquote>"
+            f"🗂 Кластер: <b>{cluster_name}</b>\n"
+            f"📡 API URL: <b>{api_url}</b>\n"
         )
 
+        if subscription_url:
+            text += f"🌐 Subscription URL: <b>{subscription_url}</b>\n"
+
+        text += (
+            f"🔑 Inbound ID/Squads: <b>{inbound_id}</b>\n"
+            f"⚙️ Тип панели: <b>{panel_type}</b>\n"
+            f"📈 Лимит ключей: <b>{limit_display}</b>\n"
+        )
+
+        if subscription_count > 0:
+            text += f"🔑 Подписок на сервере: <b>{subscription_count}</b>\n"
+
+        text += "</blockquote>"
+
         await callback_query.message.edit_text(
             text=text,
-            reply_markup=build_manage_server_kb(server_name, cluster_name),
+            reply_markup=build_manage_server_kb(server_name, cluster_name, enabled=server.get("enabled", True)),
         )
     else:
         await callback_query.message.edit_text(text="❌ Сервер не найден.")
@@ -50,20 +97,20 @@ async def handle_server_manage(callback_query: CallbackQuery, callback_data: Adm
 
 @router.callback_query(AdminServerCallback.filter(F.action == "delete"), IsAdminFilter())
 async def process_callback_delete_server(
-    callback_query: CallbackQuery, callback_data: AdminServerCallback, state: FSMContext, session: Any
+    callback_query: CallbackQuery,
+    callback_data: AdminServerCallback,
+    state: FSMContext,
+    session: AsyncSession,
 ):
     from ..clusters.clusters_handler import AdminClusterStates
 
     server_name = callback_data.data
 
-    servers = await get_servers(session)
+    servers_dict = await get_servers(session, include_enabled=True)
     cluster_name = None
-    for c_name, server_list in servers.items():
-        for server in server_list:
-            if server["server_name"] == server_name:
-                cluster_name = c_name
-                break
-        if cluster_name:
+    for c_name, server_list in servers_dict.items():
+        if any(s["server_name"] == server_name for s in server_list):
+            cluster_name = c_name
             break
 
     if not cluster_name:
@@ -73,36 +120,41 @@ async def process_callback_delete_server(
         )
         return
 
-    keys_count = await session.fetchval(
-        "SELECT COUNT(*) FROM keys WHERE server_id = $1",
-        server_name
-    )
+    stmt_keys_count = select(func.count()).where(Key.server_id == server_name)
+    result = await session.execute(stmt_keys_count)
+    keys_count = result.scalar_one()
 
     if keys_count > 0:
         await state.update_data(server_name=server_name, cluster_name=cluster_name)
 
-        all_servers = await session.fetch(
-            """
-            SELECT server_name, (SELECT COUNT(*) FROM keys WHERE server_id = servers.server_name) as key_count
-            FROM servers
-            WHERE server_name != $1
-            """,
-            server_name
-        )
+        subq = select(func.count()).where(Key.server_id == Server.server_name).correlate(Server).scalar_subquery()
+
+        stmt_all_servers = select(Server.server_name, subq.label("key_count")).where(Server.server_name != server_name)
+        result = await session.execute(stmt_all_servers)
+        all_servers = result.all()
 
         if all_servers:
             builder = InlineKeyboardBuilder()
-            for server in all_servers:
+            for s_name, key_count in all_servers:
+                callback_data = f"transfer_to_server|{s_name}|{server_name}"
+                if len(callback_data.encode("utf-8")) > 64:
+                    await callback_query.message.edit_text(
+                        text=f"❌ Ошибка: название сервера '{s_name}' слишком длинное.\n\n"
+                        f"Пожалуйста, переименуйте сервер в более короткое название и попробуйте снова.",
+                        reply_markup=build_admin_back_kb("clusters"),
+                    )
+                    return
+
                 builder.row(
                     InlineKeyboardButton(
-                        text=f"{server['server_name']} ({server['key_count']})",
-                        callback_data=f"transfer_to_server|{server['server_name']}|{server_name}"
+                        text=f"{s_name} ({key_count})",
+                        callback_data=callback_data,
                     )
                 )
             builder.row(
                 InlineKeyboardButton(
                     text=BACK,
-                    callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+                    callback_data=AdminServerCallback(action="manage", data=server_name).pack(),
                 )
             )
 
@@ -113,49 +165,58 @@ async def process_callback_delete_server(
             await state.set_state(AdminClusterStates.waiting_for_server_transfer)
             return
 
-    remaining_servers = await session.fetchval(
-        "SELECT COUNT(*) FROM servers WHERE cluster_name = $1 AND server_name != $2",
-        cluster_name,
-        server_name
+    stmt_remaining = select(func.count()).where(
+        (Server.cluster_name == cluster_name) & (Server.server_name != server_name)
     )
+    result = await session.execute(stmt_remaining)
+    remaining_servers = result.scalar_one()
 
     if remaining_servers == 0:
-        other_clusters = await session.fetch(
-            "SELECT DISTINCT cluster_name FROM servers WHERE cluster_name != $1",
-            cluster_name
-        )
+        stmt_other_clusters = select(Server.cluster_name).distinct().where(Server.cluster_name != cluster_name)
+        result = await session.execute(stmt_other_clusters)
+        other_clusters = result.scalars().all()
 
         if other_clusters:
-            cluster_keys_count = await session.fetchval(
-                "SELECT COUNT(*) FROM keys WHERE server_id = $1",
-                cluster_name
-            )
+            stmt_cluster_keys = select(func.count()).where(Key.server_id == cluster_name)
+            result = await session.execute(stmt_cluster_keys)
+            cluster_keys_count = result.scalar_one()
 
             if cluster_keys_count > 0:
                 await state.update_data(server_name=server_name, cluster_name=cluster_name)
 
-                all_clusters = await session.fetch(
-                    """
-                    SELECT cluster_name, (SELECT COUNT(*) FROM keys WHERE server_id = servers.cluster_name) as key_count
-                    FROM servers
-                    WHERE cluster_name != $1
-                    GROUP BY cluster_name
-                    """,
-                    cluster_name
+                subq_cluster = (
+                    select(func.count()).where(Key.server_id == Server.cluster_name).correlate(Server).scalar_subquery()
                 )
 
+                stmt_all_clusters = (
+                    select(Server.cluster_name, subq_cluster.label("key_count"))
+                    .where(Server.cluster_name != cluster_name)
+                    .group_by(Server.cluster_name)
+                )
+                result = await session.execute(stmt_all_clusters)
+                all_clusters = result.all()
+
                 builder = InlineKeyboardBuilder()
-                for cluster in all_clusters:
+                for cl_name, key_count in all_clusters:
+                    callback_data = f"transfer_to_cluster|{cl_name}|{cluster_name}|{server_name}"
+                    if len(callback_data.encode("utf-8")) > 64:
+                        await callback_query.message.edit_text(
+                            text=f"❌ Ошибка: название сервера '{server_name}' или кластера '{cl_name}' слишком длинное.\n\n"
+                            f"Пожалуйста, переименуйте сервер в более короткое название и попробуйте снова.",
+                            reply_markup=build_admin_back_kb("clusters"),
+                        )
+                        return
+
                     builder.row(
                         InlineKeyboardButton(
-                            text=f"{cluster['cluster_name']} ({cluster['key_count']})",
-                            callback_data=f"transfer_to_cluster|{cluster['cluster_name']}|{cluster_name}|{server_name}"
+                            text=f"{cl_name} ({key_count})",
+                            callback_data=callback_data,
                         )
                     )
                 builder.row(
                     InlineKeyboardButton(
                         text=BACK,
-                        callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+                        callback_data=AdminServerCallback(action="manage", data=server_name).pack(),
                     )
                 )
 
@@ -166,22 +227,254 @@ async def process_callback_delete_server(
                 await state.set_state(AdminClusterStates.waiting_for_cluster_transfer)
                 return
 
-        await session.execute(
-            "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2",
-            cluster_name,
-            server_name
-        )
+        stmt_delete = delete(Server).where((Server.cluster_name == cluster_name) & (Server.server_name == server_name))
+        await session.execute(stmt_delete)
+        await session.commit()
         await callback_query.message.edit_text(
             text=f"✅ Сервер '{server_name}' удален. Кластер '{cluster_name}' также удален, так как в нем не осталось серверов.",
             reply_markup=build_admin_back_kb("clusters"),
         )
     else:
-        await session.execute(
-            "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2",
-            cluster_name,
-            server_name
-        )
+        stmt_delete = delete(Server).where((Server.cluster_name == cluster_name) & (Server.server_name == server_name))
+        await session.execute(stmt_delete)
+        await session.commit()
         await callback_query.message.edit_text(
             text=f"✅ Сервер '{server_name}' удален.",
             reply_markup=build_admin_back_kb("clusters"),
         )
+
+
+@router.callback_query(AdminServerCallback.filter(F.action.in_(["enable", "disable"])), IsAdminFilter())
+async def toggle_server_enabled(
+    callback_query: CallbackQuery,
+    callback_data: AdminServerCallback,
+    session: AsyncSession,
+):
+    server_name = callback_data.data
+    action = callback_data.action
+
+    new_status = action == "enable"
+
+    await session.execute(update(Server).where(Server.server_name == server_name).values(enabled=new_status))
+    await session.commit()
+
+    servers = await get_servers(session=session, include_enabled=True)
+
+    cluster_name, server = next(
+        ((c, s) for c, cs in servers.items() for s in cs if s["server_name"] == server_name),
+        (None, None),
+    )
+
+    if not server:
+        await callback_query.message.edit_text("❌ Сервер не найден.")
+        return
+
+    max_keys = server.get("max_keys")
+    limit_display = f"{max_keys}" if max_keys else "не задан"
+
+    text = (
+        f"<b>🔧 Информация о сервере {server_name}:</b>\n\n"
+        f"<b>📡 API URL:</b> {server['api_url']}\n"
+        f"<b>🌐 Subscription URL:</b> {server['subscription_url']}\n"
+        f"<b>🔑 Inbound ID/Squads:</b> {server['inbound_id']}\n"
+        f"<b>📈 Лимит ключей:</b> {limit_display}"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_manage_server_kb(server_name, cluster_name, enabled=new_status),
+    )
+
+
+@router.callback_query(AdminServerCallback.filter(F.action == "set_limit"), IsAdminFilter())
+async def ask_server_limit(callback_query: CallbackQuery, callback_data: AdminServerCallback, state: FSMContext):
+    server_name = callback_data.data
+    await state.set_state(ServerLimitState.waiting_for_limit)
+    await state.update_data(server_name=server_name)
+    await callback_query.message.edit_text(
+        f"Введите лимит ключей для сервера <b>{server_name}</b> (целое число, 0 — без лимита):",
+    )
+
+
+@router.message(ServerLimitState.waiting_for_limit, IsAdminFilter())
+async def save_server_limit(message: types.Message, state: FSMContext, session: AsyncSession):
+    try:
+        limit = int(message.text.strip())
+        if limit < 0:
+            raise ValueError
+
+        data = await state.get_data()
+        server_name = data["server_name"]
+
+        new_value = limit if limit > 0 else None
+
+        await session.execute(update(Server).where(Server.server_name == server_name).values(max_keys=new_value))
+        await session.commit()
+
+        servers = await get_servers(session=session, include_enabled=True)
+        cluster_name, server = next(
+            ((c, s) for c, cs in servers.items() for s in cs if s["server_name"] == server_name),
+            (None, None),
+        )
+
+        if not server:
+            await message.answer("❌ Сервер не найден.")
+            await state.clear()
+            return
+
+        max_keys = server.get("max_keys")
+        limit_display = f"{max_keys}" if max_keys is not None else "не задан"
+
+        text = (
+            f"<b>🔧 Информация о сервере {server_name}:</b>\n\n"
+            f"<b>📡 API URL:</b> {server['api_url']}\n"
+            f"<b>🌐 Subscription URL:</b> {server['subscription_url']}\n"
+            f"<b>🔑 Inbound ID/Squads:</b> {server['inbound_id']}\n"
+            f"<b>📈 Лимит ключей:</b> {limit_display}"
+        )
+
+        await message.answer(
+            text,
+            reply_markup=build_manage_server_kb(server_name, cluster_name, enabled=server.get("enabled", True)),
+        )
+        await state.clear()
+
+    except ValueError:
+        await message.answer("❌ Введите корректное целое число (0 = без лимита)")
+
+
+@router.callback_query(F.data.startswith("edit_server|"), IsAdminFilter())
+async def start_edit_server(callback: CallbackQuery, state: FSMContext, session: AsyncSession):
+    server_name = callback.data.split("|")[1]
+
+    await state.clear()
+
+    server_data = await get_server_by_name(session, server_name)
+    if not server_data:
+        await callback.message.edit_text("❌ Сервер не найден.")
+        return
+
+    await callback.message.edit_text(
+        f"<b>✏️ Редактирование сервера: {server_name}</b>\n\nВыберите поле для редактирования:",
+        reply_markup=build_edit_server_fields_kb(server_name, server_data),
+    )
+
+
+@router.callback_query(F.data.startswith("edit_server_field|"), IsAdminFilter())
+async def ask_new_field_value(callback: CallbackQuery, state: FSMContext, session: AsyncSession):
+    _, server_name, field = callback.data.split("|")
+
+    if field == "cluster_name":
+        clusters = await get_available_clusters(session)
+        await callback.message.edit_text(
+            f"<b>🗂 Выберите кластер для сервера {server_name}:</b>",
+            reply_markup=build_cluster_selection_kb(server_name, clusters),
+        )
+        return
+
+    await state.update_data(server_name=server_name, field=field)
+    await state.set_state(ServerEditState.editing_value)
+
+    field_names = {
+        "server_name": "имя сервера",
+        "api_url": "API URL",
+        "subscription_url": "Subscription URL",
+        "inbound_id": "Inbound ID/Squads",
+    }
+
+    await callback.message.edit_text(
+        f"✏️ Введите новое значение для <b>{field_names.get(field, field)}</b>:",
+        reply_markup=build_cancel_edit_kb(server_name),
+    )
+
+
+@router.callback_query(F.data.startswith("select_panel_type|"), IsAdminFilter())
+async def select_panel_type(callback: CallbackQuery):
+    server_name = callback.data.split("|")[1]
+
+    await callback.message.edit_text(
+        f"<b>⚙️ Выберите тип панели для сервера {server_name}:</b>",
+        reply_markup=build_panel_type_selection_kb(server_name),
+    )
+
+
+@router.callback_query(F.data.startswith("set_panel_type|"), IsAdminFilter())
+async def set_panel_type(callback: CallbackQuery, session: AsyncSession):
+    _, server_name, panel_type = callback.data.split("|")
+
+    success = await update_server_field(session, server_name, "panel_type", panel_type)
+    if success:
+        await callback.message.edit_text(
+            f"✅ Тип панели сервера {server_name} изменен на {panel_type}",
+            reply_markup=InlineKeyboardBuilder()
+            .button(
+                text="⬅️ Назад к серверу", callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+            )
+            .as_markup(),
+        )
+    else:
+        await callback.message.edit_text("❌ Ошибка при изменении типа панели")
+
+
+@router.callback_query(F.data.startswith("set_cluster|"), IsAdminFilter())
+async def set_cluster(callback: CallbackQuery, session: AsyncSession):
+    _, server_name, new_cluster = callback.data.split("|")
+
+    success = await update_server_cluster(session, server_name, new_cluster)
+    if success:
+        await callback.message.edit_text(
+            f"✅ Кластер сервера {server_name} изменен на {new_cluster}",
+            reply_markup=InlineKeyboardBuilder()
+            .button(
+                text="⬅️ Назад к серверу", callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+            )
+            .as_markup(),
+        )
+    else:
+        await callback.message.edit_text("❌ Ошибка при изменении кластера")
+
+
+@router.message(ServerEditState.editing_value, IsAdminFilter())
+async def apply_field_edit(message: types.Message, state: FSMContext, session: AsyncSession):
+    data = await state.get_data()
+    server_name = data["server_name"]
+    field = data["field"]
+    value = message.text.strip()
+
+    if field == "server_name":
+        if len(value) > 12:
+            await message.answer(
+                text="❌ Имя сервера не должно превышать 12 символов. Попробуйте снова.",
+                reply_markup=build_admin_back_kb("clusters"),
+            )
+            return
+
+        success = await update_server_name_with_keys(session, server_name, value)
+        if success:
+            server_name = value
+        else:
+            await message.answer("❌ Ошибка при изменении имени сервера. Возможно, такое имя уже существует.")
+            return
+    else:
+        success = await update_server_field(session, server_name, field, value)
+
+    if success:
+        field_names = {
+            "server_name": "имя сервера",
+            "api_url": "API URL",
+            "subscription_url": "Subscription URL",
+            "inbound_id": "Inbound ID/Squads",
+        }
+
+        await message.answer(
+            f"✅ {field_names.get(field, field).capitalize()} изменено",
+            reply_markup=InlineKeyboardBuilder()
+            .button(
+                text="⬅️ Назад к серверу", callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+            )
+            .as_markup(),
+        )
+    else:
+        await message.answer("❌ Ошибка при изменении поля")
+
+    await state.clear()

handlers/admin/stats/keyboard.py

@@ -12,14 +12,16 @@ def build_stats_kb() -> InlineKeyboardMarkup:
         callback_data=AdminPanelCallback(action="stats_export_users_csv").pack(),
     )
     builder.button(
-        text="📥 Выгрузить оплаты в CSV", callback_data=AdminPanelCallback(action="stats_export_payments_csv").pack()
+        text="📥 Выгрузить оплаты в CSV",
+        callback_data=AdminPanelCallback(action="stats_export_payments_csv").pack(),
     )
     builder.button(
         text="📥 Выгрузить подписки в CSV",
         callback_data=AdminPanelCallback(action="stats_export_keys_csv").pack(),
     )
     builder.button(
-        text="📥 Выгрузить горящих лидов", callback_data=AdminPanelCallback(action="stats_export_hot_leads_csv").pack()
+        text="📥 Выгрузить горящих лидов",
+        callback_data=AdminPanelCallback(action="stats_export_hot_leads_csv").pack(),
     )
     builder.row(build_admin_back_btn())
     builder.adjust(1)

handlers/admin/stats/stats_handler.py

@@ -1,15 +1,42 @@
-from datetime import datetime
-from typing import Any
+from collections import Counter
+from datetime import datetime, timedelta
 
 import pytz
 
 from aiogram import F, Router
 from aiogram.exceptions import TelegramBadRequest
-from aiogram.types import CallbackQuery
+from aiogram.types import CallbackQuery, Message
+from sqlalchemy.ext.asyncio import AsyncSession
 
+from bot import bot
+from config import ADMIN_ID
+from database import (
+    count_active_keys,
+    count_hot_leads,
+    count_total_keys,
+    count_total_referrals,
+    count_total_users,
+    count_trial_keys,
+    count_users_registered_between,
+    count_users_registered_since,
+    count_users_updated_today,
+    get_tariff_distribution,
+    get_tariff_durations,
+    get_tariff_groups,
+    get_tariff_names,
+    sum_payments_between,
+    sum_payments_since,
+    sum_total_payments,
+)
 from filters.admin import IsAdminFilter
+from hooks.hooks import run_hooks
 from logger import logger
-from utils.csv_export import export_hot_leads_csv, export_keys_csv, export_payments_csv, export_users_csv
+from utils.csv_export import (
+    export_hot_leads_csv,
+    export_keys_csv,
+    export_payments_csv,
+    export_users_csv,
+)
 
 from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
 from .keyboard import build_stats_kb
@@ -18,125 +45,179 @@ from .keyboard import build_stats_kb
 router = Router()
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "stats"),
-    IsAdminFilter(),
-)
-async def handle_stats(callback_query: CallbackQuery, session: Any):
+@router.callback_query(AdminPanelCallback.filter(F.action == "stats"), IsAdminFilter())
+async def handle_stats(callback_query: CallbackQuery, session: AsyncSession):
     try:
-        total_users = await session.fetchval("SELECT COUNT(*) FROM users")
-        total_keys = await session.fetchval("SELECT COUNT(*) FROM keys")
-        total_referrals = await session.fetchval("SELECT COUNT(*) FROM referrals")
-
-        total_payments_today = int(
-            await session.fetchval("SELECT COALESCE(SUM(amount), 0) FROM payments WHERE created_at >= CURRENT_DATE")
-        )
-        total_payments_week = int(
-            await session.fetchval(
-                "SELECT COALESCE(SUM(amount), 0) FROM payments WHERE created_at >= date_trunc('week', CURRENT_DATE)"
-            )
-        )
-        total_payments_month = int(
-            await session.fetchval(
-                "SELECT COALESCE(SUM(amount), 0) FROM payments WHERE created_at >= date_trunc('month', CURRENT_DATE)"
-            )
-        )
-        total_payments_last_month = int(
-            await session.fetchval(
-                """
-                SELECT COALESCE(SUM(amount), 0)
-                FROM payments
-                WHERE created_at >= date_trunc('month', CURRENT_DATE - interval '1 month')
-                AND created_at < date_trunc('month', CURRENT_DATE)
-                """
-            )
-        )
-        total_payments_all_time = int(await session.fetchval("SELECT COALESCE(SUM(amount), 0) FROM payments"))
-
-        all_keys = await session.fetch("SELECT created_at, expiry_time FROM keys")
-
-        def count_subscriptions_by_duration(keys):
-            periods = {"trial": 0, "1": 0, "3": 0, "6": 0, "12": 0}
-            for key in keys:
-                try:
-                    duration_days = (key["expiry_time"] - key["created_at"]) / (1000 * 60 * 60 * 24)
-
-                    if duration_days <= 29:
-                        periods["trial"] += 1
-                    elif duration_days <= 89:
-                        periods["1"] += 1
-                    elif duration_days <= 179:
-                        periods["3"] += 1
-                    elif duration_days <= 359:
-                        periods["6"] += 1
-                    else:
-                        periods["12"] += 1
-                except Exception as e:
-                    logger.error(f"Error processing key duration: {e}")
-                    continue
-            return periods
-
-        subs_all_time = count_subscriptions_by_duration(all_keys)
-
-        registrations_today = await session.fetchval("SELECT COUNT(*) FROM users WHERE created_at >= CURRENT_DATE")
-        registrations_week = await session.fetchval(
-            "SELECT COUNT(*) FROM users WHERE created_at >= date_trunc('week', CURRENT_DATE)"
-        )
-        registrations_month = await session.fetchval(
-            "SELECT COUNT(*) FROM users WHERE created_at >= date_trunc('month', CURRENT_DATE)"
-        )
-
-        users_updated_today = await session.fetchval("SELECT COUNT(*) FROM users WHERE updated_at >= CURRENT_DATE")
-
-        active_keys = await session.fetchval(
-            "SELECT COUNT(*) FROM keys WHERE expiry_time > $1",
-            int(datetime.utcnow().timestamp() * 1000),
-        )
-        expired_keys = total_keys - active_keys
         moscow_tz = pytz.timezone("Europe/Moscow")
-        update_time = datetime.now(moscow_tz).strftime("%d.%m.%y %H:%M:%S")
+        now = datetime.now(moscow_tz)
+        today = now.date()
 
-        hot_leads_count = await session.fetchval("""
-            SELECT COUNT(DISTINCT u.tg_id)
-            FROM users u
-            JOIN payments p ON u.tg_id = p.tg_id
-            LEFT JOIN keys k ON u.tg_id = k.tg_id
-            WHERE p.status = 'success'
-            AND k.tg_id IS NULL
-        """)
+        total_users = await count_total_users(session)
+        today_start = moscow_tz.localize(datetime.combine(today, datetime.min.time()))
+        today_start_utc = today_start.astimezone(pytz.UTC).replace(tzinfo=None)
+
+        users_updated_today = await count_users_updated_today(session, today_start_utc)
+        registrations_today = await count_users_registered_since(session, today_start_utc)
+
+        yesterday_date = today - timedelta(days=1)
+        yesterday_start = moscow_tz.localize(datetime.combine(yesterday_date, datetime.min.time()))
+        yesterday_end = moscow_tz.localize(datetime.combine(today, datetime.min.time()))
+        yesterday_start_utc = yesterday_start.astimezone(pytz.UTC).replace(tzinfo=None)
+        yesterday_end_utc = yesterday_end.astimezone(pytz.UTC).replace(tzinfo=None)
+
+        registrations_yesterday = await count_users_registered_between(session, yesterday_start_utc, yesterday_end_utc)
+
+        week_start_date = today - timedelta(days=today.weekday())
+        week_start = moscow_tz.localize(datetime.combine(week_start_date, datetime.min.time()))
+        week_start_utc = week_start.astimezone(pytz.UTC).replace(tzinfo=None)
+
+        month_start_date = today.replace(day=1)
+        month_start = moscow_tz.localize(datetime.combine(month_start_date, datetime.min.time()))
+        month_start_utc = month_start.astimezone(pytz.UTC).replace(tzinfo=None)
+
+        registrations_week = await count_users_registered_since(session, week_start_utc)
+        registrations_month = await count_users_registered_since(session, month_start_utc)
+
+        last_month_start_date = (today.replace(day=1) - timedelta(days=1)).replace(day=1)
+        this_month_start_date = today.replace(day=1)
+
+        last_month_start = moscow_tz.localize(datetime.combine(last_month_start_date, datetime.min.time()))
+        last_month_end = moscow_tz.localize(datetime.combine(this_month_start_date, datetime.min.time()))
+        last_month_start_utc = last_month_start.astimezone(pytz.UTC).replace(tzinfo=None)
+        last_month_end_utc = last_month_end.astimezone(pytz.UTC).replace(tzinfo=None)
+
+        registrations_last_month = await count_users_registered_between(
+            session, last_month_start_utc, last_month_end_utc
+        )
+
+        total_keys = await count_total_keys(session)
+        active_keys = await count_active_keys(session)
+        expired_keys = total_keys - active_keys
+        trial_keys_count = await count_trial_keys(session)
+
+        tariff_counts, no_tariff_keys = await get_tariff_distribution(session, include_unbound=True)
+        tariff_names = await get_tariff_names(session, [tid for tid, _ in tariff_counts])
+        tariff_groups = await get_tariff_groups(session, [tid for tid, _ in tariff_counts])
+        tariff_durations = await get_tariff_durations(session, [tid for tid, _ in tariff_counts])
+
+        grouped_tariffs = {}
+        for tid, count in tariff_counts:
+            group = tariff_groups.get(tid, "unknown")
+            if group not in grouped_tariffs:
+                grouped_tariffs[group] = []
+            grouped_tariffs[group].append((tid, count))
+
+        tariff_stats_text = ""
+        duration_buckets = Counter()
+        now_ts = int(now.timestamp() * 1000)
+
+        for key in no_tariff_keys:
+            duration_days = round((key["expiry_time"] - now_ts) / (1000 * 60 * 60 * 24))
+            if 25 <= duration_days <= 35:
+                bucket = "Без тарифа: 1 мес"
+            elif 80 <= duration_days <= 100:
+                bucket = "Без тарифа: 3 мес"
+            elif 170 <= duration_days <= 200:
+                bucket = "Без тарифа: 6 мес"
+            elif 350 <= duration_days <= 380:
+                bucket = "Без тарифа: 12 мес"
+            else:
+                bucket = "Без тарифа: прочее"
+            duration_buckets[bucket] += 1
+
+        bucket_order = {
+            "Без тарифа: 1 мес": 1,
+            "Без тарифа: 3 мес": 2,
+            "Без тарифа: 6 мес": 3,
+            "Без тарифа: 12 мес": 4,
+            "Без тарифа: прочее": 5,
+        }
+        sorted_buckets = sorted(duration_buckets.items(), key=lambda x: bucket_order.get(x[0], 999))
+
+        for name, count in sorted_buckets:
+            tariff_stats_text += f"├ {name}: <b>{count}</b>\n"
+
+        for group, tariffs in grouped_tariffs.items():
+            tariff_stats_text += f"Тариф {group}\n"
+            sorted_tariffs = sorted(tariffs, key=lambda x: tariff_durations.get(x[0], 0))
+            for tid, count in sorted_tariffs:
+                name = tariff_names.get(tid, f"ID {tid}")
+                tariff_stats_text += f" ├ {name}: <b>{count}</b>\n"
+
+        tariff_stats_text = (
+            "└ По тарифам и срокам:\n" + tariff_stats_text if tariff_stats_text else "└ Нет данных по тарифам\n"
+        )
+
+        total_referrals = await count_total_referrals(session)
+
+        total_payments_today = await sum_payments_since(session, today_start.replace(tzinfo=None))
+        total_payments_yesterday = await sum_payments_between(
+            session, yesterday_start.replace(tzinfo=None), yesterday_end.replace(tzinfo=None)
+        )
+        total_payments_week = await sum_payments_since(session, week_start.replace(tzinfo=None))
+        total_payments_month = await sum_payments_since(session, month_start.replace(tzinfo=None))
+        total_payments_last_month = await sum_payments_between(
+            session, last_month_start.replace(tzinfo=None), last_month_end.replace(tzinfo=None)
+        )
+        total_payments_all_time = await sum_total_payments(session)
+        hot_leads_count = await count_hot_leads(session)
+
+        update_time = now.strftime("%d.%m.%y %H:%M:%S")
 
         stats_message = (
-            "📊 <b>Статистика проекта</b>\n\n"
-            "👤 <b>Пользователи:</b>\n"
+            f"📊 <b>Статистика проекта</b>\n\n"
+            f"👤 <b>Пользователи:</b>\n"
+            f"<blockquote>"
             f"├ 🗓️ За день: <b>{registrations_today}</b>\n"
+            f"├ 🗓️ Вчера: <b>{registrations_yesterday}</b>\n"
             f"├ 📆 За неделю: <b>{registrations_week}</b>\n"
             f"├ 🗓️ За месяц: <b>{registrations_month}</b>\n"
-            f"└ 🌐 Всего: <b>{total_users}</b>\n\n"
-            "💡 <b>Активность:</b>\n"
+            f"├ 📅 За прошлый месяц: <b>{registrations_last_month}</b>\n"
+            f"└ 🌐 Всего: <b>{total_users}</b>\n"
+            f"</blockquote>\n"
+            f"💡 <b>Активность:</b>\n"
             f"└ 👥 Сегодня были активны: <b>{users_updated_today}</b>\n\n"
-            "🤝 <b>Реферальная система:</b>\n"
+            f"🤝 <b>Реферальная система:</b>\n"
             f"└ 👥 Всего привлечено: <b>{total_referrals}</b>\n\n"
-            "🔐 <b>Подписки:</b>\n"
+            f"🔐 <b>Подписки:</b>\n"
+            f"<blockquote>"
             f"├ 📦 Всего сгенерировано: <b>{total_keys}</b>\n"
             f"├ ✅ Активных: <b>{active_keys}</b>\n"
             f"├ ❌ Просроченных: <b>{expired_keys}</b>\n"
-            f"└ 📋 По срокам:\n"
-            f"     • 🎁 Триал: <b>{subs_all_time['trial']}</b>\n"
-            f"     • 🗓️ 1 мес: <b>{subs_all_time['1']}</b>\n"
-            f"     • 🗓️ 3 мес: <b>{subs_all_time['3']}</b>\n"
-            f"     • 🗓️ 6 мес: <b>{subs_all_time['6']}</b>\n"
-            f"     • 🗓️ 12 мес: <b>{subs_all_time['12']}</b>\n\n"
-            "💰 <b>Финансы:</b>\n"
+            f"├ 🧪 Триальных: <b>{trial_keys_count}</b>\n"
+            f"{tariff_stats_text}"
+            f"</blockquote>\n"
+            f"💰 <b>Финансы:</b>\n"
+            f"<blockquote>"
             f"├ 📅 За день: <b>{total_payments_today} ₽</b>\n"
+            f"├ 📆 Вчера: <b>{total_payments_yesterday} ₽</b>\n"
             f"├ 📆 За неделю: <b>{total_payments_week} ₽</b>\n"
             f"├ 📆 За месяц: <b>{total_payments_month} ₽</b>\n"
-            f"├ 📆 За прошлый месяц: <b>{total_payments_last_month} ₽</b>\n"
-            f"└ 🏦 Всего: <b>{total_payments_all_time} ₽</b>\n\n"
-            f"🔥 <b>Горящие лиды</b>: <b>{hot_leads_count}</b> (платили, но не продлили)\n\n"
+            f"├ 📆 Прошлый месяц: <b>{total_payments_last_month} ₽</b>\n"
+            f"└ 🏦 Всего: <b>{total_payments_all_time} ₽</b>\n"
+            f"</blockquote>\n"
+            f"🔥 <b>Горячие лиды: {hot_leads_count}</b>\n"
             f"⏱️ <i>Последнее обновление:</i> <code>{update_time}</code>"
         )
 
-        await callback_query.message.edit_text(text=stats_message, reply_markup=build_stats_kb())
+        extra_blocks = await run_hooks("admin_stats", session=session, now=now)
+        if extra_blocks:
+            stats_message += "\n\n" + "\n\n".join([str(b) for b in extra_blocks if b])
+
+        new_kb = build_stats_kb()
+        current_text = callback_query.message.html_text or callback_query.message.text or ""
+        cur_kb = callback_query.message.reply_markup
+        cur_kb_json = cur_kb.model_dump_json() if cur_kb else None
+        new_kb_json = new_kb.model_dump_json() if new_kb else None
+
+        if current_text == stats_message and cur_kb_json == new_kb_json:
+            try:
+                await callback_query.answer()
+            except Exception:
+                pass
+        else:
+            await callback_query.message.edit_text(text=stats_message, reply_markup=new_kb)
+
     except TelegramBadRequest as e:
         if "message is not modified" not in str(e):
             logger.error(f"Error in user_stats_menu: {e}")
@@ -145,57 +226,83 @@ async def handle_stats(callback_query: CallbackQuery, session: Any):
         await callback_query.answer("Произошла ошибка при получении статистики", show_alert=True)
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "stats_export_users_csv"),
-    IsAdminFilter(),
-)
-async def handle_export_users_csv(callback_query: CallbackQuery, session: Any):
+@router.callback_query(AdminPanelCallback.filter(F.action == "stats_export_users_csv"), IsAdminFilter())
+async def handle_export_users_csv(callback_query: CallbackQuery, session: AsyncSession):
     kb = build_admin_back_kb("stats")
     try:
         export = await export_users_csv(session)
-        await callback_query.message.answer_document(document=export, caption="📥 Экспорт пользователей в CSV")
+        await callback_query.message.answer_document(document=export, caption="📅 Экспорт пользователей в CSV")
     except Exception as e:
-        logger.error(f"Ошибка при экспорте пользователей в CSV: {e}")
-        await callback_query.message.edit_text(text=f"❗ Произошла ошибка при экспорте: {e}", reply_markup=kb)
+        logger.error(f"Ошибка при экспорте пользователей: {e}")
+        await callback_query.message.edit_text(text=f"❗ Ошибка: {e}", reply_markup=kb)
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "stats_export_payments_csv"),
-    IsAdminFilter(),
-)
-async def handle_export_payments_csv(callback_query: CallbackQuery, session: Any):
+@router.callback_query(AdminPanelCallback.filter(F.action == "stats_export_payments_csv"), IsAdminFilter())
+async def handle_export_payments_csv(callback_query: CallbackQuery, session: AsyncSession):
     kb = build_admin_back_kb("stats")
     try:
         export = await export_payments_csv(session)
-        await callback_query.message.answer_document(document=export, caption="📥 Экспорт платежей в CSV")
+        await callback_query.message.answer_document(document=export, caption="📅 Экспорт платежей в CSV")
     except Exception as e:
-        logger.error(f"Ошибка при экспорте платежей в CSV: {e}")
-        await callback_query.message.edit_text(text=f"❗ Произошла ошибка при экспорте: {e}", reply_markup=kb)
+        logger.error(f"Ошибка при экспорте платежей: {e}")
+        await callback_query.message.edit_text(text=f"❗ Ошибка: {e}", reply_markup=kb)
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "stats_export_hot_leads_csv"),
-    IsAdminFilter(),
-)
-async def handle_export_hot_leads_csv(callback_query: CallbackQuery, session: Any):
+@router.callback_query(AdminPanelCallback.filter(F.action == "stats_export_hot_leads_csv"), IsAdminFilter())
+async def handle_export_hot_leads_csv(callback_query: CallbackQuery, session: AsyncSession):
     kb = build_admin_back_kb("stats")
     try:
         export = await export_hot_leads_csv(session)
-        await callback_query.message.answer_document(document=export, caption="📥 Экспорт горящих лидов")
+        await callback_query.message.answer_document(document=export, caption="📅 Экспорт горящих лидов")
     except Exception as e:
-        logger.error(f"Ошибка при экспорте 'горящих лидов': {e}")
-        await callback_query.message.edit_text(text=f"❗ Произошла ошибка при экспорте: {e}", reply_markup=kb)
+        logger.error(f"Ошибка при экспорте горящих лидов: {e}")
+        await callback_query.message.edit_text(text=f"❗ Ошибка: {e}", reply_markup=kb)
 
 
-@router.callback_query(
-    AdminPanelCallback.filter(F.action == "stats_export_keys_csv"),
-    IsAdminFilter(),
-)
-async def handle_export_keys_csv(callback_query: CallbackQuery, session: Any):
+@router.callback_query(AdminPanelCallback.filter(F.action == "stats_export_keys_csv"), IsAdminFilter())
+async def handle_export_keys_csv(callback_query: CallbackQuery, session: AsyncSession):
     kb = build_admin_back_kb("stats")
     try:
         export = await export_keys_csv(session)
-        await callback_query.message.answer_document(document=export, caption="📥 Экспорт подписок в CSV")
+        await callback_query.message.answer_document(document=export, caption="📅 Экспорт подписок в CSV")
     except Exception as e:
-        logger.error(f"Ошибка при экспорте подписок в CSV: {e}")
-        await callback_query.message.edit_text(text=f"❗ Произошла ошибка при экспорте: {e}", reply_markup=kb)
+        logger.error(f"Ошибка при экспорте подписок: {e}")
+        await callback_query.message.edit_text(text=f"❗ Ошибка: {e}", reply_markup=kb)
+
+
+async def send_daily_stats_report(session: AsyncSession):
+    try:
+        moscow_tz = pytz.timezone("Europe/Moscow")
+        now_moscow = datetime.now(moscow_tz)
+        update_time = now_moscow.strftime("%d.%m.%y %H:%M")
+
+        report_date = now_moscow.date() - timedelta(days=1)
+
+        start = moscow_tz.localize(datetime.combine(report_date, datetime.min.time()))
+        end = moscow_tz.localize(datetime.combine(report_date + timedelta(days=1), datetime.min.time()))
+
+        start_utc = start.astimezone(pytz.UTC).replace(tzinfo=None)
+        end_utc = end.astimezone(pytz.UTC).replace(tzinfo=None)
+
+        registrations_today = await count_users_registered_between(session, start_utc, end_utc)
+        payments_today = await sum_payments_between(session, start.replace(tzinfo=None), end.replace(tzinfo=None))
+        active_keys = await count_active_keys(session)
+
+        text = (
+            f"🗓️ <b>Сводка за {report_date.strftime('%d.%m.%Y')} с 00:00 до 23:59 МСК</b>\n\n"
+            f"👤 Новых пользователей: <b>{registrations_today}</b>\n"
+            f"💰 Оплачено: <b>{payments_today} ₽</b>\n"
+            f"🔐 Активных ключей: <b>{active_keys}</b>\n\n"
+            f"⏱️ <i>Отчёт сгенерирован: {update_time} МСК</i>"
+        )
+
+        for admin_id in ADMIN_ID:
+            await bot.send_message(admin_id, text)
+
+    except Exception as e:
+        logger.error(f"[Stats] Ошибка при отправке статистики: {e}")
+
+
+@router.message(F.text == "Сводка", IsAdminFilter())
+async def test_stats_command(message: Message, session: AsyncSession):
+    await send_daily_stats_report(session)

handlers/admin/tariffs/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ("router",)
+
+from .tariffs_handler import router

handlers/admin/tariffs/keyboard.py

@@ -0,0 +1,278 @@
+from collections import defaultdict
+
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from database.tariffs import create_subgroup_hash
+
+from ..panel.keyboard import AdminPanelCallback
+
+
+class AdminTariffCallback(CallbackData, prefix="tariff"):
+    action: str
+
+
+def build_tariff_menu_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(
+            text="🆕 Новый тариф",
+            callback_data=AdminTariffCallback(action="create").pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="📋 Мои тарифы",
+            callback_data=AdminTariffCallback(action="list").pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="🔢 Расположение тарифов",
+            callback_data=AdminTariffCallback(action="arrange").pack(),
+        )
+    )
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data=AdminPanelCallback(action="admin").pack()))
+    return builder.as_markup()
+
+
+def build_cancel_kb() -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[[InlineKeyboardButton(text="❌ Отменить", callback_data="cancel_tariff_creation")]]
+    )
+
+
+def build_tariff_arrangement_groups_kb(groups: list[str]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    row = []
+
+    for i, group in enumerate(groups):
+        row.append(
+            InlineKeyboardButton(
+                text=group,
+                callback_data=AdminTariffCallback(action=f"arrange_group|{group}").pack(),
+            )
+        )
+        if len(row) == 2 or i == len(groups) - 1:
+            builder.row(*row)
+            row = []
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад",
+            callback_data=AdminTariffCallback(action="list").pack(),
+        )
+    )
+    return builder.as_markup()
+
+
+def build_tariffs_arrangement_kb(group_code: str, tariffs: list) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    grouped_tariffs = defaultdict(list)
+    for t in tariffs:
+        grouped_tariffs[t.get("subgroup_title")].append(t)
+
+    for subgroup in grouped_tariffs:
+        grouped_tariffs[subgroup].sort(key=lambda x: x.get("sort_order"))
+
+    if grouped_tariffs.get(None):
+        for t in grouped_tariffs[None]:
+            builder.row(
+                InlineKeyboardButton(
+                    text="⬆️",
+                    callback_data=AdminTariffCallback(action=f"quick_move_up|{t.get('id')}|{group_code}").pack(),
+                ),
+                InlineKeyboardButton(
+                    text=f"  {t.get('name')}  ", callback_data=AdminTariffCallback(action=f"view|{t.get('id')}").pack()
+                ),
+                InlineKeyboardButton(
+                    text="⬇️",
+                    callback_data=AdminTariffCallback(action=f"quick_move_down|{t.get('id')}|{group_code}").pack(),
+                ),
+            )
+
+    for subgroup, tariffs_list in grouped_tariffs.items():
+        if subgroup:
+            builder.row(
+                InlineKeyboardButton(text=f"📁 {subgroup}", callback_data=AdminTariffCallback(action="arrange").pack())
+            )
+            for t in tariffs_list:
+                builder.row(
+                    InlineKeyboardButton(
+                        text="⬆️",
+                        callback_data=AdminTariffCallback(action=f"quick_move_up|{t.get('id')}|{group_code}").pack(),
+                    ),
+                    InlineKeyboardButton(
+                        text=f"  {t.get('name')}  ",
+                        callback_data=AdminTariffCallback(action=f"view|{t.get('id')}").pack(),
+                    ),
+                    InlineKeyboardButton(
+                        text="⬇️",
+                        callback_data=AdminTariffCallback(action=f"quick_move_down|{t.get('id')}|{group_code}").pack(),
+                    ),
+                )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад",
+            callback_data=AdminPanelCallback(action="tariffs").pack(),
+        )
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="🏠 Главное меню",
+            callback_data=AdminPanelCallback(action="admin").pack(),
+        )
+    )
+
+    return builder.as_markup()
+
+
+def build_tariff_groups_kb(groups: list[str]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    row = []
+
+    for i, group in enumerate(groups):
+        row.append(
+            InlineKeyboardButton(
+                text=group,
+                callback_data=AdminTariffCallback(action=f"group|{group}").pack(),
+            )
+        )
+        if len(row) == 2 or i == len(groups) - 1:
+            builder.row(*row)
+            row = []
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад",
+            callback_data=AdminPanelCallback(action="tariffs").pack(),
+        )
+    )
+    return builder.as_markup()
+
+
+def build_tariff_list_kb(tariffs: list[dict]) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    if tariffs:
+        group_code = tariffs[0]["group_code"]
+    else:
+        group_code = "unknown"
+
+    grouped = defaultdict(list)
+    for t in tariffs:
+        subgroup = t.get("subgroup_title")
+        grouped[subgroup].append(t)
+
+    sorted_subgroups = sorted(
+        [k for k in grouped if k], key=lambda x: (sum(t.get("sort_order", 1) for t in grouped[x]), x)
+    )
+
+    for subgroup_title in sorted_subgroups:
+        subgroup_hash = create_subgroup_hash(subgroup_title, group_code)
+        builder.row(
+            InlineKeyboardButton(text=f"{subgroup_title}", callback_data=f"view_subgroup|{subgroup_hash}|{group_code}")
+        )
+
+    for t in grouped.get(None, []):
+        title = f"{t['name']} — {t['price_rub']}₽"
+        builder.row(
+            InlineKeyboardButton(
+                text=title,
+                callback_data=AdminTariffCallback(action=f"view|{t['id']}").pack(),
+            )
+        )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="➕ Добавить тариф",
+            callback_data=AdminTariffCallback(action=f"create|{group_code}").pack(),
+        )
+    )
+
+    builder.row(InlineKeyboardButton(text="Сгруппировать в подгруппу", callback_data=f"start_subgrouping|{group_code}"))
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад",
+            callback_data=AdminTariffCallback(action="list").pack(),
+        )
+    )
+
+    return builder.as_markup()
+
+
+def build_single_tariff_kb(tariff_id: int, group_code: str = None) -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="✏️ Редактировать",
+                    callback_data=AdminTariffCallback(action=f"edit|{tariff_id}").pack(),
+                ),
+                InlineKeyboardButton(
+                    text="🗑 Удалить",
+                    callback_data=AdminTariffCallback(action=f"delete|{tariff_id}").pack(),
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    text="⬆️ Выше",
+                    callback_data=AdminTariffCallback(action=f"move_up|{tariff_id}").pack(),
+                ),
+                InlineKeyboardButton(
+                    text="⬇️ Ниже",
+                    callback_data=AdminTariffCallback(action=f"move_down|{tariff_id}").pack(),
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    text="⬅️ Назад",
+                    callback_data=AdminTariffCallback(action=f"group|{group_code}").pack()
+                    if group_code
+                    else AdminTariffCallback(action="list").pack(),
+                )
+            ],
+        ]
+    )
+
+
+def build_edit_tariff_fields_kb(tariff_id: int) -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(
+        inline_keyboard=[
+            [InlineKeyboardButton(text="📝 Название", callback_data=f"edit_field|{tariff_id}|name")],
+            [
+                InlineKeyboardButton(
+                    text="📅 Длительность",
+                    callback_data=f"edit_field|{tariff_id}|duration_days",
+                )
+            ],
+            [InlineKeyboardButton(text="💰 Цена", callback_data=f"edit_field|{tariff_id}|price_rub")],
+            [
+                InlineKeyboardButton(
+                    text="📦 Трафик (ГБ или 0)",
+                    callback_data=f"edit_field|{tariff_id}|traffic_limit",
+                )
+            ],
+            [
+                InlineKeyboardButton(
+                    text="📱 Лимит устройств",
+                    callback_data=f"edit_field|{tariff_id}|device_limit",
+                )
+            ],
+            [
+                InlineKeyboardButton(
+                    text="🔗 VLESS",
+                    callback_data=f"edit_field|{tariff_id}|vless",
+                )
+            ],
+            [InlineKeyboardButton(text="🔘 Активность", callback_data=f"toggle_active|{tariff_id}")],
+            [
+                InlineKeyboardButton(
+                    text="⬅️ Назад", callback_data=AdminTariffCallback(action=f"view|{tariff_id}").pack()
+                )
+            ],
+        ]
+    )

handlers/admin/users/keyboard.py

@@ -3,10 +3,16 @@ from datetime import datetime, timezone
 from aiogram.filters.callback_data import CallbackData
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 
-from config import RENEWAL_PRICES, TOTAL_GB
+from config import HWID_RESET_BUTTON
 from database import get_clusters
+from database.models import Key, Tariff
 from handlers.buttons import BACK
+from handlers.utils import format_days
+from hooks.hook_buttons import insert_hook_buttons
+from hooks.hooks import run_hooks
 
 from ..panel.keyboard import build_admin_back_btn
 
@@ -26,119 +32,193 @@ class AdminUserKeyEditorCallback(CallbackData, prefix="admin_users_key"):
     edit: bool = False
 
 
-def build_user_edit_kb(tg_id: int, key_records: list) -> InlineKeyboardMarkup:
+async def build_user_edit_kb(tg_id: int, key_records: list, is_banned: bool = False) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
     current_time = datetime.now(tz=timezone.utc)
 
-    builder.button(
-        text="➕ Создать ключ",
-        callback_data=AdminUserEditorCallback(action="users_create_key", tg_id=tg_id).pack(),
+    builder.row(
+        InlineKeyboardButton(
+            text="➕ Создать подписку",
+            callback_data=AdminUserEditorCallback(action="users_create_key", tg_id=tg_id).pack(),
+        )
     )
 
     for record in key_records:
-        email = record["email"]
-        expiry = datetime.fromtimestamp(record["expiry_time"] / 1000, tz=timezone.utc)
+        email = record.email
+        expiry = datetime.fromtimestamp(record.expiry_time / 1000, tz=timezone.utc)
         days = (expiry - current_time).days
-        builder.button(
-            text=f"🔑 {email} ({'<1' if days < 1 else days} дн.)",
-            callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=str(email)).pack(),
+        builder.row(
+            InlineKeyboardButton(
+                text=f"🔑 {email} ({'<1' if days < 1 else days} дн.)",
+                callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=str(email)).pack(),
+            )
         )
 
-    builder.button(
-        text="✉️ Сообщение", callback_data=AdminUserEditorCallback(action="users_send_message", tg_id=tg_id).pack()
+    builder.row(
+        InlineKeyboardButton(
+            text="✉️ Сообщение",
+            callback_data=AdminUserEditorCallback(action="users_send_message", tg_id=tg_id).pack(),
+        ),
+        InlineKeyboardButton(
+            text="💸 Баланс",
+            callback_data=AdminUserEditorCallback(action="users_balance_edit", tg_id=tg_id).pack(),
+        ),
     )
-    builder.button(
-        text="💸 Изменить баланс",
-        callback_data=AdminUserEditorCallback(action="users_balance_edit", tg_id=tg_id).pack(),
+
+    builder.row(
+        InlineKeyboardButton(
+            text="🤝 Выгрузить рефералов",
+            callback_data=AdminUserEditorCallback(action="users_export_referrals", tg_id=tg_id).pack(),
+        )
     )
-    builder.button(
-        text="🤝 Выгрузить рефералов",
-        callback_data=AdminUserEditorCallback(action="users_export_referrals", tg_id=tg_id).pack(),
+
+    builder.row(
+        InlineKeyboardButton(
+            text="♻️ Восстановить триал",
+            callback_data=AdminUserEditorCallback(action="users_trial_restore", tg_id=tg_id).pack(),
+        )
     )
-    builder.button(
-        text="♻️ Восстановить триал",
-        callback_data=AdminUserEditorCallback(action="users_trial_restore", tg_id=tg_id).pack(),
-    )
-    builder.button(
-        text="❌ Удалить клиента", callback_data=AdminUserEditorCallback(action="users_delete_user", tg_id=tg_id).pack()
+
+    builder.row(
+        InlineKeyboardButton(
+            text="❌ Удалить",
+            callback_data=AdminUserEditorCallback(action="users_delete_user", tg_id=tg_id).pack(),
+        ),
+        InlineKeyboardButton(
+            text="✅ Разблокировать" if is_banned else "🚫 Заблокировать",
+            callback_data=AdminUserEditorCallback(
+                action="users_unban" if is_banned else "users_ban", tg_id=tg_id
+            ).pack(),
+        ),
     )
+
+    hook_buttons = await run_hooks("admin_user_edit", tg_id=tg_id, is_banned=is_banned)
+    builder = insert_hook_buttons(builder, hook_buttons)
+
     builder.row(build_editor_btn("🔄 Обновить данные", tg_id, edit=True))
     builder.row(build_admin_back_btn())
-    builder.adjust(1)
+
     return builder.as_markup()
 
 
 def build_users_balance_change_kb(tg_id: int) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
     builder.button(
-        text=BACK,  # todo: fix magic text was set
+        text=BACK,
         callback_data=AdminUserEditorCallback(action="users_balance_edit", tg_id=tg_id).pack(),
     )
     return builder.as_markup()
 
 
-def build_users_balance_kb(tg_id: int) -> InlineKeyboardMarkup:
+async def build_users_balance_kb(session: AsyncSession, tg_id: int) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
-    for month, amount in RENEWAL_PRICES.items():
-        builder.button(
-            text=f"+ {amount}Р ({month} мес.)",
-            callback_data=AdminUserEditorCallback(action="users_balance_add", tg_id=tg_id, data=amount).pack(),
+
+    for amount in [100, 250, 500, 1000]:
+        builder.row(
+            InlineKeyboardButton(
+                text=f"+ {amount}₽",
+                callback_data=AdminUserEditorCallback(action="users_balance_add", tg_id=tg_id, data=amount).pack(),
+            ),
+            InlineKeyboardButton(
+                text=f"- {amount}₽",
+                callback_data=AdminUserEditorCallback(action="users_balance_add", tg_id=tg_id, data=-amount).pack(),
+            ),
         )
-        builder.button(
-            text=f"- {amount}Р ({month} мес.)",
-            callback_data=AdminUserEditorCallback(action="users_balance_add", tg_id=tg_id, data=-amount).pack(),
+
+    builder.row(
+        InlineKeyboardButton(
+            text="💵 Добавить",
+            callback_data=AdminUserEditorCallback(action="users_balance_add", tg_id=tg_id).pack(),
+        ),
+        InlineKeyboardButton(
+            text="💵 Вычесть",
+            callback_data=AdminUserEditorCallback(action="users_balance_take", tg_id=tg_id).pack(),
+        ),
+    )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="💵 Установить баланс",
+            callback_data=AdminUserEditorCallback(action="users_balance_set", tg_id=tg_id).pack(),
         )
-    builder.button(
-        text="💵 Добавить", callback_data=AdminUserEditorCallback(action="users_balance_add", tg_id=tg_id).pack()
-    )
-    builder.button(
-        text="💵 Вычесть", callback_data=AdminUserEditorCallback(action="users_balance_take", tg_id=tg_id).pack()
-    )
-    builder.button(
-        text="💵 Установить баланс",
-        callback_data=AdminUserEditorCallback(action="users_balance_set", tg_id=tg_id).pack(),
     )
+
     builder.row(build_editor_back_btn(tg_id, True))
-    builder.adjust(2, 2, 2, 2, 2, 1)
+
     return builder.as_markup()
 
 
 def build_users_key_show_kb(tg_id: int, email: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
     builder.button(
-        text=BACK,  # todo: fix magic text was set
+        text=BACK,
         callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=email, edit=True).pack(),
     )
     return builder.as_markup()
 
 
-def build_users_key_expiry_kb(tg_id: int, email: str) -> InlineKeyboardMarkup:
+async def build_users_key_expiry_kb(session: AsyncSession, tg_id: int, email: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
-    for month in RENEWAL_PRICES.keys():
-        month = int(month)
-        builder.button(
-            text=f"+ {month} мес.",
-            callback_data=AdminUserKeyEditorCallback(action="add", tg_id=tg_id, data=email, month=month).pack(),
+
+    result = await session.execute(select(Key.server_id, Key.tariff_id).where(Key.email == email))
+    row = result.first()
+    _server_id, tariff_id = row if row else (None, None)
+
+    if tariff_id:
+        result = await session.execute(select(Tariff.group_code).where(Tariff.id == tariff_id))
+        row = result.first()
+        if row and row[0]:
+            group_code = row[0]
+            result = await session.execute(
+                select(Tariff).where(Tariff.group_code == group_code, Tariff.is_active.is_(True))
+            )
+            tariffs = result.scalars().all()
+            unique_durations = set()
+            for tariff in tariffs:
+                days = tariff.duration_days
+                if days < 1 or days in unique_durations:
+                    continue
+                unique_durations.add(days)
+                label = format_days(days)
+                builder.row(
+                    InlineKeyboardButton(
+                        text=f"+ {label}",
+                        callback_data=AdminUserKeyEditorCallback(
+                            action="add", tg_id=tg_id, data=email, month=days
+                        ).pack(),
+                    ),
+                    InlineKeyboardButton(
+                        text=f"- {label}",
+                        callback_data=AdminUserKeyEditorCallback(
+                            action="add", tg_id=tg_id, data=email, month=-days
+                        ).pack(),
+                    ),
+                )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⏳ Добавить дни",
+            callback_data=AdminUserKeyEditorCallback(action="add", tg_id=tg_id, data=email).pack(),
+        ),
+        InlineKeyboardButton(
+            text="⏳ Вычесть дни",
+            callback_data=AdminUserKeyEditorCallback(action="take", tg_id=tg_id, data=email).pack(),
+        ),
+    )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⏳ Установить дату истечения",
+            callback_data=AdminUserKeyEditorCallback(action="set", tg_id=tg_id, data=email).pack(),
         )
-        builder.button(
-            text=f"- {month} мес.",
-            callback_data=AdminUserKeyEditorCallback(action="add", tg_id=tg_id, data=email, month=-month).pack(),
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text=BACK,
+            callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=email).pack(),
         )
-    builder.button(
-        text="⏳ Добавить дни", callback_data=AdminUserKeyEditorCallback(action="add", tg_id=tg_id, data=email).pack()
     )
-    builder.button(
-        text="⏳ Вычесть дни", callback_data=AdminUserKeyEditorCallback(action="take", tg_id=tg_id, data=email).pack()
-    )
-    builder.button(
-        text="⏳ Установить дату истечения",
-        callback_data=AdminUserKeyEditorCallback(action="set", tg_id=tg_id, data=email).pack(),
-    )
-    builder.button(
-        text=BACK,  # todo: fix magic text was set
-        callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=email).pack(),
-    )
-    builder.adjust(2, 2, 2, 2, 2, 1)
+
     return builder.as_markup()
 
 
@@ -156,7 +236,8 @@ def build_user_delete_kb(tg_id: int):
 def build_user_key_kb(tg_id: int, email: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
     builder.button(
-        text=BACK, callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=email).pack()
+        text=BACK,
+        callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=email).pack(),
     )
     builder.adjust(1)
     return builder.as_markup()
@@ -164,6 +245,7 @@ def build_user_key_kb(tg_id: int, email: str) -> InlineKeyboardMarkup:
 
 def build_key_edit_kb(key_details: dict, email: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
+
     builder.button(
         text="⏳ Время истечения",
         callback_data=AdminUserEditorCallback(
@@ -174,6 +256,10 @@ def build_key_edit_kb(key_details: dict, email: str) -> InlineKeyboardMarkup:
         text="🔄 Перевыпустить",
         callback_data=AdminUserEditorCallback(action="users_update_key", data=email, tg_id=key_details["tg_id"]).pack(),
     )
+    builder.button(
+        text="📦 Тариф",
+        callback_data=AdminUserEditorCallback(action="users_renew", data=email, tg_id=key_details["tg_id"]).pack(),
+    )
     builder.button(
         text="❌ Удалить",
         callback_data=AdminUserEditorCallback(action="users_delete_key", data=email, tg_id=key_details["tg_id"]).pack(),
@@ -182,18 +268,39 @@ def build_key_edit_kb(key_details: dict, email: str) -> InlineKeyboardMarkup:
         text="📊 Трафик",
         callback_data=AdminUserEditorCallback(action="users_traffic", data=email, tg_id=key_details["tg_id"]).pack(),
     )
-    if TOTAL_GB > 0:
+    builder.button(
+        text="♻️ Сбросить трафик",
+        callback_data=AdminUserEditorCallback(
+            action="users_reset_traffic", data=email, tg_id=key_details["tg_id"]
+        ).pack(),
+    )
+    if HWID_RESET_BUTTON:
         builder.button(
-            text="♻️ Сбросить трафик",
+            text="💻 HWID",
             callback_data=AdminUserEditorCallback(
-                action="users_reset_traffic", data=email, tg_id=key_details["tg_id"]
+                action="users_hwid_menu", data=email, tg_id=key_details["tg_id"]
             ).pack(),
         )
+
     builder.row(build_editor_back_btn(key_details["tg_id"], True))
     builder.adjust(1)
     return builder.as_markup()
 
 
+def build_hwid_menu_kb(email: str, tg_id: int) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(
+        text="♻️ Сбросить HWID",
+        callback_data=AdminUserEditorCallback(action="users_hwid_reset", data=email, tg_id=tg_id).pack(),
+    )
+    builder.button(
+        text="🔙 Назад",
+        callback_data=AdminUserEditorCallback(action="users_key_edit", data=email, tg_id=tg_id).pack(),
+    )
+    builder.adjust(1)
+    return builder.as_markup()
+
+
 def build_key_delete_kb(tg_id: int, email: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
     builder.row(
@@ -223,7 +330,8 @@ def build_editor_back_btn(tg_id: int, edit: bool = False) -> InlineKeyboardButto
 
 def build_editor_btn(text: str, tg_id: int, edit: bool = False) -> InlineKeyboardButton:
     return InlineKeyboardButton(
-        text=text, callback_data=AdminUserEditorCallback(action="users_editor", tg_id=tg_id, edit=edit).pack()
+        text=text,
+        callback_data=AdminUserEditorCallback(action="users_editor", tg_id=tg_id, edit=edit).pack(),
     )
 
 
@@ -234,6 +342,39 @@ async def build_cluster_selection_kb(session, tg_id: int, email: str, action: st
     for cluster_id in clusters:
         builder.button(text=cluster_id, callback_data=f"{action}|{tg_id}|{email}|{cluster_id}")
 
-    builder.button(text=BACK, callback_data=f"edit_user_key|{tg_id}|{email}")
+    builder.button(
+        text=BACK, callback_data=AdminUserEditorCallback(action="users_key_edit", tg_id=tg_id, data=email).pack()
+    )
     builder.adjust(1)
     return builder.as_markup()
+
+
+def build_user_ban_type_kb(tg_id: int) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⛔ Навсегда",
+            callback_data=AdminUserEditorCallback(action="users_ban_forever", tg_id=tg_id).pack(),
+        ),
+        InlineKeyboardButton(
+            text="⏳ По сроку",
+            callback_data=AdminUserEditorCallback(action="users_ban_temporary", tg_id=tg_id).pack(),
+        ),
+    )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="👻 Теневой бан",
+            callback_data=AdminUserEditorCallback(action="users_ban_shadow", tg_id=tg_id).pack(),
+        )
+    )
+
+    builder.row(
+        InlineKeyboardButton(
+            text="⬅️ Назад",
+            callback_data=AdminUserEditorCallback(action="users_editor", tg_id=tg_id, edit=True).pack(),
+        )
+    )
+
+    return builder.as_markup()

handlers/buttons.py

@@ -10,16 +10,16 @@ CANCEL = "❌ Отмена"
 
 # Профиль
 
-ADD_SUB = "➕ Подписка"
+ADD_SUB = "Купить новую подписку"
 MY_SUBS = "📱 Мои подписки"
-BALANCE = "💰 Баланс"
+BALANCE = "💵 Баланс"
 INVITE = "👥 Пригласить"
 GIFTS = "🎁 Подарить"
-TARRIFS = "💡 Тарифы"
 INSTRUCTIONS = "📘 Инструкции"
-INVITE = "👥 Пригласить друга"
 TOP_FIVE = "🏆 Топ-5"
 TRIAL_SUB = "🎁 Пробная подписка"
+MY_SUB = "🔐 Моя подписка"
+RENEW_SUB = "🔄 Обновить подписку"
 
 # Меню Оплат и баланса
 
@@ -29,10 +29,18 @@ COUPON = "🎟️ Активировать купон"
 COUPON_RESTART = "🎟️ Попробовать другой купон"
 YOOKASSA = "💳 ЮКасса: быстрая оплата"
 YOOMONEY = "💳 ЮМани: перевод по карте"
+FREEKASSA = "💰 FreeKassa: межд. платежи"
 CRYPTOBOT = "💰 CryptoBot: криптовалюта"
 STARS = "⭐ Оплата Звездами"
 ROBOKASSA = "⭐ RoboKassa"
+DISCOUNT_TARIFF = "🔥 Получить скидку"
+MAX_DISCOUNT_TARIFF = "⚡ Получить максимальную скидку"
+DONAT_BUTTON = "💰 Поддержать проект"
 
+# Кнопки подписки на канал
+
+SUB_CHANELL = "📢 Подписаться"
+SUB_CHANELL_DONE = "✅ Я подписался"
 
 # Подарки
 
@@ -40,8 +48,7 @@ GIFT = "🎁 Подарить подписку"
 MY_GIFTS = "🎁 Мои подарки"
 GIFTS_MENU = "В меню подарков"
 SHARE_GIFT = "🎁 Поделиться подарком"
-APPLY = "✅ Подтвердить"
-CANCEL = "❌ Отмена"
+GET_GIFT = "🎁 Получить подарок"
 
 # Создание и подключение ключей
 
@@ -52,7 +59,7 @@ DOWNLOAD_PC_BUTTON = "💻 Скачать Windows"
 IMPORT_IOS = "🍏 Подключить"
 IMPORT_ANDROID = "🤖 Подключить"
 PC_BUTTON = "💻 Компьютеры"
-TV_BUTTON = "📺 Андроид TV"
+TV_BUTTON = "📺 Подключить Андроид TV"
 CONNECT_PHONE = "📱 Подключить телефон"
 CONNECT_DEVICE = "📲 Подключить устройство"
 CONNECT_WINDOWS_BUTTON = "💻 Подключить"
@@ -60,8 +67,6 @@ CONNECT_MACOS_BUTTON = "🍏 Подключить"
 ALIAS = "✏️"
 UNFREEZE = "🟢 Разморозить подписку"
 FREEZE = "🛑 Заморозить подписку"
-RENEW = "⏳ Продлить"
-RENEW_FULL = "⏳ Продлить подписку"
 DELETE = "❌ Удалить"
 CHANGE_LOCATION = "🌍 Сменить локацию"
 QR = "📷 Показать QR-код"
@@ -73,9 +78,13 @@ PC_MACOS = "🍏 macOS"
 TV = "📺 Телевизор"
 ROUTER = "📶 Роутер"
 MANUAL_INSTRUCTIONS = "📖 Ручная установка"
-RENEW_KEY = "🔄 Продлить подписку"
+RENEW_KEY = "⏳ Продлить подписку"
+RENEW_KEY_NOTIFICATION = "🔄 Продлить подписку"
+CHANGE_TARIFF = "🔄 Сменить тариф"
 TV_CONTINUE = "▶ Продолжить"
 TV_INSTRUCTIONS = "📖 Полная инструкция"
+HWID_BUTTON = "♻️ Сбросить привязку"
+ROUTER_BUTTON = "Подключить роутер"
 
 
 # Кнопки касс
@@ -83,6 +92,17 @@ TV_INSTRUCTIONS = "📖 Полная инструкция"
 PAY = "Пополнить"
 PAY_2 = "Оплатить"
 CUSTOM_AMOUNT = "💰 Ввести свою сумму"
-PAY = "Пополнить"
-PAY_2 = "Оплатить"
 STARS_BOT = "🤖 Бот для покупки звезд"
+WATA = "💳 WATA"
+WATA_RU = "🇷🇺 WATA: Карты РФ"
+WATA_SBP = "🏦 WATA: СБП"
+WATA_INT = "🌍 WATA: Международные карты"
+KASSAI_CARDS = "💳 KassaAI: Карты РФ"
+KASSAI_SBP = "🏦 KassaAI: СБП"
+KASSAI = "💳 KassaAI"
+TRIBUTE = "💳 Tribute"
+RUB_CURRENCY = "₽ Рубли (RUB)"
+USD_CURRENCY = "$ USD / Cryptowallet"
+
+# Кнопки Heleket
+HELEKET = "Heleket Crypto"

handlers/captcha.py

@@ -8,8 +8,7 @@ from aiogram.fsm.context import FSMContext
 from aiogram.types import CallbackQuery, Message
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
-from config import CAPTCHA_EMOJIS
-from handlers.texts import CAPTCHA_PROMPT_MSG
+from handlers.texts import CAPTCHA_EMOJIS, CAPTCHA_PROMPT_MSG
 from logger import logger
 
 from .utils import edit_or_send_message
@@ -25,12 +24,36 @@ async def generate_captcha(message: Message, state: FSMContext):
     all_emojis = [correct_emoji] + wrong_emojis
     random.shuffle(all_emojis)
 
-    await state.update_data(
-        correct_emoji=correct_emoji,
-        message_id=message.message_id,
-        chat_id=message.chat.id,
-        original_text=message.text,
-    )
+    state_data = await state.get_data()
+
+    if "user_data" not in state_data:
+        from_user = message.from_user
+        if not from_user:
+            logger.warning("[CAPTCHA] ❗ from_user отсутствует — невозможно сохранить user_data")
+            return None
+
+        await state.update_data(
+            user_data={
+                "tg_id": from_user.id,
+                "username": getattr(from_user, "username", None),
+                "first_name": getattr(from_user, "first_name", None),
+                "last_name": getattr(from_user, "last_name", None),
+                "language_code": getattr(from_user, "language_code", None),
+                "is_bot": getattr(from_user, "is_bot", False),
+            }
+        )
+
+    update_data = {
+        "correct_emoji": correct_emoji,
+        "message_id": message.message_id,
+        "chat_id": message.chat.id,
+    }
+
+    state_data = await state.get_data()
+    if "original_text" not in state_data:
+        update_data["original_text"] = message.text
+
+    await state.update_data(**update_data)
 
     builder = InlineKeyboardBuilder()
     for emoji in all_emojis:
@@ -45,34 +68,33 @@ async def generate_captcha(message: Message, state: FSMContext):
 
 @router.callback_query(F.data.startswith("captcha_"))
 async def check_captcha(callback: CallbackQuery, state: FSMContext, session: Any, admin: bool):
-    from handlers.start import start_command
+    from handlers.start import process_start_logic
 
     selected_emoji = callback.data.split("captcha_")[1]
     state_data = await state.get_data()
     correct_emoji = state_data.get("correct_emoji")
-    message_id = state_data.get("message_id")
-    chat_id = state_data.get("chat_id")
+    original_text = state_data.get("original_text")
+    user_data = state_data.get("user_data")
 
-    if not message_id or not chat_id:
-        target_message = callback.message
-    else:
-        try:
-            target_message = await callback.bot.edit_message_text(
-                chat_id=chat_id,
-                message_id=message_id,
-                text=callback.message.text,
-            )
-        except Exception:
-            target_message = callback.message
+    target_message = callback.message
 
     if selected_emoji == correct_emoji:
-        logger.info(f"Пользователь {callback.message.chat.id} успешно прошел капчу")
-        await start_command(target_message, state, session, admin, captcha=False)
-    else:
-        logger.warning(f"Пользователь {callback.message.chat.id} неверно ответил на капчу")
-        captcha = await generate_captcha(target_message, state)
-        await edit_or_send_message(
-            target_message=target_message,
-            text=captcha["text"],
-            reply_markup=captcha["markup"],
+        logger.info(f"Пользователь {callback.from_user.id} успешно прошел капчу")
+        logger.debug(f"[CAPTCHA] user_data передано в process_start_logic: {user_data}")
+        await process_start_logic(
+            message=target_message,
+            state=state,
+            session=session,
+            admin=admin,
+            text_to_process=original_text,
+            user_data=user_data,
         )
+    else:
+        logger.warning(f"Пользователь {callback.from_user.id} неверно ответил на капчу")
+        captcha = await generate_captcha(target_message, state)
+        if captcha:
+            await edit_or_send_message(
+                target_message=target_message,
+                text=captcha["text"],
+                reply_markup=captcha["markup"],
+            )

handlers/coupons.py

@@ -1,31 +1,50 @@
+import html
+
+from datetime import datetime
 from typing import Any
 
+import pytz
+
 from aiogram import F, Router
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
 from aiogram.types import CallbackQuery, InlineKeyboardButton, Message
 from aiogram.utils.keyboard import InlineKeyboardBuilder
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 
+from config import ADMIN_ID
 from database import (
+    add_payment,
+    add_user,
     check_coupon_usage,
+    check_user_exists,
     create_coupon_usage,
     get_coupon_by_code,
+    get_keys,
+    get_tariff_by_id,
     update_balance,
     update_coupon_usage_count,
+    update_key_expiry,
 )
-from handlers.buttons import MAIN_MENU, COUPON_RESTART
+from handlers.buttons import MAIN_MENU
+from handlers.keys.operations import renew_key_in_cluster
+from handlers.payments.currency_rates import format_for_user
+from handlers.profile import process_callback_view_profile
 from handlers.texts import (
-    COUPON_ACTIVATED_SUCCESS_MSG,
+    COUPONS_DAYS_MESSAGE,
     COUPON_ALREADY_USED_MSG,
+    COUPON_DAYS_ACTIVATED_MSG,
     COUPON_INPUT_PROMPT,
     COUPON_NOT_FOUND_MSG,
 )
-
-from .utils import edit_or_send_message
+from handlers.utils import edit_or_send_message, format_days
+from logger import logger
 
 
 class CouponActivationState(StatesGroup):
     waiting_for_coupon_code = State()
+    waiting_for_key_selection = State()
 
 
 router = Router()
@@ -51,35 +70,214 @@ async def handle_activate_coupon(callback_query_or_message: Message | CallbackQu
     await state.set_state(CouponActivationState.waiting_for_coupon_code)
 
 
-@router.message(CouponActivationState.waiting_for_coupon_code)
+@router.message(CouponActivationState.waiting_for_coupon_code, F.text)
 async def process_coupon_code(message: Message, state: FSMContext, session: Any):
     coupon_code = message.text.strip()
-    activation_result = await activate_coupon(message.chat.id, coupon_code, session)
+    await activate_coupon(message, state, session, coupon_code=coupon_code)
 
-    builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-    builder.row(InlineKeyboardButton(text=COUPON_RESTART, callback_data="activate_coupon"))
 
-    await message.answer(activation_result, reply_markup=builder.as_markup())
+async def activate_coupon(
+    message: Message,
+    state: FSMContext,
+    session: AsyncSession,
+    coupon_code: str,
+    admin: bool = False,
+    user_data: dict | None = None,
+):
+    logger.info(f"Активация купона: {coupon_code}")
+    coupon = await get_coupon_by_code(session, coupon_code)
 
+    if not coupon:
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="exit_coupon_input"))
+        await message.answer(COUPON_NOT_FOUND_MSG, reply_markup=builder.as_markup())
+        return
+
+    if coupon.usage_count >= coupon.usage_limit or coupon.is_used:
+        await message.answer("❌ Лимит активаций купона исчерпан.")
+        await state.clear()
+        return
+
+    user = user_data or message.from_user or message.chat
+    language_code = user.get("language_code") if isinstance(user, dict) else getattr(user, "language_code", None)
+    user_id = user["tg_id"] if isinstance(user, dict) else user.id
+
+    usage = await check_coupon_usage(session, coupon.id, user_id)
+    if usage:
+        await message.answer(COUPON_ALREADY_USED_MSG)
+        await state.clear()
+        return
+
+    user_exists = await check_user_exists(session, user_id)
+    if not user_exists:
+        if isinstance(user, dict):
+            await add_user(session=session, **user)
+        else:
+            await add_user(
+                session=session,
+                tg_id=user.id,
+                username=getattr(user, "username", None),
+                first_name=getattr(user, "first_name", None),
+                last_name=getattr(user, "last_name", None),
+                language_code=getattr(user, "language_code", None),
+                is_bot=getattr(user, "is_bot", False),
+            )
+
+    if coupon.amount > 0:
+        try:
+            await update_balance(session, user_id, coupon.amount)
+            await update_coupon_usage_count(session, coupon.id)
+            await create_coupon_usage(session, coupon.id, user_id)
+            await add_payment(session, tg_id=user_id, amount=coupon.amount, payment_system="coupon")
+            amount_txt = await format_for_user(session, user_id, coupon.amount, language_code)
+            await message.answer(f"✅ Купон активирован, на баланс начислено {amount_txt}.")
+            await state.clear()
+        except Exception as e:
+            logger.error(f"Ошибка при активации купона на баланс: {e}")
+            await message.answer("❌ Ошибка при активации купона.")
+            await state.clear()
+        return
+
+    if coupon.days:
+        try:
+            keys = await get_keys(session, user_id)
+            active_keys = [k for k in keys if not k.is_frozen]
+
+            if not active_keys:
+                await message.answer("❌ У вас нет активных подписок для продления.")
+                await state.clear()
+                return
+
+            builder = InlineKeyboardBuilder()
+            moscow_tz = pytz.timezone("Europe/Moscow")
+            response_message = COUPONS_DAYS_MESSAGE
+
+            for key in active_keys:
+                key_display = html.escape((key.alias or key.email).strip())
+                expiry_date = datetime.fromtimestamp(key.expiry_time / 1000, tz=moscow_tz).strftime(
+                    "до %d.%m.%y, %H:%M"
+                )
+                response_message += f"• <b>{key_display}</b> ({expiry_date})\n"
+                builder.button(
+                    text=key_display,
+                    callback_data=f"extend_key|{key.client_id}|{coupon.id}",
+                )
+
+            response_message += "</blockquote>"
+            builder.button(text="Отмена", callback_data="cancel_coupon_activation")
+            builder.adjust(1)
+
+            await message.answer(response_message, reply_markup=builder.as_markup())
+            await state.set_state(CouponActivationState.waiting_for_key_selection)
+            await state.update_data(coupon_id=coupon.id, user_id=user_id)
+        except Exception as e:
+            logger.error(f"Ошибка при обработке купона на дни: {e}")
+            await message.answer("❌ Ошибка при активации купона.")
+            await state.clear()
+        return
+
+    await message.answer("❌ Купон недействителен (нет суммы или дней).")
     await state.clear()
 
 
-async def activate_coupon(user_id: int, coupon_code: str, session: Any):
-    coupon_record = await get_coupon_by_code(coupon_code, session)
+@router.callback_query(F.data.startswith("extend_key|"))
+async def handle_key_extension(
+    callback_query: CallbackQuery,
+    state: FSMContext,
+    session: AsyncSession,
+    admin: bool = False,
+):
+    from database.models import Coupon, Key
 
-    if not coupon_record:
-        return COUPON_NOT_FOUND_MSG
+    parts = callback_query.data.split("|")
+    client_id = parts[1]
+    coupon_id = int(parts[2])
+    tg_id = callback_query.from_user.id
 
-    usage_exists = await check_coupon_usage(coupon_record["id"], user_id, session)
+    try:
+        result = await session.execute(select(Coupon).where(Coupon.id == coupon_id))
+        coupon = result.scalar_one_or_none()
+        if not coupon or coupon.usage_count >= coupon.usage_limit:
+            await callback_query.message.edit_text("❌ Купон недействителен или лимит исчерпан.")
+            await state.clear()
+            return
 
-    if usage_exists:
-        return COUPON_ALREADY_USED_MSG
+        usage = await check_coupon_usage(session, coupon.id, tg_id)
+        if usage:
+            await callback_query.message.edit_text("❌ Вы уже активировали этот купон.")
+            await state.clear()
+            return
 
-    coupon_amount = coupon_record["amount"]
+        result = await session.execute(select(Key).where(Key.tg_id == tg_id, Key.client_id == client_id))
+        key = result.scalar_one_or_none()
+        if not key or key.is_frozen:
+            await callback_query.message.edit_text("❌ Выбранная подписка не найдена или заморожена.")
+            await state.clear()
+            return
 
-    await update_coupon_usage_count(coupon_record["id"], session)
-    await create_coupon_usage(coupon_record["id"], user_id, session)
+        now_ms = int(datetime.now().timestamp() * 1000)
+        current_expiry = key.expiry_time
+        new_expiry = max(now_ms, current_expiry) + (coupon.days * 86400 * 1000)
 
-    await update_balance(user_id, coupon_amount, session)
-    return COUPON_ACTIVATED_SUCCESS_MSG.format(coupon_amount=coupon_amount)
+        tariff = None
+        if key.tariff_id:
+            tariff = await get_tariff_by_id(session, key.tariff_id)
+        total_gb = int(tariff["traffic_limit"]) if tariff and tariff.get("traffic_limit") else 0
+        device_limit = int(tariff["device_limit"]) if tariff and tariff.get("device_limit") else 0
+
+        key_subgroup = None
+        if tariff:
+            key_subgroup = tariff.get("subgroup_title")
+
+        await renew_key_in_cluster(
+            cluster_id=key.server_id,
+            email=key.email,
+            client_id=client_id,
+            new_expiry_time=new_expiry,
+            total_gb=total_gb,
+            session=session,
+            hwid_device_limit=device_limit,
+            reset_traffic=False,
+            target_subgroup=key_subgroup,
+            old_subgroup=key_subgroup,
+        )
+        await update_key_expiry(session, client_id, new_expiry)
+        await update_coupon_usage_count(session, coupon.id)
+        await create_coupon_usage(session, coupon.id, tg_id)
+
+        alias = key.alias or key.email
+        expiry_date = datetime.fromtimestamp(new_expiry / 1000, tz=pytz.timezone("Europe/Moscow")).strftime(
+            "%d.%m.%y, %H:%M"
+        )
+        await callback_query.message.answer(
+            COUPON_DAYS_ACTIVATED_MSG.format(alias=alias, days=format_days(coupon.days), expiry=expiry_date)
+        )
+        await process_callback_view_profile(callback_query.message, state, admin, session)
+        await state.clear()
+    except Exception as e:
+        logger.error(f"Ошибка при продлении ключа: {e}")
+        await callback_query.message.edit_text("❌ Ошибка при активации купона.")
+        await state.clear()
+
+
+@router.callback_query(F.data == "cancel_coupon_activation")
+async def cancel_coupon_activation(
+    callback_query: CallbackQuery,
+    state: FSMContext,
+    admin: bool = False,
+    session: AsyncSession = None,
+):
+    await callback_query.message.edit_text("⚠️ Активация купона отменена.")
+    await process_callback_view_profile(callback_query.message, state, admin, session)
+    await state.clear()
+
+
+@router.callback_query(F.data == "exit_coupon_input")
+async def handle_exit_coupon_input(
+    callback_query: CallbackQuery,
+    state: FSMContext,
+    session: AsyncSession = None,
+):
+    await state.clear()
+    is_admin = callback_query.from_user.id in ADMIN_ID
+    await process_callback_view_profile(callback_query.message, state, admin=is_admin, session=session)

handlers/donate.py

@@ -1,10 +1,16 @@
 from aiogram import F, Router
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
-from aiogram.types import CallbackQuery, InlineKeyboardButton, LabeledPrice, Message, PreCheckoutQuery
+from aiogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    LabeledPrice,
+    Message,
+    PreCheckoutQuery,
+)
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
-from config import RUB_TO_XTR
+from config import RUB_TO_XTR, STARS_BOT_URL
 from handlers.buttons import BACK, MAIN_MENU
 from logger import logger
 
@@ -25,7 +31,7 @@ async def process_donate(callback_query: CallbackQuery, state: FSMContext):
     await state.clear()
 
     builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text="🤖 Бот для покупки звезд", url="https://t.me/PremiumBot"))
+    builder.row(InlineKeyboardButton(text="🤖 Бот для покупки звезд", url=STARS_BOT_URL))
     builder.row(
         InlineKeyboardButton(
             text="💰 Ввести сумму доната",

handlers/fallback_router.py

@@ -0,0 +1,36 @@
+from aiogram import F, Router
+from aiogram.types import InlineKeyboardButton, Message
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from config import SUPPORT_CHAT_URL
+from database import async_session_maker
+from handlers.buttons import MAIN_MENU, SUPPORT
+from handlers.texts import FALLBACK_MESSAGE
+from hooks.hooks import run_hooks
+
+
+fallback_router = Router()
+
+
+@fallback_router.message(F.text)
+async def handle_unhandled_messages(message: Message):
+    async with async_session_maker() as session:
+        await run_hooks(
+            "user_message",
+            user_id=message.from_user.id,
+            message_text=message.text,
+            username=message.from_user.username,
+            first_name=message.from_user.first_name,
+            last_name=message.from_user.last_name,
+            session=session,
+            message=message,
+        )
+
+    keyboard = InlineKeyboardBuilder()
+    keyboard.row(InlineKeyboardButton(text=SUPPORT, url=SUPPORT_CHAT_URL))
+    keyboard.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+    await message.answer(
+        FALLBACK_MESSAGE,
+        reply_markup=keyboard.as_markup(),
+    )

handlers/instructions/instructions.py

@@ -1,12 +1,10 @@
 import os
+import urllib.parse
+
 from typing import Any
 
 from aiogram import F, Router
-from aiogram.types import (
-    CallbackQuery,
-    InlineKeyboardButton,
-    Message,
-)
+from aiogram.types import CallbackQuery, InlineKeyboardButton, Message
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from config import (
@@ -15,8 +13,9 @@ from config import (
     DOWNLOAD_MACOS,
     DOWNLOAD_PC,
     SUPPORT_CHAT_URL,
+    WEBHOOK_HOST,
 )
-from database import get_key_details
+from database import get_subscription_link
 from handlers.buttons import (
     BACK,
     CONNECT_MACOS_BUTTON,
@@ -28,7 +27,6 @@ from handlers.buttons import (
     PC_PC,
     SUPPORT,
     TV_CONTINUE,
-    TV_INSTRUCTIONS,
 )
 from handlers.texts import (
     CHOOSE_DEVICE_TEXT,
@@ -37,6 +35,7 @@ from handlers.texts import (
     INSTRUCTION_MACOS,
     INSTRUCTION_PC,
     KEY_MESSAGE,
+    ROUTER_MESSAGE,
     SUBSCRIPTION_DETAILS_TEXT,
 )
 from handlers.utils import edit_or_send_message
@@ -71,8 +70,8 @@ async def send_instructions(callback_query_or_message: CallbackQuery | Message):
 @router.callback_query(F.data.startswith("connect_pc|"))
 async def process_connect_pc(callback_query: CallbackQuery, session: Any):
     key_name = callback_query.data.split("|")[1]
-    record = await get_key_details(key_name, session)
-    if not record:
+    key_link = await get_subscription_link(session, key_name)
+    if not key_link:
         builder = InlineKeyboardBuilder()
         builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
         await edit_or_send_message(
@@ -86,7 +85,7 @@ async def process_connect_pc(callback_query: CallbackQuery, session: Any):
     builder = InlineKeyboardBuilder()
     builder.row(InlineKeyboardButton(text=PC_PC, callback_data=f"windows_menu|{key_name}"))
     builder.row(InlineKeyboardButton(text=PC_MACOS, callback_data=f"macos_menu|{key_name}"))
-    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"connect_device|{key_name}"))
 
     await edit_or_send_message(
         target_message=callback_query.message,
@@ -99,14 +98,25 @@ async def process_connect_pc(callback_query: CallbackQuery, session: Any):
 @router.callback_query(F.data.startswith("windows_menu|"))
 async def process_windows_menu(callback_query: CallbackQuery, session: Any):
     key_name = callback_query.data.split("|")[1]
-    record = await get_key_details(key_name, session)
-    key = record["key"]
-    key_message_text = KEY_MESSAGE.format(key)
+    key_link = await get_subscription_link(session, key_name)
+    if not key_link:
+        await callback_query.message.answer("❌ Ошибка: ключ не найден.")
+        return
+
+    key_message_text = KEY_MESSAGE.format(key_link)
     instruction_message = f"{key_message_text}{INSTRUCTION_PC}"
 
     builder = InlineKeyboardBuilder()
     builder.row(InlineKeyboardButton(text=DOWNLOAD_PC_BUTTON, url=DOWNLOAD_PC))
-    builder.row(InlineKeyboardButton(text=CONNECT_WINDOWS_BUTTON, url=f"{CONNECT_WINDOWS}{key}"))
+
+    if "happ://crypt" in key_link:
+        processed_link = urllib.parse.quote(key_link, safe="")
+        windows_url = f"{WEBHOOK_HOST}/?url={processed_link}"
+    else:
+        processed_link = key_link
+        windows_url = f"{CONNECT_WINDOWS}{processed_link}"
+
+    builder.row(InlineKeyboardButton(text=CONNECT_WINDOWS_BUTTON, url=windows_url))
     builder.row(InlineKeyboardButton(text=SUPPORT, url=SUPPORT_CHAT_URL))
     builder.row(InlineKeyboardButton(text=BACK, callback_data=f"connect_pc|{key_name}"))
 
@@ -121,14 +131,25 @@ async def process_windows_menu(callback_query: CallbackQuery, session: Any):
 @router.callback_query(F.data.startswith("macos_menu|"))
 async def process_macos_menu(callback_query: CallbackQuery, session: Any):
     key_name = callback_query.data.split("|")[1]
-    record = await get_key_details(key_name, session)
-    key = record["key"]
-    key_message_text = KEY_MESSAGE.format(key)
+    key_link = await get_subscription_link(session, key_name)
+    if not key_link:
+        await callback_query.message.answer("❌ Ошибка: ключ не найден.")
+        return
+
+    key_message_text = KEY_MESSAGE.format(key_link)
     instruction_message = f"{key_message_text}{INSTRUCTION_MACOS}"
 
     builder = InlineKeyboardBuilder()
     builder.row(InlineKeyboardButton(text=DOWNLOAD_MACOS_BUTTON, url=DOWNLOAD_MACOS))
-    builder.row(InlineKeyboardButton(text=CONNECT_MACOS_BUTTON, url=f"{CONNECT_MACOS}{key}"))
+
+    if "happ://crypt" in key_link:
+        processed_link = urllib.parse.quote(key_link, safe="")
+        macos_url = f"{WEBHOOK_HOST}/?url={processed_link}"
+    else:
+        processed_link = key_link
+        macos_url = f"{CONNECT_MACOS}{processed_link}"
+
+    builder.row(InlineKeyboardButton(text=CONNECT_MACOS_BUTTON, url=macos_url))
     builder.row(InlineKeyboardButton(text=SUPPORT, url=SUPPORT_CHAT_URL))
     builder.row(InlineKeyboardButton(text=BACK, callback_data=f"connect_pc|{key_name}"))
 
@@ -141,12 +162,12 @@ async def process_macos_menu(callback_query: CallbackQuery, session: Any):
 
 
 @router.callback_query(F.data.startswith("connect_tv|"))
-async def process_connect_tv(callback_query: CallbackQuery):
+async def process_connect_tv(callback_query: CallbackQuery, session: Any):
     key_name = callback_query.data.split("|")[1]
 
     builder = InlineKeyboardBuilder()
     builder.row(InlineKeyboardButton(text=TV_CONTINUE, callback_data=f"continue_tv|{key_name}"))
-    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"connect_device|{key_name}"))
     builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
 
     await edit_or_send_message(
@@ -161,13 +182,10 @@ async def process_connect_tv(callback_query: CallbackQuery):
 @router.callback_query(F.data.startswith("continue_tv|"))
 async def process_continue_tv(callback_query: CallbackQuery, session: Any):
     key_name = callback_query.data.split("|")[1]
-
-    record = await get_key_details(key_name, session)
-    subscription_link = record["key"]
-    message_text = SUBSCRIPTION_DETAILS_TEXT.format(subscription_link=subscription_link)
+    key_link = await get_subscription_link(session, key_name)
+    message_text = SUBSCRIPTION_DETAILS_TEXT.format(subscription_link=key_link)
 
     builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text=TV_INSTRUCTIONS, url="https://vpn4tv.com/quick-guide.html"))
     builder.row(InlineKeyboardButton(text=BACK, callback_data=f"connect_tv|{key_name}"))
     builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
 
@@ -177,3 +195,31 @@ async def process_continue_tv(callback_query: CallbackQuery, session: Any):
         reply_markup=builder.as_markup(),
         media_path=None,
     )
+
+
+@router.callback_query(F.data.startswith("connect_router|"))
+async def process_connect_router(callback_query: CallbackQuery, session: Any):
+    key_name = callback_query.data.split("|")[1]
+    key_link = await get_subscription_link(session, key_name)
+    if not key_link:
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+        await edit_or_send_message(
+            target_message=callback_query.message,
+            text="❌ Ключ не найден.",
+            reply_markup=builder.as_markup(),
+            media_path=None,
+        )
+        return
+
+    message_text = ROUTER_MESSAGE.format(subscription_link=key_link)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=message_text,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+    )

handlers/keys/__init__.py

@@ -2,7 +2,11 @@ __all__ = ("router",)
 
 from aiogram import Router
 
-from .key_management import router as management_router
+from .key_connect import router as connect_router
+from .key_freeze import router as freeze_router
+from .key_mode import router as key_mode_router
+from .key_renew import router as renew_router
+from .key_view import router as view_router
 from .keys import router as keys_router
 
 
@@ -10,5 +14,9 @@ router = Router(name="keys_main_router")
 
 router.include_routers(
     keys_router,
-    management_router,
+    view_router,
+    renew_router,
+    freeze_router,
+    connect_router,
+    key_mode_router,
 )

handlers/keys/key_connect.py

@@ -0,0 +1,262 @@
+import os
+import urllib.parse
+
+from io import BytesIO
+
+import qrcode
+
+from aiogram import F, Router, types
+from aiogram.types import CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from config import (
+    APP_URL,
+    CONNECT_ANDROID,
+    CONNECT_IOS,
+    DOWNLOAD_ANDROID,
+    DOWNLOAD_IOS,
+    INSTRUCTIONS_BUTTON,
+)
+from database import Key, get_subscription_link
+from handlers.buttons import (
+    ANDROID,
+    BACK,
+    DOWNLOAD_ANDROID_BUTTON,
+    DOWNLOAD_IOS_BUTTON,
+    IMPORT_ANDROID,
+    IMPORT_IOS,
+    IPHONE,
+    MAIN_MENU,
+    MANUAL_INSTRUCTIONS,
+    PC,
+    TV,
+)
+from handlers.texts import (
+    ANDROID_DESCRIPTION_TEMPLATE,
+    CHOOSE_DEVICE_TEXT,
+    IOS_DESCRIPTION_TEMPLATE,
+    SUBSCRIPTION_DESCRIPTION,
+)
+from handlers.utils import edit_or_send_message
+from hooks.hook_buttons import insert_hook_buttons
+from hooks.hooks import run_hooks
+from logger import logger
+
+
+router = Router()
+
+
+@router.callback_query(F.data.startswith("connect_device|"))
+async def handle_connect_device(callback_query: CallbackQuery, session: AsyncSession):
+    try:
+        key_name = callback_query.data.split("|")[1]
+
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=IPHONE, callback_data=f"connect_ios|{key_name}"))
+        builder.row(InlineKeyboardButton(text=ANDROID, callback_data=f"connect_android|{key_name}"))
+        builder.row(InlineKeyboardButton(text=PC, callback_data=f"connect_pc|{key_name}"))
+        builder.row(InlineKeyboardButton(text=TV, callback_data=f"connect_tv|{key_name}"))
+        builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+
+        try:
+            hook_builder = InlineKeyboardBuilder()
+            hook_builder.attach(builder)
+
+            hook_commands = await run_hooks(
+                "connect_device_menu", chat_id=callback_query.from_user.id, admin=False, session=session
+            )
+            if hook_commands:
+                hook_builder = insert_hook_buttons(hook_builder, hook_commands)
+
+            final_markup = hook_builder.as_markup()
+        except Exception as e:
+            logger.warning(f"[CONNECT_DEVICE] Ошибка при применении хуков: {e}")
+            final_markup = builder.as_markup()
+
+        await edit_or_send_message(
+            target_message=callback_query.message,
+            text=CHOOSE_DEVICE_TEXT,
+            reply_markup=final_markup,
+            media_path=None,
+        )
+    except Exception as e:
+        await callback_query.message.answer("❌ Ошибка при показе меню подключения.")
+        logger.error(f"Ошибка в handle_connect_device: {e}")
+
+
+@router.callback_query(F.data.startswith("connect_phone|"))
+async def process_callback_connect_phone(callback_query: CallbackQuery, session: AsyncSession):
+    email = callback_query.data.split("|")[1]
+
+    try:
+        key_link = await get_subscription_link(session, email)
+        if not key_link:
+            await callback_query.message.answer("❌ Ошибка: ключ не найден.")
+            return
+    except Exception as e:
+        logger.error(f"Ошибка при получении ссылки для {email}: {e}")
+        await callback_query.message.answer("❌ Произошла ошибка. Попробуйте позже.")
+        return
+
+    description = SUBSCRIPTION_DESCRIPTION.format(key_link=key_link)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(text=DOWNLOAD_IOS_BUTTON, url=DOWNLOAD_IOS),
+        InlineKeyboardButton(text=DOWNLOAD_ANDROID_BUTTON, url=DOWNLOAD_ANDROID),
+    )
+    if key_link and "happ://crypt" in key_link:
+        processed_link = urllib.parse.quote(key_link, safe="")
+        crypto_url = f"{APP_URL}/?url={processed_link}"
+        builder.row(
+            InlineKeyboardButton(text=IMPORT_IOS, url=crypto_url),
+            InlineKeyboardButton(text=IMPORT_ANDROID, url=crypto_url),
+        )
+    else:
+        processed_link = key_link
+        builder.row(
+            InlineKeyboardButton(text=IMPORT_IOS, url=f"{CONNECT_IOS}{processed_link}"),
+            InlineKeyboardButton(text=IMPORT_ANDROID, url=f"{CONNECT_ANDROID}{processed_link}"),
+        )
+    if INSTRUCTIONS_BUTTON:
+        builder.row(InlineKeyboardButton(text=MANUAL_INSTRUCTIONS, callback_data="instructions"))
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{email}"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=description,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+    )
+
+
+@router.callback_query(F.data.startswith("connect_ios|"))
+async def process_callback_connect_ios(callback_query: CallbackQuery, session: AsyncSession):
+    email = callback_query.data.split("|")[1]
+
+    try:
+        key_link = await get_subscription_link(session, email)
+        if not key_link:
+            await callback_query.message.answer("❌ Ошибка: ключ не найден.")
+            return
+    except Exception as e:
+        logger.error(f"Ошибка при получении ссылки для {email} (iOS): {e}")
+        await callback_query.message.answer("❌ Произошла ошибка. Попробуйте позже.")
+        return
+
+    description = IOS_DESCRIPTION_TEMPLATE.format(key_link=key_link)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text=DOWNLOAD_IOS_BUTTON, url=DOWNLOAD_IOS))
+
+    if key_link and "happ://crypt" in key_link:
+        processed_link = urllib.parse.quote(key_link, safe="")
+        ios_url = f"{APP_URL}/?url={processed_link}"
+    else:
+        processed_link = key_link
+        ios_url = f"{CONNECT_IOS}{processed_link}"
+
+    builder.row(InlineKeyboardButton(text=IMPORT_IOS, url=ios_url))
+    if INSTRUCTIONS_BUTTON:
+        builder.row(InlineKeyboardButton(text=MANUAL_INSTRUCTIONS, callback_data="instructions"))
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"connect_device|{email}"))
+    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=description,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+    )
+
+
+@router.callback_query(F.data.startswith("connect_android|"))
+async def process_callback_connect_android(callback_query: CallbackQuery, session: AsyncSession):
+    email = callback_query.data.split("|")[1]
+
+    try:
+        key_link = await get_subscription_link(session, email)
+        if not key_link:
+            await callback_query.message.answer("❌ Ошибка: ключ не найден.")
+            return
+    except Exception as e:
+        logger.error(f"Ошибка при получении ссылки для {email} (Android): {e}")
+        await callback_query.message.answer("❌ Произошла ошибка. Попробуйте позже.")
+        return
+
+    description = ANDROID_DESCRIPTION_TEMPLATE.format(key_link=key_link)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text=DOWNLOAD_ANDROID_BUTTON, url=DOWNLOAD_ANDROID))
+
+    if key_link and "happ://crypt" in key_link:
+        processed_link = urllib.parse.quote(key_link, safe="")
+        android_url = f"{APP_URL}/?url={processed_link}"
+    else:
+        processed_link = key_link
+        android_url = f"{CONNECT_ANDROID}{processed_link}"
+
+    builder.row(InlineKeyboardButton(text=IMPORT_ANDROID, url=android_url))
+    if INSTRUCTIONS_BUTTON:
+        builder.row(InlineKeyboardButton(text=MANUAL_INSTRUCTIONS, callback_data="instructions"))
+    builder.row(InlineKeyboardButton(text=BACK, callback_data=f"connect_device|{email}"))
+    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=description,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+    )
+
+
+@router.callback_query(F.data.startswith("show_qr|"))
+async def show_qr_code(callback_query: types.CallbackQuery, session: AsyncSession):
+    try:
+        key_name = callback_query.data.split("|")[1]
+
+        stmt = select(Key).where(Key.email == key_name)
+        result = await session.execute(stmt)
+        record = result.scalars().first()
+
+        if not record:
+            await callback_query.message.answer("❌ Подписка не найдена.")
+            return
+
+        qr_data = record.key or record.remnawave_link
+        if not qr_data:
+            await callback_query.message.answer("❌ У этой подписки отсутствует ссылка для подключения.")
+            return
+
+        qr = qrcode.QRCode(version=1, box_size=10, border=4)
+        qr.add_data(qr_data)
+        qr.make(fit=True)
+
+        img = qr.make_image(fill_color="black", back_color="white")
+        buffer = BytesIO()
+        img.save(buffer, format="PNG")
+        buffer.seek(0)
+
+        qr_path = f"/tmp/qrcode_{record.email}.png"
+        with open(qr_path, "wb") as f:
+            f.write(buffer.read())
+
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{record.email}"))
+        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+        await edit_or_send_message(
+            target_message=callback_query.message,
+            text="🔲 <b>Ваш QR-код для подключения</b>",
+            reply_markup=builder.as_markup(),
+            media_path=qr_path,
+            disable_cache=True,
+        )
+
+        os.remove(qr_path)
+
+    except Exception as e:
+        logger.error(f"Ошибка при генерации QR: {e}", exc_info=True)
+        await callback_query.message.answer("❌ Произошла ошибка при создании QR-кода.")

handlers/keys/key_freeze.py

@@ -0,0 +1,210 @@
+import time
+
+from typing import Any
+
+from aiogram import F, Router
+from aiogram.types import CallbackQuery, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from database import (
+    get_key_details,
+    get_servers,
+    get_tariff_by_id,
+    mark_key_as_frozen,
+    mark_key_as_unfrozen,
+)
+from handlers.buttons import APPLY, BACK, CANCEL
+from handlers.keys.operations import renew_key_in_cluster, toggle_client_on_cluster
+from handlers.texts import (
+    FREEZE_SUBSCRIPTION_CONFIRM_MSG,
+    SUBSCRIPTION_FROZEN_MSG,
+    SUBSCRIPTION_UNFROZEN_MSG,
+    UNFREEZE_SUBSCRIPTION_CONFIRM_MSG,
+)
+from handlers.utils import edit_or_send_message, handle_error
+from logger import logger
+
+
+router = Router()
+
+
+@router.callback_query(F.data.startswith("unfreeze_subscription|"))
+async def process_callback_unfreeze_subscription(callback_query: CallbackQuery, session: Any):
+    key_name = callback_query.data.split("|")[1]
+    confirm_text = UNFREEZE_SUBSCRIPTION_CONFIRM_MSG
+
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(
+            text=APPLY,
+            callback_data=f"unfreeze_subscription_confirm|{key_name}",
+        ),
+        InlineKeyboardButton(
+            text=CANCEL,
+            callback_data=f"view_key|{key_name}",
+        ),
+    )
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=confirm_text,
+        reply_markup=builder.as_markup(),
+    )
+
+
+@router.callback_query(F.data.startswith("unfreeze_subscription_confirm|"))
+async def process_callback_unfreeze_subscription_confirm(callback_query: CallbackQuery, session: Any):
+    """
+    Размораживает (включает) подписку.
+    """
+    tg_id = callback_query.message.chat.id
+    key_name = callback_query.data.split("|")[1]
+
+    try:
+        record = await get_key_details(session, key_name)
+        if not record:
+            await callback_query.message.answer("Ключ не найден.")
+            return
+
+        email = record["email"]
+        client_id = record["client_id"]
+        cluster_id = record["server_id"]
+
+        result = await toggle_client_on_cluster(cluster_id, email, client_id, enable=True, session=session)
+        if result["status"] != "success":
+            logger.warning(f"Не удалось включить подписку: {result.get('error') or result.get('results')}")
+
+        servers = await get_servers(session)
+        cluster_servers = servers.get(cluster_id, [])
+
+        if not cluster_servers:
+            text_error = "Сервер не найден."
+            builder = InlineKeyboardBuilder()
+            builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+            await edit_or_send_message(callback_query.message, text_error, builder.as_markup())
+            return
+
+        tariff = await get_tariff_by_id(session, record["tariff_id"]) if record.get("tariff_id") else None
+
+        if not tariff:
+            logger.info("[Unfreeze] Тариф не найден — применяем дефолтные значения.")
+            total_gb = 0
+            hwid_limit = 0
+        else:
+            total_gb = int(tariff.get("traffic_limit") or 0)
+            hwid_limit = int(tariff.get("device_limit") or 0)
+
+        now_ms = int(time.time() * 1000)
+        leftover = record["expiry_time"]
+        if leftover < 0:
+            leftover = 0
+        new_expiry_time = now_ms + leftover
+
+        await mark_key_as_unfrozen(session, record["tg_id"], client_id, new_expiry_time)
+        await session.commit()
+
+        max(leftover / (1000 * 86400), 0.01)
+        logger.info(
+            f"[Unfreeze Debug] Запуск renew_key_in_cluster с expiry={new_expiry_time}, gb={total_gb}, hwid={hwid_limit}"
+        )
+
+        await renew_key_in_cluster(
+            cluster_id=cluster_id,
+            email=email,
+            client_id=client_id,
+            new_expiry_time=new_expiry_time,
+            total_gb=total_gb,
+            session=session,
+            hwid_device_limit=hwid_limit,
+            reset_traffic=False,
+        )
+
+        text_ok = SUBSCRIPTION_UNFROZEN_MSG
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+        await edit_or_send_message(callback_query.message, text_ok, builder.as_markup())
+
+    except Exception as e:
+        await handle_error(tg_id, callback_query, f"Ошибка при включении подписки: {e}")
+
+
+@router.callback_query(F.data.startswith("freeze_subscription|"))
+async def process_callback_freeze_subscription(callback_query: CallbackQuery, session: Any):
+    """
+    Показывает пользователю диалог подтверждения заморозки (отключения) подписки.
+    """
+    key_name = callback_query.data.split("|")[1]
+
+    confirm_text = FREEZE_SUBSCRIPTION_CONFIRM_MSG
+
+    builder = InlineKeyboardBuilder()
+    builder.row(
+        InlineKeyboardButton(
+            text=APPLY,
+            callback_data=f"freeze_subscription_confirm|{key_name}",
+        ),
+        InlineKeyboardButton(
+            text=CANCEL,
+            callback_data=f"view_key|{key_name}",
+        ),
+    )
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=confirm_text,
+        reply_markup=builder.as_markup(),
+    )
+
+
+@router.callback_query(F.data.startswith("freeze_subscription_confirm|"))
+async def process_callback_freeze_subscription_confirm(callback_query: CallbackQuery, session: Any):
+    """
+    Замораживает (отключает) подписку.
+    """
+    tg_id = callback_query.message.chat.id
+    key_name = callback_query.data.split("|")[1]
+
+    try:
+        record = await get_key_details(session, key_name)
+        if not record:
+            await callback_query.message.answer("Ключ не найден.")
+            return
+
+        email = record["email"]
+        client_id = record["client_id"]
+        cluster_id = record["server_id"]
+
+        result = await toggle_client_on_cluster(cluster_id, email, client_id, enable=False, session=session)
+
+        if result["status"] == "success":
+            now_ms = int(time.time() * 1000)
+            time_left = record["expiry_time"] - now_ms
+            if time_left < 0:
+                time_left = 0
+
+            await mark_key_as_frozen(session, record["tg_id"], client_id, time_left)
+            await session.commit()
+
+            text_ok = SUBSCRIPTION_FROZEN_MSG
+            builder = InlineKeyboardBuilder()
+            builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+            await edit_or_send_message(
+                target_message=callback_query.message,
+                text=text_ok,
+                reply_markup=builder.as_markup(),
+            )
+
+        else:
+            text_error = (
+                f"Произошла ошибка при заморозке подписки.\nДетали: {result.get('error') or result.get('results')}"
+            )
+            builder = InlineKeyboardBuilder()
+            builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{key_name}"))
+            await edit_or_send_message(
+                target_message=callback_query.message,
+                text=text_error,
+                reply_markup=builder.as_markup(),
+            )
+
+    except Exception as e:
+        await handle_error(tg_id, callback_query, f"Ошибка при заморозке подписки: {e}")

handlers/keys/key_management.py

@@ -1,669 +0,0 @@
-import asyncio
-import uuid
-
-from datetime import datetime, timedelta
-from typing import Any
-
-import pytz
-
-from aiogram import F, Router
-from aiogram.fsm.context import FSMContext
-from aiogram.types import CallbackQuery, InlineKeyboardButton, Message, FSInputFile
-from aiogram.utils.keyboard import InlineKeyboardBuilder
-from py3xui import AsyncApi
-
-from bot import bot
-from config import (
-    ADMIN_PASSWORD,
-    ADMIN_USERNAME,
-    CONNECT_PHONE_BUTTON,
-    NOTIFY_EXTRA_DAYS,
-    PUBLIC_LINK,
-    RENEWAL_PRICES,
-    SUPPORT_CHAT_URL,
-    TRIAL_TIME,
-    TRIAL_TIME_DISABLE,
-    USE_COUNTRY_SELECTION,
-    USE_NEW_PAYMENT_FLOW,
-)
-from database import (
-    add_connection,
-    check_connection_exists,
-    create_temporary_data,
-    get_balance,
-    get_key_details,
-    get_trial,
-    store_key,
-    update_balance,
-    update_trial,
-    check_server_name_by_cluster,
-)
-from handlers.buttons import (
-    BACK,
-    CONNECT_DEVICE,
-    CONNECT_PHONE,
-    MAIN_MENU,
-    PAYMENT,
-    PC_BUTTON,
-    SUPPORT,
-    TV_BUTTON,
-)
-from handlers.keys.key_utils import create_client_on_server, create_key_on_cluster
-from handlers.payments.robokassa_pay import handle_custom_amount_input
-from handlers.payments.yookassa_pay import process_custom_amount_input
-from handlers.texts import (
-    CREATING_CONNECTION_MSG,
-    DISCOUNTS,
-    INSUFFICIENT_FUNDS_MSG,
-    SELECT_COUNTRY_MSG,
-    SELECT_TARIFF_PLAN_MSG,
-    key_message_success,
-)
-from handlers.utils import edit_or_send_message, generate_random_email, get_least_loaded_cluster
-from logger import logger
-from panels.three_xui import delete_client
-
-
-router = Router()
-
-moscow_tz = pytz.timezone("Europe/Moscow")
-
-
-class Form(FSMContext):
-    waiting_for_server_selection = "waiting_for_server_selection"
-    waiting_for_key_name = "waiting_for_key_name"
-    viewing_profile = "viewing_profile"
-    waiting_for_message = "waiting_for_message"
-
-
-@router.callback_query(F.data == "create_key")
-async def confirm_create_new_key(callback_query: CallbackQuery, state: FSMContext, session: Any):
-    tg_id = callback_query.message.chat.id
-    await handle_key_creation(tg_id, state, session, callback_query)
-
-
-async def handle_key_creation(
-    tg_id: int,
-    state: FSMContext,
-    session: Any,
-    message_or_query: Message | CallbackQuery,
-):
-    """Создание ключа с учётом выбора тарифного плана."""
-    current_time = datetime.now(moscow_tz)
-
-    if not TRIAL_TIME_DISABLE:
-        trial_status = await get_trial(tg_id, session)
-        if trial_status in [0, -1]:
-            extra_days = NOTIFY_EXTRA_DAYS if trial_status == -1 else 0
-            expiry_time = current_time + timedelta(days=TRIAL_TIME + extra_days)
-            logger.info(f"Доступен {TRIAL_TIME + extra_days}-дневный пробный период пользователю {tg_id}.")
-            await edit_or_send_message(
-                target_message=message_or_query if isinstance(message_or_query, Message) else message_or_query.message,
-                text=CREATING_CONNECTION_MSG,
-                reply_markup=None,
-            )
-            await state.update_data(is_trial=True)
-            await create_key(tg_id, expiry_time, state, session, message_or_query)
-            return
-
-    builder = InlineKeyboardBuilder()
-    for index, (plan_id, price) in enumerate(RENEWAL_PRICES.items()):
-        discount_text = ""
-        if DISCOUNTS and plan_id in DISCOUNTS:
-            discount_percentage = DISCOUNTS[plan_id]
-            discount_text = f" ({discount_percentage}% скидка)"
-            if index == len(RENEWAL_PRICES) - 1:
-                discount_text = f" ({discount_percentage}% 🔥)"
-        builder.row(
-            InlineKeyboardButton(
-                text=f"📅 {plan_id} мес. - {price}₽{discount_text}",
-                callback_data=f"select_plan_{plan_id}",
-            )
-        )
-    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-
-    if isinstance(message_or_query, CallbackQuery):
-        target_message = message_or_query.message
-    else:
-        target_message = message_or_query
-
-    await edit_or_send_message(
-        target_message=target_message,
-        text=SELECT_TARIFF_PLAN_MSG,
-        reply_markup=builder.as_markup(),
-        media_path=None,
-    )
-
-    await state.update_data(tg_id=tg_id)
-    await state.set_state(Form.waiting_for_server_selection)
-
-
-@router.callback_query(F.data.startswith("select_plan_"))
-async def select_tariff_plan(callback_query: CallbackQuery, session: Any, state: FSMContext):
-    tg_id = callback_query.message.chat.id
-    plan_id = callback_query.data.split("_")[-1]
-    plan_price = RENEWAL_PRICES.get(plan_id)
-    if plan_price is None:
-        await callback_query.message.answer("🚫 Неверный тарифный план.")
-        return
-    duration_days = int(plan_id) * 30
-    balance = await get_balance(tg_id)
-    if balance < plan_price:
-        required_amount = plan_price - balance
-        await create_temporary_data(
-            session,
-            tg_id,
-            "waiting_for_payment",
-            {
-                "plan_id": plan_id,
-                "plan_price": plan_price,
-                "duration_days": duration_days,
-                "required_amount": required_amount,
-            },
-        )
-        if USE_NEW_PAYMENT_FLOW == "YOOKASSA":
-            await process_custom_amount_input(callback_query, session)
-        elif USE_NEW_PAYMENT_FLOW == "ROBOKASSA":
-            await handle_custom_amount_input(callback_query, session)
-        else:
-            builder = InlineKeyboardBuilder()
-            builder.row(InlineKeyboardButton(text=PAYMENT, callback_data="pay"))
-            builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-            await edit_or_send_message(
-                target_message=callback_query.message,
-                text=INSUFFICIENT_FUNDS_MSG.format(required_amount=required_amount),
-                reply_markup=builder.as_markup(),
-                media_path=None,
-            )
-        return
-    builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text="⏳ Подождите...", callback_data="creating_key"))
-
-    await edit_or_send_message(
-        target_message=callback_query.message,
-        text=CREATING_CONNECTION_MSG,
-        reply_markup=builder.as_markup(),
-    )
-
-    expiry_time = datetime.now(moscow_tz) + timedelta(days=duration_days)
-    await state.update_data(plan_id=plan_id)
-    await create_key(tg_id, expiry_time, state, session, callback_query, plan=int(plan_id))
-
-async def create_key(
-    tg_id: int,
-    expiry_time: datetime,
-    state: FSMContext | None,
-    session: Any,
-    message_or_query: Message | CallbackQuery | None = None,
-    old_key_name: str = None,
-    plan: int = None,
-):
-    """Создаёт ключ с заданным сроком действия."""
-
-    target_message = message_or_query.message if isinstance(message_or_query, CallbackQuery) else message_or_query
-    if not await check_connection_exists(tg_id):
-        await add_connection(tg_id, balance=0.0, trial=0, session=session)
-        logger.info(f"[Connection] Подключение создано для пользователя {tg_id}")
-
-    if USE_COUNTRY_SELECTION:
-        logger.info("[Country Selection] USE_COUNTRY_SELECTION включен. Получение наименее загруженного кластера")
-        least_loaded_cluster = await get_least_loaded_cluster()
-        logger.info(f"[Country Selection] Наименее загруженный кластер: {least_loaded_cluster}. Получаем список серверов")
-        servers = await session.fetch(
-            "SELECT server_name, api_url FROM servers WHERE cluster_name = $1",
-            least_loaded_cluster,
-        )
-        if not servers:
-            logger.error(f"Нет серверов в кластере {least_loaded_cluster}")
-            error_message = "❌ Нет доступных серверов для создания ключа."
-            if target_message:
-                await edit_or_send_message(
-                    target_message=target_message, text=error_message, reply_markup=None, media_path=None
-                )
-            else:
-                await bot.send_message(chat_id=tg_id, text=error_message)
-            return
-
-        available_servers = []
-        tasks = []
-        for server in servers:
-            server_info = {
-                "server_name": server["server_name"],
-                "api_url": server["api_url"],
-            }
-            task = asyncio.create_task(check_server_availability(server_info))
-            tasks.append(task)
-
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        for server, result in zip(servers, results):
-            if result is True:
-                available_servers.append(server["server_name"])
-
-        if not available_servers:
-            logger.error(f"Нет доступных серверов в кластере {least_loaded_cluster}")
-            error_message = "❌ Нет доступных серверов для создания ключа."
-            if target_message:
-                await edit_or_send_message(
-                    target_message=target_message, text=error_message, reply_markup=None, media_path=None
-                )
-            else:
-                await bot.send_message(chat_id=tg_id, text=error_message)
-            return
-
-        logger.info(f"[Country Selection] Список доступных серверов: {available_servers}")
-
-        builder = InlineKeyboardBuilder()
-        ts = int(expiry_time.timestamp())
-        for country in available_servers:
-            if old_key_name:
-                callback_data = f"select_country|{country}|{ts}|{old_key_name}"
-            else:
-                callback_data = f"select_country|{country}|{ts}"
-            builder.row(InlineKeyboardButton(text=country, callback_data=callback_data))
-        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-
-        if target_message:
-            await edit_or_send_message(
-                target_message=target_message,
-                text=SELECT_COUNTRY_MSG,
-                reply_markup=builder.as_markup(),
-                media_path=None,
-            )
-        else:
-            await bot.send_message(
-                chat_id=tg_id,
-                text=SELECT_COUNTRY_MSG,
-                reply_markup=builder.as_markup(),
-            )
-        return
-
-    while True:
-        key_name = generate_random_email()
-        logger.info(f"[Key Generation] Сгенерировано имя ключа: {key_name} для пользователя {tg_id}")
-        existing_key = await get_key_details(key_name, session)
-        if not existing_key:
-            break
-        logger.warning(f"[Key Generation] Имя ключа {key_name} уже существует. Генерация нового.")
-
-    client_id = str(uuid.uuid4())
-    email = key_name.lower()
-    expiry_timestamp = int(expiry_time.timestamp() * 1000)
-    public_link = f"{PUBLIC_LINK}{email}/{tg_id}"
-
-    try:
-        least_loaded_cluster = await get_least_loaded_cluster()
-        tasks = [
-            asyncio.create_task(
-                create_key_on_cluster(least_loaded_cluster, tg_id, client_id, email, expiry_timestamp, plan)
-            )
-        ]
-        await asyncio.gather(*tasks, return_exceptions=True)
-        logger.info(f"[Key Creation] Ключ создан на кластере {least_loaded_cluster} для пользователя {tg_id}")
-        await store_key(
-            tg_id,
-            client_id,
-            email,
-            expiry_timestamp,
-            public_link,
-            least_loaded_cluster,
-            session,
-        )
-
-        data = {}
-        if state:
-            data = await state.get_data()
-
-        if data.get("is_trial"):
-            trial_status = await get_trial(tg_id, session)
-            if trial_status in [0, -1]:
-                await update_trial(tg_id, 1, session)
-        if data.get("plan_id"):
-            plan_price = RENEWAL_PRICES.get(data["plan_id"])
-            await update_balance(tg_id, -plan_price, session)
-        logger.info(f"[Database] Ключ сохранён в базе данных для пользователя {tg_id}")
-    except Exception as e:
-        logger.error(f"[Error] Ошибка при создании ключа для пользователя {tg_id}: {e}")
-        error_message = "❌ Произошла ошибка при создании подписки. Пожалуйста, попробуйте снова."
-        if target_message:
-            await edit_or_send_message(
-                target_message=target_message, text=error_message, reply_markup=None, media_path=None
-            )
-        else:
-            await bot.send_message(chat_id=tg_id, text=error_message)
-        return
-
-    builder = InlineKeyboardBuilder()
-    if CONNECT_PHONE_BUTTON:
-        builder.row(InlineKeyboardButton(text=CONNECT_PHONE, callback_data=f"connect_phone|{key_name}"))
-        builder.row(
-            InlineKeyboardButton(text=PC_BUTTON, callback_data=f"connect_pc|{email}"),
-            InlineKeyboardButton(text=TV_BUTTON, callback_data=f"connect_tv|{email}"),
-        )
-    else:
-        builder.row(
-            InlineKeyboardButton(
-                text=CONNECT_DEVICE,
-                callback_data=f"connect_device|{key_name}",
-            )
-        )
-    builder.row(InlineKeyboardButton(text=SUPPORT, url=SUPPORT_CHAT_URL))
-    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-
-    expiry_time_local = expiry_time.replace(tzinfo=None).astimezone(moscow_tz)
-    remaining_time = expiry_time_local - datetime.now(moscow_tz)
-    days = remaining_time.days
-    key_message_text = key_message_success(public_link, f"⏳ Осталось дней: {days} 📅")
-
-    default_media_path = "img/pic.jpg"
-
-    if target_message:
-        await edit_or_send_message(
-            target_message=target_message,
-            text=key_message_text,
-            reply_markup=builder.as_markup(),
-            media_path=default_media_path,
-        )
-
-    else:
-        photo = FSInputFile(default_media_path)
-        await bot.send_photo(
-            chat_id=tg_id,
-            photo=photo,
-            caption=key_message_text,
-            reply_markup=builder.as_markup(),
-        )
-    if state:
-        await state.clear()
-
-
-@router.callback_query(F.data.startswith("change_location|"))
-async def change_location_callback(callback_query: CallbackQuery, session: Any):
-    try:
-        data = callback_query.data.split("|")
-        if len(data) < 2:
-            await callback_query.answer("❌ Некорректные данные", show_alert=True)
-            return
-
-        old_key_name = data[1]
-        record = await get_key_details(old_key_name, session)
-        if not record:
-            await callback_query.answer("❌ Ключ не найден", show_alert=True)
-            return
-
-        expiry_timestamp = record["expiry_time"]
-        ts = int(expiry_timestamp / 1000)
-
-        current_server = record["server_id"]
-
-        cluster_info = await check_server_name_by_cluster(current_server, session)
-        if not cluster_info:
-            await callback_query.answer("❌ Кластер для текущего сервера не найден", show_alert=True)
-            return
-
-        cluster_name = cluster_info["cluster_name"]
-
-        servers = await session.fetch(
-            "SELECT server_name, api_url FROM servers WHERE cluster_name = $1 AND server_name != $2",
-            cluster_name,
-            current_server,
-        )
-        if not servers:
-            await callback_query.answer("❌ Доступных серверов в кластере не найдено", show_alert=True)
-            return
-
-        available_servers = []
-        tasks = []
-        for server in servers:
-            server_info = {
-                "server_name": server["server_name"],
-                "api_url": server["api_url"],
-            }
-            task = asyncio.create_task(check_server_availability(server_info))
-            tasks.append(task)
-
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        for server, result in zip(servers, results):
-            if result is True:
-                available_servers.append(server["server_name"])
-
-        if not available_servers:
-            await callback_query.answer("❌ Нет доступных серверов для смены локации", show_alert=True)
-            return
-
-        logger.info(f"Доступные страны для смены локации: {available_servers}")
-
-        builder = InlineKeyboardBuilder()
-        for country in available_servers:
-            callback_data = f"select_country|{country}|{ts}|{old_key_name}"
-            builder.row(InlineKeyboardButton(text=country, callback_data=callback_data))
-        builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{old_key_name}"))
-
-        await edit_or_send_message(
-            target_message=callback_query.message,
-            text="🌍 Пожалуйста, выберите новую локацию для вашей подписки:",
-            reply_markup=builder.as_markup(),
-            media_path=None,
-        )
-    except Exception as e:
-        logger.error(f"Ошибка при смене локации для пользователя {callback_query.from_user.id}: {e}")
-        await callback_query.answer("❌ Ошибка смены локации. Попробуйте снова.", show_alert=True)
-
-
-@router.callback_query(F.data.startswith("select_country|"))
-async def handle_country_selection(callback_query: CallbackQuery, session: Any, state: FSMContext):
-    """
-    Обрабатывает выбор страны.
-    Формат callback data:
-      select_country|{selected_country}|{ts} [|{old_key_name} (опционально)]
-    Если передан old_key_name – значит, происходит смена локации.
-    """
-    data = callback_query.data.split("|")
-    if len(data) < 3:
-        await callback_query.message.answer("❌ Некорректные данные. Попробуйте снова.")
-        return
-
-    selected_country = data[1]
-    try:
-        ts = int(data[2])
-    except ValueError:
-        await callback_query.message.answer("❌ Некорректное время истечения. Попробуйте снова.")
-        return
-
-    expiry_time = datetime.fromtimestamp(ts, tz=moscow_tz)
-
-    old_key_name = data[3] if len(data) > 3 else None
-
-    tg_id = callback_query.from_user.id
-    logger.info(f"Пользователь {tg_id} выбрал страну: {selected_country}")
-    logger.info(f"Получено время истечения (timestamp): {ts}")
-
-    await finalize_key_creation(tg_id, expiry_time, selected_country, state, session, callback_query, old_key_name)
-
-
-async def finalize_key_creation(
-    tg_id: int,
-    expiry_time: datetime,
-    selected_country: str,
-    state: FSMContext | None,
-    session: Any,
-    callback_query: CallbackQuery,
-    old_key_name: str = None,
-):
-    """Финализирует создание ключа с выбором стран."""
-
-    if not await check_connection_exists(tg_id):
-        await add_connection(tg_id, balance=0.0, trial=0, session=session)
-        logger.info(f"[Connection] Подключение создано для пользователя {tg_id}")
-
-    expiry_time = expiry_time.astimezone(moscow_tz)
-
-    if old_key_name:
-        old_key_details = await get_key_details(old_key_name, session)
-        if not old_key_details:
-            await callback_query.message.answer("❌ Ключ не найден. Попробуйте снова.")
-            return
-
-        key_name = old_key_name
-        client_id = old_key_details["client_id"]
-        email = old_key_details["email"]
-        expiry_timestamp = old_key_details["expiry_time"]
-        public_link = old_key_details["key"]
-    else:
-        while True:
-            key_name = generate_random_email()
-            existing_key = await get_key_details(key_name, session)
-            if not existing_key:
-                break
-            logger.warning(f"Key name '{key_name}' already exists for user {tg_id}. Generating a new one.")
-
-        client_id = str(uuid.uuid4())
-        email = key_name.lower()
-        expiry_timestamp = int(expiry_time.timestamp() * 1000)
-        public_link = f"{PUBLIC_LINK}{email}/{tg_id}"
-
-    try:
-        server_info = await session.fetchrow(
-            "SELECT api_url, inbound_id, server_name FROM servers WHERE server_name = $1",
-            selected_country,
-        )
-
-        if not server_info:
-            raise ValueError(f"Сервер {selected_country} не найден.")
-
-        if old_key_name:
-            old_server_id = old_key_details.get("server_id")
-            if old_server_id:
-                old_server_info = await session.fetchrow(
-                    "SELECT api_url, inbound_id, server_name FROM servers WHERE server_name = $1",
-                    old_server_id,
-                )
-
-                if old_server_info:
-                    xui = AsyncApi(
-                        old_server_info["api_url"],
-                        username=ADMIN_USERNAME,
-                        password=ADMIN_PASSWORD,
-                        logger=logger,
-                    )
-                    deletion_success = await delete_client(
-                        xui,
-                        old_server_info["inbound_id"],
-                        email,
-                        client_id,
-                    )
-                    if not deletion_success:
-                        logger.warning(f"Не удалось удалить клиента с сервера {old_server_id}, но продолжаем процесс.")
-
-        semaphore = asyncio.Semaphore(2)
-        await create_client_on_server(
-            server_info=server_info,
-            tg_id=tg_id,
-            client_id=client_id,
-            email=email,
-            expiry_timestamp=expiry_timestamp,
-            semaphore=semaphore,
-        )
-
-        logger.info(f"Key created on server {selected_country} for user {tg_id}.")
-
-        if old_key_name:
-            await session.execute(
-                """
-                UPDATE keys
-                SET server_id = $1
-                WHERE tg_id = $2 AND email = $3
-                """,
-                selected_country,
-                tg_id,
-                old_key_name,
-            )
-        else:
-            created_at = int(datetime.now(moscow_tz).timestamp() * 1000)
-            await session.execute(
-                """
-                INSERT INTO keys (tg_id, client_id, email, created_at, expiry_time, key, server_id)
-                VALUES ($1, $2, $3, $4, $5, $6, $7)
-                """,
-                tg_id,
-                client_id,
-                email,
-                created_at,
-                expiry_timestamp,
-                public_link,
-                selected_country,
-            )
-            data = await state.get_data()
-            if data.get("is_trial"):
-                trial_status = await get_trial(tg_id, session)
-                if trial_status in [0, -1]:
-                    await update_trial(tg_id, 1, session)
-            if data.get("plan_id"):
-                plan_price = RENEWAL_PRICES.get(data["plan_id"])
-                await update_balance(tg_id, -plan_price, session)
-
-    except Exception as e:
-        logger.error(f"Error while creating the key for user {tg_id}: {e}")
-        await callback_query.message.answer("❌ Произошла ошибка при создании подписки. Пожалуйста, попробуйте снова.")
-        return
-
-    builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text=SUPPORT, url=SUPPORT_CHAT_URL))
-    if CONNECT_PHONE_BUTTON:
-        builder.row(InlineKeyboardButton(text=CONNECT_PHONE, callback_data=f"connect_phone|{key_name}"))
-        builder.row(
-            InlineKeyboardButton(text=PC_BUTTON, callback_data=f"connect_pc|{email}"),
-            InlineKeyboardButton(text=TV_BUTTON, callback_data=f"connect_tv|{email}"),
-        )
-    else:
-        builder.row(
-            InlineKeyboardButton(
-                text=CONNECT_DEVICE,
-                callback_data=f"connect_device|{key_name}",
-            )
-        )
-    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-
-    remaining_time = expiry_time - datetime.now(moscow_tz)
-    days = remaining_time.days
-    key_message_text = key_message_success(public_link, f"⏳ Осталось дней: {days} 📅")
-
-    default_media_path = "img/pic.jpg"
-
-    await edit_or_send_message(
-        target_message=callback_query.message,
-        text=key_message_text,
-        reply_markup=builder.as_markup(),
-        media_path=default_media_path, 
-    )
-
-    if state:
-        await state.clear()
-
-async def check_server_availability(server_info: dict) -> bool:
-    """
-    Проверяет доступность сервера через API.
-
-    Args:
-        server_info (dict): Информация о сервере (api_url, username, password).
-
-    Returns:
-        bool: True, если сервер доступен, False в противном случае.
-    """
-    try:
-        xui = AsyncApi(
-            server_info["api_url"],
-            username=ADMIN_USERNAME,
-            password=ADMIN_PASSWORD,
-            logger=logger,
-        )
-        await asyncio.wait_for(xui.login(), timeout=5.0)
-        logger.info(f"Сервер {server_info.get('server_name', 'unknown')} доступен.")
-        return True
-    except asyncio.TimeoutError:
-        logger.warning(f"Сервер {server_info.get('server_name', 'unknown')} не ответил вовремя.")
-        return False
-    except Exception as e:
-        logger.warning(f"Сервер {server_info.get('server_name', 'unknown')} недоступен: {e}")
-        return False