version 4.0

Рефакторинг и оптимизация обработки подписок

.gitignore

@@ -1,8 +1,60 @@
-/venv
+# Byte-compiled / optimized / DLL files
-/__pycache__
+__pycache__/
-/vpn_users.db
+*.py[cod]
-/config.py
+*$py.class
-/database.db
+
-/bot_old.py
+# Distribution / packaging
-/bot_old_2.py
+dist/
-/database.db
+build/
+*.egg-info/
+
+# Virtual environments
+venv/
+env/
+.env/
+.venv/
+
+# IDE specific files
+.idea/
+.vscode/
+*.sublime-project
+*.sublime-workspace
+
+# Logs and databases
+*.log
+*.sqlite3
+*.db
+
+# Sensitive configuration files
+config.py
+config.ini
+.env
+
+# Backup files
+*.bak
+*.swp
+*~
+
+# Specific project files
+vpn_users.db
+database.db
+bot_old.py
+bot_old_2.py
+backup_pg.sh
+docker-compose.yml
+config copy.py
+handlers/texts.py
+
+# Miscellaneous
+.DS_Store
+Thumbs.db
+
+nginx.conf
+scripts
+models.py
+Dockerfile
+.csv
+/logs
+setup.py
+.ruff_cache
+.github/workflows/

.python-version

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

LICENSE

@@ -0,0 +1,330 @@
+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.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+
+  j. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  k. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  l. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.

Makefile

@@ -0,0 +1,7 @@
+formatting:
+	@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

README.md

@@ -1,91 +1,106 @@
 # 🚀 SoloBot
 
-**[SoloBot]**!  
+**SoloBot** — ваш идеальный помощник для управления API 3x-UI VPN на протоколе VLESS.
-[Бот для API x-ray]  
 
-## 📋 Оглавление
+<img src="./img/preview.gif" alt="SoloBot" width="1600">
-1. [Описание](#описание)
-2. [Требования](#требования)
-3. [Установка](#установка)
-4. [Конфигурация](#конфигурация)
-5. [Запуск](#запуск)
-6. [Автор](#автор)
 
----
+# Описание
+Бот, предоставляющий инструменты под различные реализации. Хорошая кастомизация и подстройка под свой бренд.
 
-## 📖 Описание
+# Основные возможности
 
-[Бот предназначен для автоматизирования выдачи ключей, хранении их в базе данных и управления подключениями]  
+**SoloBot** реализует множество функций, включая:
+
+### Управление подписками
+- Выдача подписок на различные периоды (**1 месяц, 3 месяца, полгода, год**).
+- Использование **тестового периода** подписки.
+- Продление ключей на указанные периоды.
+
+### Полный контроль клиента над своими ключами
+- Просмотр информации о ключе (**сервер, оставшееся время, сам ключ**).
+- Продление ключей.
+- Удаление ключей.
+- Просмотр полной информации вплоть до минут истечения
+- Смена локации (**перемещение ключа между серверами**).
+- Поддержка **нескольких ключей и устройств** для одного клиента.
+
+### Реферальная программа
+- Уникальная ссылка для приглашений.
+- Инлайн режим или обычные сообщения
+
+### Интеграция платёжных систем
+В боте реализована интеграция касс как для физических лиц, так и для самозанятых и ИП:
+- **Юкасса** (Самозанятость и ИП)
+- **Юмани** (Физические Лица) (TrackLine)
+- **Robokassa** (Физические Лица)
+- **Cryptobot** (Криптовалюта) (izzzzzi)
+- **Звезды Telegram**
+
+### Безопасность и стабильность
+- **Периодические бэкапы** базы данных клиентов и их восстановление.
+- **Смена домена** в случае переезда.
+
+### Уведомления
+- **Произвольные сообщения** через панель администратора.
+- Уведомления о **неиспользованных пробниках**.
+- Уведомления об **истекающих ключах** (_за сутки, за 6 часов и в момент истечения_).
+- **Воронка продаж**. Если клиент не взял пробник предлагаются более выгодные условия.
+- **Рассылка лично или всем.** С сохранением форматирования и отправкой картинок
+
+### Серверы
+- **Мультисерверность** — добавление сервера прямо в админке.
+- **Проверка на доступность** — бот следит за серверами и их откликом.
+- **Балансировка** — бот выдает подписку на наименее загруженный сервер.
+- **Сихронизация** — перемещайте клиентов на другие сервера бесшовно.
+
+### Удобная админ-панель
+- **Поиск клиента** — по айди, нику или ключу.
+- **Управление подпиской клиента** — перевыпуск, изменение баланса и остальное.
+- **Управление ботом** — перезагрузка, списки банов, смена домена.
+- *А также рассылки, создание купонов, просмотр детальной статистики и многое другое*
 
 
----
+<img src="./img/preview_2.gif" alt="SoloBot" width="1600">
 
-## 💻 Требования
+### Кастомизация
+- **Пробник** — Сами решаете будет или нет. Количество дней пробника также кастомизируется.
+- **Реферальная программа** — процент с каждого пополнения или фиксированная сумма.
+- **Все меню** — меняйте все меню как вам захочется, описания и тексты.
+- **Кешбэк** — начисляйте кэшбек за пополнения, если хотите.
+- **Настройки** — капча, подписка на канал, купоны и прочее.
+- **Автоматика** — удалять ли ключи после продления, продлевать ли их и остальное.
 
-Для работы проекта необходимы следующие компоненты:
+### *Настраивайте как вам удобно!*
-
-- **Python** версии 3.8 или выше
-- **Git** для клонирования репозитория
-- **Virtualenv** для создания виртуального окружения (рекомендуется)
-- **postgresql** для работы базы данных
-
----
-
-## ⚙️ Установка
-
-### 1️⃣ Шаг 1: Клонирование репозитория
-
-Клонируйте репозиторий и перейдите в его директорию:
-
-```bash
-git clone https://github.com/Vladless/Solo_bot.git
-cd solo_bot
-```
-
-### 2️⃣ Шаг 2: Создание и активация виртуального окружения
-
-```
-python3 -m venv venv
-source venv/bin/activate
-```
-
-### 3️⃣ Шаг 3: Установка зависимостей
-
-```
-pip install -r requirements.txt
-```
-
-### 🛠️ Конфигурация
-
-Для правильной работы вам нужно установить и запустить postgresql, создать пользователя для работы с базой данных и выдать ему права
-
-Также создайте файл config.py в корневой папке проекта с вашими данными:
-
-```
-API_TOKEN = токен вашего бота телеграм
-API_URL = домен вашего x-ray сервера с указанием порта и дополнительным путем панели вида "https://{domen}:{port}/{путь}" без слэша в конце
-ADMIN_USERNAME = логин от вашей панели x-ray
-ADMIN_PASSWORD = пароль от вашей панели x-ray
-ADD_CLIENT_URL = f"{API_URL}/panel/api/inbounds/addClient"
-GET_INBOUNDS_URL = f"{API_URL}/panel/api/inbounds/list/"
-AUTH_URL = f"{API_URL}/login/"
-DOMEN = "{ваш домен без https://}:443"
-DATABASE_URL = путь к вашей базе данных, имеет вид "postgresql://{user}:{password}@{Ip-adress}:{port}/{имя базы данных}"
-ADMIN_ID = ID телеграм профиля администратора
-CHANNEL_URL = ссылка на ваш телеграм канал
-```
-
-### 🚀 Запуск
-
-введите команду из виртуального окружения
-
-```
-python main.py
-```
-🔗 SoloBot в Telegram
-
-Попробуйте SoloBot прямо сейчас в Telegram [по этой ссылке](https://t.me/SoloNetVPN_bot).
 
 
+## Список версий
+
+#### Бот постоянно развивается, обрастая новыми возможностями.
+#### Для полного рассмотрения каждой версии ознакомьтесь с [**релизами**](https://github.com/Vladless/Solo_bot/releases).
 
 
+## 🔗 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)

assets/schema.sql

@@ -0,0 +1,114 @@
+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)
+);
+
+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,
+    usage_limit INTEGER     NOT NULL DEFAULT 1,
+    usage_count INTEGER     NOT NULL DEFAULT 0,
+    is_used     BOOLEAN     NOT NULL DEFAULT FALSE
+);
+
+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()
+);

auth.py

@@ -1,56 +0,0 @@
-import json
-
-import requests
-
-from config import API_URL, GET_INBOUNDS_URL
-
-session = None
-
-def login_with_credentials(username, password):
-    global session
-    session = requests.Session()
-    auth_url = f"{API_URL}/login/"
-    data = {
-        "username": username,
-        "password": password
-    }
-    response = requests.post(auth_url, json=data)
-    if response.status_code == 200:
-        session.cookies.update(response.cookies)
-        return session
-    else:
-        raise Exception(f"Ошибка авторизации: {response.status_code}, {response.text}")
-
-
-def get_clients(session):
-    response = session.get(GET_INBOUNDS_URL)
-    if response.status_code == 200:
-        return response.json()  # Возвращает данные по инбаундам и клиентам
-    else:
-        raise Exception(f"Ошибка при получении клиентов: {response.status_code}, {response.text}")
-
-def link(session, client_id: str, email: str):
-    """
-    Получение ссылки для подключения по ID клиента.
-    :param session: requests.Session - авторизованная сессия
-    :param client_id: str - идентификатор клиента
-    :return: str - ссылка для подключения
-    """
-    response = get_clients(session)
-    
-    if 'obj' not in response or len(response['obj']) == 0:
-        raise Exception("Не удалось получить данные клиентов.")
-    
-    inbounds = response['obj'][0]
-    settings = json.loads(inbounds['settings'])
-    
-    # Найти клиентский ID в настройках
-    stream_settings = json.loads(inbounds['streamSettings'])
-    tcp = stream_settings.get('network', 'tcp')
-    reality = stream_settings.get('security', 'reality')
-    flow = stream_settings.get('flow', 'xtls-rprx-vision')
-    
-    # Создание ссылки для подключения VLESS
-    val = f"vless://{client_id}@solonet.pocomacho.ru:443?type={tcp}&security={reality}&pbk=Ik3cfHdM5RXYCuzTxhaFfo58Fzwjvw11AtKsz5-izxA&fp=chrome&sni=discord.com&sid=6fc9&spx=%2F&flow={flow}#SoloNet_DE-{email}"
-    return val
-

backup.py

@@ -0,0 +1,164 @@
+import os
+import subprocess
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional, Tuple, Union
+
+import aiofiles
+from aiogram.types import BufferedInputFile
+
+from bot import bot
+from config import ADMIN_ID, BACK_DIR, DB_NAME, DB_PASSWORD, DB_USER, PG_HOST, PG_PORT
+from logger import logger
+
+
+async def backup_database() -> Exception | None:
+    """
+    Создает резервную копию базы данных и отправляет ее администраторам.
+
+    Returns:
+        Optional[Exception]: Исключение в случае ошибки или None при успешном выполнении
+    """
+    backup_file_path, exception = _create_database_backup()
+
+    if exception:
+        logger.error(f"Ошибка при создании бэкапа базы данных: {exception}")
+        return exception
+
+    try:
+        await _send_backup_to_admins(backup_file_path)
+        exception = _cleanup_old_backups()
+
+        if exception:
+            logger.error(f"Ошибка при удалении старых бэкапов базы данных: {exception}")
+            return exception
+
+        return None
+    except Exception as e:
+        logger.error(f"Ошибка при отправке бэкапа базы данных: {e}")
+        return e
+
+
+def _create_database_backup() -> tuple[str | None, Exception | None]:
+    """
+    Создает резервную копию базы данных PostgreSQL.
+
+    Returns:
+        Tuple[Optional[str], Optional[Exception]]: Путь к файлу бэкапа и исключение (если произошла ошибка)
+    """
+    date_formatted = datetime.now().strftime("%Y-%m-%d-%H%M%S")
+
+    # Создаем директорию для бэкапов, если она не существует
+    backup_dir = Path(BACK_DIR)
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    filename = backup_dir / f"{DB_NAME}-backup-{date_formatted}.sql"
+
+    try:
+        # Устанавливаем пароль PostgreSQL через переменную окружения
+        os.environ["PGPASSWORD"] = DB_PASSWORD
+
+        # Запускаем pg_dump для создания бэкапа
+        subprocess.run(
+            [
+                "pg_dump",
+                "-U",
+                DB_USER,
+                "-h",
+                PG_HOST,
+                "-p",
+                PG_PORT,
+                "-F",
+                "c",
+                "-f",
+                str(filename),
+                DB_NAME,
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        logger.info(f"Бэкап базы данных создан: {filename}")
+        return str(filename), None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Ошибка при выполнении pg_dump: {e.stderr}")
+        return None, e
+    except Exception as e:
+        logger.error(f"Непредвиденная ошибка при создании бэкапа: {e}")
+        return None, e
+    finally:
+        # Удаляем переменную окружения с паролем
+        if "PGPASSWORD" in os.environ:
+            del os.environ["PGPASSWORD"]
+
+
+def _cleanup_old_backups() -> Exception | None:
+    """
+    Удаляет бэкапы старше 3 дней.
+
+    Returns:
+        Optional[Exception]: Исключение в случае ошибки или None при успешном выполнении
+    """
+    try:
+        backup_dir = Path(BACK_DIR)
+        if not backup_dir.exists():
+            return None
+
+        # Вычисляем дату, старше которой нужно удалить файлы
+        cutoff_date = datetime.now() - timedelta(days=3)
+
+        # Находим и удаляем старые файлы бэкапов
+        for backup_file in backup_dir.glob("*.sql"):
+            if backup_file.is_file():
+                file_mtime = datetime.fromtimestamp(backup_file.stat().st_mtime)
+                if file_mtime < cutoff_date:
+                    backup_file.unlink()
+                    logger.info(f"Удален старый бэкап: {backup_file}")
+
+        logger.info("Очистка старых бэкапов завершена")
+        return None
+    except Exception as e:
+        logger.error(f"Ошибка при удалении старых бэкапов: {e}")
+        return e
+
+
+async def create_backup_and_send_to_admins(client) -> None:
+    """
+    Создает бэкап и отправляет администраторам через переданный клиент.
+
+    Args:
+        client: Клиент для работы с базой данных
+    """
+    await client.login()
+    await client.database.export()
+
+
+async def _send_backup_to_admins(backup_file_path: str) -> None:
+    """
+    Отправляет файл бэкапа всем администраторам через Telegram.
+
+    Args:
+        backup_file_path: Путь к файлу бэкапа
+
+    Raises:
+        Exception: При ошибке отправки файла
+    """
+    if not backup_file_path or not os.path.exists(backup_file_path):
+        raise FileNotFoundError(f"Файл бэкапа не найден: {backup_file_path}")
+
+    try:
+        async with aiofiles.open(backup_file_path, "rb") as backup_file:
+            backup_data = await backup_file.read()
+            filename = os.path.basename(backup_file_path)
+            backup_input_file = BufferedInputFile(file=backup_data, filename=filename)
+
+            # Отправляем файл каждому администратору
+            for admin_id in ADMIN_ID:
+                try:
+                    await bot.send_document(chat_id=admin_id, document=backup_input_file)
+                    logger.info(f"Бэкап базы данных отправлен админу: {admin_id}")
+                except Exception as e:
+                    logger.error(f"Не удалось отправить бэкап админу {admin_id}: {e}")
+    except Exception as e:
+        logger.error(f"Ошибка при отправке бэкапа в Telegram: {e}")
+        raise

bot.py

@@ -1,27 +1,91 @@
-from aiogram import Bot, Dispatcher, Router
+import traceback
+
+from aiogram import Bot, Dispatcher
+from aiogram.client.default import DefaultBotProperties
+from aiogram.enums import ParseMode
+from aiogram.exceptions import TelegramBadRequest, TelegramForbiddenError
+from aiogram.filters import ExceptionTypeFilter
 from aiogram.fsm.storage.memory import MemoryStorage
+from aiogram.types import BufferedInputFile, ErrorEvent
+from aiogram.utils.markdown import hbold
 
-from auth import login_with_credentials
+from config import ADMIN_ID, API_TOKEN
-from config import API_TOKEN
+from filters.private import IsPrivateFilter
+from logger import logger
+from middlewares import register_middleware
 
-bot = Bot(token=API_TOKEN)
+bot = Bot(token=API_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTML))
 storage = MemoryStorage()
 dp = Dispatcher(bot=bot, storage=storage)
-router = Router()
 
-from handlers import balance, keys, notifications, pay, profile, start
+version = "4.0"
-from key_management import router as key_management_router
 
-# Регистрация обработчиков
+register_middleware(dp)
-dp.include_router(start.router)
+
-dp.include_router(profile.router)
+dp.message.filter(IsPrivateFilter())
-dp.include_router(keys.router)
+dp.callback_query.filter(IsPrivateFilter())
-dp.include_router(balance.router)
-dp.include_router(key_management_router)
-dp.include_router(pay.router)
-dp.include_router(notifications.router)
 
 
+@dp.errors(ExceptionTypeFilter(Exception))
+async def errors_handler(
+    event: ErrorEvent,
+    bot: Bot,
+) -> bool:
+    if isinstance(event.exception, TelegramForbiddenError):
+        logger.info(f"User {event.update.message.from_user.id} заблокировал бота.")
+        return True
 
-async def on_startup(dispatcher: Dispatcher):
+    if isinstance(event.exception, TelegramBadRequest):
-    await login_with_credentials()
+        error_message = str(event.exception)
+
+        if (
+            "query is too old and response timeout expired or query ID is invalid" in error_message
+            or "message can't be deleted for everyone" in error_message
+            or "message to delete not found" in error_message
+        ):
+            logger.warning("Отправляем стартовое меню.")
+
+            try:
+                from handlers.start import handle_start_callback_query, start_command
+
+                if event.update.message:
+                    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
+                    )
+            except Exception as e:
+                logger.error(f"Ошибка при показе стартового меню после ошибки: {e}")
+
+            return True
+    logger.exception(f"Update: {event.update}\nException: {event.exception}")
+    if not ADMIN_ID:
+        return True
+    try:
+        for admin_id in ADMIN_ID:
+            await bot.send_document(
+                chat_id=admin_id,
+                document=BufferedInputFile(
+                    traceback.format_exc().encode(),
+                    filename=f"error_{event.update.update_id}.txt",
+                ),
+                caption=f"{hbold(type(event.exception).__name__)}: {str(event.exception)[:1021]}...",
+            )
+        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
+                )
+        except Exception as e:
+            logger.error(f"Ошибка при показе стартового меню после ошибки: {e}")
+    except TelegramBadRequest as exception:
+        logger.warning(f"Failed to send error details: {exception}")
+    except Exception as exception:
+        logger.error(f"Unexpected error in error handler: {exception}")
+    return True

client.py

@@ -1,124 +1,227 @@
-import json
+from dataclasses import dataclass
+from typing import Any
 
-from config import API_URL
+import py3xui
+
+from config import LIMIT_IP, SUPERNODE
+from logger import logger
 
 
-def add_client(session, client_id: str, email: str, tg_id: str, limit_ip: int, total_gb: int, expiry_time: int, enable: bool, flow: str):
+@dataclass
-    url = f'{API_URL}/panel/api/inbounds/addClient'
+class ClientConfig:
-    
+    """Конфигурация клиента для добавления/обновления."""
-    email = email.lower()
-    
-    client_data = {
-        "id": client_id,
-        "alterId": 0,
-        "email": email,
-        "limitIp": limit_ip,
-        "totalGB": total_gb,
-        "expiryTime": expiry_time,
-        "enable": enable,
-        "tgId": tg_id,
-        "subId": "",
-        "flow": flow,
-    }
-    
-    settings = json.dumps({"clients": [client_data]})
 
-    data = {
+    client_id: str
-        "id": 1,
+    email: str
-        "settings": settings
+    tg_id: str
-    }
+    limit_ip: int
+    total_gb: int
+    expiry_time: int
+    enable: bool
+    flow: str
+    inbound_id: int
+    sub_id: str
 
-    headers = {
-        'Content-Type': 'application/json',
-    }
-    
-    response = session.post(url, json=data, headers=headers)
-    
-    print(f"Запрос на добавление клиента: {data}")
-    print(f"Статус ответа: {response.status_code}")
-    print(f"Ответ от сервера: {response.text}")
 
-    if response.status_code == 200:
+async def add_client(xui: py3xui.AsyncApi, config: ClientConfig) -> dict[str, Any]:
-        print(f"Клиент добавлен: email={email}")
+    """
-        return response.json()
+    Добавляет клиента на сервер через 3x-ui.
-    else:
-        print(f"Ошибка при добавлении клиента: {response.status_code}, {response.text}")
 
-def extend_client_key(session, tg_id, client_id, email: str, new_expiry_time: int) -> bool:
+    Args:
-    response = session.get(f"{API_URL}/panel/api/inbounds/getClientTraffics/{email}")
+        xui: Экземпляр API клиента
-    print(f"GET {response.url} Status: {response.status_code}")
+        config: Конфигурация клиента
-    print(f"GET Response: {response.text}")
-    
-    if response.status_code != 200:
-        print(f"Ошибка при получении данных клиента: {response.status_code} - {response.text}")
-        return False
-    
-    client_data = response.json().get("obj", {})
-    print(client_data)
 
-    if not client_data:
+    Returns:
-        print("Не удалось получить данные клиента.")
+        Dict[str, Any]: Результат операции в формате
-        return False
+            {'status': 'success'|'failed'|'duplicate', 'error': str, 'email': str}
-
+    """
-    current_expiry_time = client_data.get('expiryTime', 0)
-    
-    if current_expiry_time == 0:
-        current_expiry_time = new_expiry_time
-
-    updated_expiry_time = max(current_expiry_time, new_expiry_time)
-
-    payload = {
-        "id": 1,
-        "settings": json.dumps({
-            "clients": [
-                {
-                    "id": client_id,
-                    "alterId": 0,
-                    "email": email.lower(),
-                    "limitIp": 2,
-                    "totalGB": 429496729600000,
-                    "expiryTime": updated_expiry_time,
-                    "enable": True,
-                    "tgId": tg_id,
-                    "subId": "",
-                    "flow": "xtls-rprx-vision"
-                }
-            ]
-        })
-    }
-    
-    headers = {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json'
-    }
-    
     try:
-        response = session.post(f"{API_URL}/panel/api/inbounds/updateClient/{client_id}", json=payload, headers=headers)
+        await xui.login()
-        print(f"POST {response.url} Status: {response.status_code}")
+
-        print(f"POST Request Data: {json.dumps(payload, indent=2)}")
+        client = py3xui.Client(
-        print(f"POST Response: {response.text}")
+            id=config.client_id,
-        
+            email=config.email.lower(),
-        if response.status_code == 200:
+            limit_ip=config.limit_ip,
-            return True
+            total_gb=config.total_gb,
-        else:
+            expiry_time=config.expiry_time,
-            print(f"Ошибка при продлении ключа: {response.status_code} - {response.text}")
+            enable=config.enable,
-            return False
+            tg_id=config.tg_id,
+            sub_id=config.sub_id,
+            flow=config.flow,
+        )
+
+        response = await xui.client.add(config.inbound_id, [client])
+        logger.info(f"Клиент {config.email} успешно добавлен с ID {config.client_id}")
+
+        return response if response else {"status": "failed"}
+
     except Exception as e:
-        print(f"Ошибка запроса: {e}")
+        error_message = str(e)
+        if "Duplicate email" in error_message:
+            logger.warning(f"Дублированный email: {config.email}. Пропуск. Сообщение: {error_message}")
+            return {"status": "duplicate", "email": config.email}
+
+        logger.error(f"Ошибка при добавлении клиента {config.email}: {error_message}")
+        return {"status": "failed", "error": error_message}
+
+
+async def extend_client_key(
+    xui: py3xui.AsyncApi, inbound_id: int, email: str, new_expiry_time: int, client_id: str, total_gb: int, sub_id: str
+) -> bool | None:
+    """
+    Обновляет срок действия ключа клиента.
+
+    Args:
+        xui: Экземпляр API клиента
+        inbound_id: ID входящего соединения
+        email: Email клиента
+        new_expiry_time: Новое время истечения
+        client_id: ID клиента
+        total_gb: Общий объем трафика
+        sub_id: ID подписки
+
+    Returns:
+        Optional[bool]: True если успешно, False если ошибка, None если клиент не найден
+    """
+    try:
+        await xui.login()
+        client = await xui.client.get_by_email(email)
+
+        if not client:
+            logger.warning(f"Клиент с email {email} не найден")
+            return None
+
+        if not client.id:
+            logger.warning(f"Ошибка: клиент {email} не имеет действительного ID")
+            return None
+
+        logger.info(f"Обновление ключа клиента {email} с ID {client.id} до {new_expiry_time}")
+
+        client.id = client_id
+        client.expiry_time = new_expiry_time
+        client.flow = "xtls-rprx-vision"
+        client.sub_id = sub_id
+        client.total_gb = total_gb
+        client.enable = True
+        client.limit_ip = LIMIT_IP
+        client.inbound_id = inbound_id
+
+        await xui.client.update(client.id, client)
+        await xui.client.reset_stats(inbound_id, email)
+        logger.info(f"Ключ клиента {email} успешно продлён до {new_expiry_time}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Ошибка при обновлении клиента с email {email}: {e}")
         return False
 
-def delete_client(session, client_id: str) -> bool:
+
-    url = f"{API_URL}/panel/api/inbounds/1/delClient/{client_id}"
+async def delete_client(
-    headers = {
+    xui: py3xui.AsyncApi,
-        'Accept': 'application/json'
+    inbound_id: int,
-    }
+    email: str,
+    client_id: str,
+) -> bool:
+    """
+    Удаляет клиента с сервера 3x-ui.
+
+    Args:
+        xui: Экземпляр API клиента
+        inbound_id: ID входящего соединения
+        email: Email клиента
+        client_id: ID клиента
+
+    Returns:
+        bool: True если удаление успешно, False в противном случае
+    """
     try:
-        response = session.post(url, headers=headers)
+        await xui.login()
-        if response.status_code == 200:
+
+        if SUPERNODE:
+            await xui.client.delete(inbound_id, client_id)
+            logger.info(f"Клиент с ID {client_id} был удален успешно (SUPERNODE)")
             return True
-        else:
+
-            print(f"Ошибка при удалении клиента: {response.status_code} - {response.text}")
+        client = await xui.client.get_by_email(email)
+        if not client:
+            logger.warning(f"Клиент с email {email} и ID {client_id} не найден")
             return False
+
+        client.id = client_id
+        await xui.client.delete(inbound_id, client.id)
+        logger.info(f"Клиент с ID {client_id} был удален успешно")
+        return True
+
     except Exception as e:
-        print(f"Ошибка запроса: {e}")
+        logger.error(f"Ошибка при удалении клиента с ID {client_id}: {e}")
-        return False
+        return False
+
+
+async def get_client_traffic(xui: py3xui.AsyncApi, client_id: str) -> dict[str, Any]:
+    """
+    Получает информацию о трафике пользователя по client_id.
+
+    Args:
+        xui: Экземпляр API клиента
+        client_id: UUID клиента
+
+    Returns:
+        dict[str, Any]: Информация о трафике пользователя или ошибка
+    """
+    try:
+        await xui.login()
+        traffic_data = await xui.client.get_traffic_by_id(client_id)
+
+        if not traffic_data:
+            logger.warning(f"Трафик для клиента {client_id} не найден.")
+            return {"status": "not_found", "client_id": client_id}
+
+        logger.info(f"Трафик для клиента {client_id} успешно получен.")
+        return {"status": "success", "client_id": client_id, "traffic": traffic_data}
+
+    except Exception as e:
+        logger.error(f"Ошибка при получении трафика клиента {client_id}: {e}")
+        return {"status": "error", "error": str(e)}
+
+
+async def toggle_client(xui: py3xui.AsyncApi, inbound_id: int, email: str, client_id: str, enable: bool = True) -> bool:
+    """
+    Функция для включения/отключения клиента на сервере 3x-ui.
+
+    Args:
+        xui: Экземпляр API клиента
+        inbound_id: ID инбаунда
+        email: Email клиента
+        client_id: UUID клиента
+        enable: True для включения, False для отключения
+
+    Returns:
+        bool: True при успешном выполнении, False при ошибке
+    """
+    try:
+        await xui.login()
+
+        # Получаем клиента по email
+        client = await xui.client.get_by_email(email)
+
+        if not client:
+            logger.warning(f"Клиент с email {email} и ID {client_id} не найден.")
+            return False
+
+        # Обновляем параметры клиента
+        client.enable = enable
+        client.id = client_id
+        client.flow = "xtls-rprx-vision"
+        client.limit_ip = LIMIT_IP
+        client.inbound_id = inbound_id
+
+        # Обновляем клиента
+        await xui.client.update(client.id, client)
+        status = "включен" if enable else "отключен"
+        logger.info(f"Клиент с email {email} и ID {client_id} успешно {status}.")
+        return True
+
+    except Exception as e:
+        status = "включении" if enable else "отключении"
+        logger.error(f"Ошибка при {status} клиента с email {email} и ID {client_id}: {e}")
+        return False

filters/admin.py

@@ -0,0 +1,12 @@
+from aiogram.filters import BaseFilter
+from aiogram.types import Message
+
+from config import ADMIN_ID
+
+
+class IsAdminFilter(BaseFilter):
+    async def __call__(self, message: Message) -> bool:
+        try:
+            return message.from_user.id in ADMIN_ID
+        except Exception:
+            return False

filters/private.py

@@ -0,0 +1,8 @@
+from aiogram.enums import ChatType
+from aiogram.filters import BaseFilter
+from aiogram.types import Chat, TelegramObject
+
+
+class IsPrivateFilter(BaseFilter):
+    async def __call__(self, event: TelegramObject, event_chat: Chat) -> bool:
+        return event_chat.type == ChatType.PRIVATE

handlers/__init__.py

@@ -0,0 +1,31 @@
+__all__ = ("router",)
+
+from aiogram import Router
+
+from .admin import router as admin_router
+from .captcha import router as captcha_router
+from .coupons import router as coupons_router
+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 .start import router as start_router
+
+router = Router(name="handlers_main_router")
+
+router.include_routers(
+    start_router,
+    captcha_router,
+    profile_router,
+    pay_router,
+    donate_router,
+    coupons_router,
+    notifications_router,
+    payments_router,
+    keys_router,
+    instructions_router,
+    admin_router,
+)

handlers/admin/__init__.py

@@ -0,0 +1,27 @@
+__all__ = ("router",)
+
+from aiogram import Router
+
+from .admin_backups import router as backups_router
+from .admin_bans import router as bans_router
+from .admin_coupons import router as coupons_router
+from .admin_panel import router as panel_router
+from .admin_restart import router as restart_router
+from .admin_sender import router as sender_router
+from .admin_servers import router as servers_router
+from .admin_stats import router as stats_router
+from .admin_users import router as users_router
+
+router = Router(name="admins_main_router")
+
+router.include_routers(
+    panel_router,
+    servers_router,
+    users_router,
+    stats_router,
+    backups_router,
+    sender_router,
+    coupons_router,
+    restart_router,
+    bans_router,
+)

handlers/admin/admin_backups.py

@@ -0,0 +1,29 @@
+from aiogram import F, Router
+from aiogram.types import CallbackQuery
+
+from backup import backup_database
+from filters.admin import IsAdminFilter
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb
+
+router = Router()
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "backups"),
+    IsAdminFilter(),
+)
+async def handle_backups(callback_query: CallbackQuery):
+    kb = build_admin_back_kb("management")
+
+    await callback_query.message.edit_text(
+        text="💾 Инициализация резервного копирования базы данных...", reply_markup=kb
+    )
+
+    exception = await backup_database()
+
+    if exception:
+        text = f"❌ Ошибка при создании резервной копии: {exception}"
+    else:
+        text = "✅ Резервная копия успешно создана и отправлена администраторам."
+
+    await callback_query.message.edit_text(text=text, reply_markup=kb)

handlers/admin/admin_bans.py

@@ -0,0 +1,92 @@
+from typing import Any
+
+from aiogram import F, Router
+from aiogram.types import BufferedInputFile, CallbackQuery
+
+from database import delete_user_data
+from filters.admin import IsAdminFilter
+from keyboards.admin.bans_kb import build_bans_kb
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb
+
+router = Router()
+
+
+@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(),
+    )
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "bans_export"),
+    IsAdminFilter(),
+)
+async def handle_bans_export(callback_query: CallbackQuery, session: Any):
+    kb = build_admin_back_kb("management")
+
+    try:
+        banned_users = await session.fetch("SELECT tg_id, blocked_at FROM blocked_users")
+
+        import csv
+        import io
+
+        csv_output = io.StringIO()
+        writer = csv.writer(csv_output)
+        writer.writerow(["tg_id", "blocked_at"])
+        for user in banned_users:
+            writer.writerow([user["tg_id"], user["blocked_at"]])
+
+        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",
+        )
+    except Exception as e:
+        await callback_query.message.answer(
+            text=f"❗ Произошла ошибка при экспорте: {e}",
+            reply_markup=kb,
+        )
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "bans_delete_banned"),
+    IsAdminFilter(),
+)
+async def handle_bans_delete_banned(callback_query: CallbackQuery, session: Any):
+    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]
+
+        if not blocked_ids:
+            await callback_query.message.answer(
+                text="📂 Нет заблокировавших пользователей для удаления.",
+                reply_markup=kb,
+            )
+            return
+
+        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 callback_query.message.answer(
+            text=f"🗑️ Удалены данные о {len(blocked_ids)} пользователях и связанных записях.",
+            reply_markup=kb,
+        )
+    except Exception as e:
+        await callback_query.message.answer(
+            text=f"❗ Произошла ошибка при удалении записей: {e}",
+            reply_markup=kb,
+        )

handlers/admin/admin_coupons.py

@@ -0,0 +1,172 @@
+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, Message
+
+from config import USERNAME_BOT
+from database import create_coupon, delete_coupon, get_all_coupons
+from filters.admin import IsAdminFilter
+from keyboards.admin.coupons_kb import AdminCouponDeleteCallback, build_coupons_kb, build_coupons_list_kb
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb
+from logger import logger
+
+router = Router()
+
+
+class AdminCouponsState(StatesGroup):
+    waiting_for_coupon_data = State()
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "coupons"),
+    IsAdminFilter(),
+)
+async def handle_coupons(
+    callback_query: CallbackQuery,
+):
+    await callback_query.message.edit_text(text="🛠 Меню управления купонами:", reply_markup=build_coupons_kb())
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "coupons_create"),
+    IsAdminFilter(),
+)
+async def handle_coupons_create(callback_query: CallbackQuery, state: FSMContext):
+    text = (
+        "🎫 <b>Введите данные для создания купона в формате:</b>\n\n"
+        "📝 <i>код</i> 💰 <i>сумма</i> 🔢 <i>лимит</i>\n\n"
+        "Пример: <b>'COUPON1 50 5'</b> 👈\n\n"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_admin_back_kb("coupons"),
+    )
+    await state.set_state(AdminCouponsState.waiting_for_coupon_data)
+
+
+@router.message(AdminCouponsState.waiting_for_coupon_data, IsAdminFilter())
+async def handle_coupon_data_input(message: Message, state: FSMContext, session: Any):
+    text = message.text.strip()
+    parts = text.split()
+
+    kb = build_admin_back_kb("coupons")
+
+    if len(parts) != 3:
+        text = (
+            "❌ <b>Некорректный формат!</b> 📝 Пожалуйста, введите данные в формате:\n"
+            "🏷️ <b>код</b> 💰 <b>сумма</b> 🔢 <b>лимит</b>\n"
+            "Пример: <b>'COUPON1 50 5'</b> 👈"
+        )
+
+        await message.answer(
+            text=text,
+            reply_markup=kb,
+        )
+        return
+
+    try:
+        coupon_code = parts[0]
+        coupon_amount = float(parts[1])
+        usage_limit = int(parts[2])
+    except ValueError:
+        text = "⚠️ <b>Проверьте правильность введенных данных!</b>\n💱 Сумма должна быть числом, а лимит — целым числом."
+
+        await message.answer(
+            text=text,
+            reply_markup=kb,
+        )
+        return
+
+    try:
+        await create_coupon(coupon_code, coupon_amount, usage_limit, session)
+
+        text = (
+            f"✅ Купон с кодом <b>{coupon_code}</b> успешно создан!\n"
+            f"💰 Сумма: <b>{coupon_amount} рублей</b> \n"
+            f"🔢 Лимит использования: <b>{usage_limit} раз</b>\n"
+            f"🔗 <b>Ссылка:</b> <code>https://t.me/{USERNAME_BOT}?start=coupons_{coupon_code}</code>\n"
+        )
+
+        await message.answer(text=text, reply_markup=kb)
+        await state.clear()
+
+    except Exception as e:
+        logger.error(f"Ошибка при создании купона: {e}")
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "coupons_list"),
+    IsAdminFilter(),
+)
+async def handle_coupons_list(callback_query: CallbackQuery, session: Any):
+    try:
+        data = AdminPanelCallback.unpack(callback_query.data)
+        page = data.page if data.page is not None else 1
+        per_page = 10
+        result = await get_all_coupons(session, page, per_page)
+        coupons = result["coupons"]
+
+        if not coupons:
+            await callback_query.message.edit_text(
+                text="❌ На данный момент нет доступных купонов!",
+                reply_markup=build_admin_back_kb("coupons"),
+            )
+            return
+
+        kb = build_coupons_list_kb(coupons, result["current_page"], result["pages"])
+        coupon_list = "📜 Список всех купонов:\n\n"
+        for coupon in coupons:
+            coupon_list += (
+                f"🏷️ <b>Код:</b> {coupon['code']}\n"
+                f"💰 <b>Сумма:</b> {coupon['amount']} рублей\n"
+                f"🔢 <b>Лимит использования:</b> {coupon['usage_limit']} раз\n"
+                f"✅ <b>Использовано:</b> {coupon['usage_count']} раз\n"
+                f"🔗 <b>Ссылка:</b> <code>https://t.me/{USERNAME_BOT}?start=coupons_{coupon['code']}</code>\n"
+            )
+        await callback_query.message.edit_text(text=coupon_list, reply_markup=kb)
+    except Exception as e:
+        logger.error(f"Ошибка при получении списка купонов: {e}")
+        await callback_query.message.answer("Произошла ошибка при получении списка купонов.")
+
+
+@router.callback_query(AdminCouponDeleteCallback.filter(), IsAdminFilter())
+async def handle_coupon_delete(callback_query: CallbackQuery, callback_data: AdminCouponDeleteCallback, session: Any):
+    coupon_code = callback_data.coupon_code
+    try:
+        result = await delete_coupon(coupon_code, session)
+        if result:
+            await callback_query.message.edit_text(f"Купон {coupon_code} удалён!")
+        else:
+            await callback_query.message.edit_text(f"❌ Купон с кодом {coupon_code} не найден.", show_alert=True)
+        await update_coupons_list(callback_query.message, session)
+    except Exception as e:
+        logger.error(f"Ошибка при удалении купона: {e}")
+        await callback_query.message.edit_text("Произошла ошибка при удалении купона.", show_alert=True)
+
+
+async def update_coupons_list(message, session: Any, page: int = 1):
+    per_page = 10
+    result = await get_all_coupons(session, page, per_page)
+    coupons = result["coupons"]
+
+    if not coupons:
+        await message.edit_text(
+            text="❌ На данный момент нет доступных купонов!",
+            reply_markup=build_admin_back_kb("coupons"),
+        )
+        return
+
+    kb = build_coupons_list_kb(coupons, result["current_page"], result["pages"])
+    coupon_list = "📜 Список всех купонов:\n\n"
+    for coupon in coupons:
+        coupon_list += (
+            f"🏷️ <b>Код:</b> {coupon['code']}\n"
+            f"💰 <b>Сумма:</b> {coupon['amount']} рублей\n"
+            f"🔢 <b>Лимит использования:</b> {coupon['usage_limit']} раз\n"
+            f"✅ <b>Использовано:</b> {coupon['usage_count']} раз\n"
+            f"🔗 <b>Ссылка:</b> <code>https://t.me/{USERNAME_BOT}?start=coupons_{coupon['code']}</code>\n"
+        )
+    await message.edit_text(text=coupon_list, reply_markup=kb)

handlers/admin/admin_panel.py

@@ -0,0 +1,48 @@
+from aiogram import F, Router
+from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+from aiogram.types import CallbackQuery, Message
+
+from bot import version
+from filters.admin import IsAdminFilter
+from keyboards.admin.panel_kb import AdminPanelCallback, build_management_kb, build_panel_kb
+
+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}"
+
+    await state.clear()
+
+    if callback_query.message.text:
+        await callback_query.message.edit_text(text=text, reply_markup=build_panel_kb())
+    else:
+        try:
+            await callback_query.message.delete()
+        except Exception as e:
+            print(f"Ошибка при удалении сообщения: {e}")
+
+        await callback_query.message.answer(text=text, reply_markup=build_panel_kb())
+
+
+@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)
+
+
+@router.message(Command("admin"), IsAdminFilter())
+async def handle_admin_message(message: Message, state: FSMContext):
+    text = f"🤖 Панель администратора\n📌 Версия бота: {version}"
+
+    await state.clear()
+    await message.answer(text=text, reply_markup=build_panel_kb())
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "management"), IsAdminFilter())
+async def handle_management(callback_query: CallbackQuery):
+    await callback_query.message.edit_text(
+        text="🤖 Управление ботом",
+        reply_markup=build_management_kb(),
+    )

handlers/admin/admin_restart.py

@@ -0,0 +1,40 @@
+import subprocess
+
+from aiogram import F, Router
+from aiogram.types import CallbackQuery
+
+from filters.admin import IsAdminFilter
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb, build_restart_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):
+    kb = build_admin_back_kb()
+    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)
+    except Exception as e:
+        await callback_query.message.edit_text(text=f"⚠️ Ошибка при перезагрузке бота: {e.stderr}", reply_markup=kb)

handlers/admin/admin_sender.py

@@ -0,0 +1,140 @@
+from datetime import datetime
+from typing import Any
+
+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 filters.admin import IsAdminFilter
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb
+from keyboards.admin.sender_kb import AdminSenderCallback, build_clusters_kb, build_sender_kb
+from logger import logger
+
+router = Router()
+
+
+class AdminSender(StatesGroup):
+    waiting_for_message = State()
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "sender"),
+    IsAdminFilter(),
+)
+async def handle_sender(callback_query: CallbackQuery):
+    await callback_query.message.edit_text(
+        text="✍️ Выберите группу пользователей для рассылки:",
+        reply_markup=build_sender_kb(),
+    )
+
+
+@router.callback_query(
+    AdminSenderCallback.filter(F.type != "cluster-select"),
+    IsAdminFilter(),
+)
+async def handle_sender_callback_text(
+    callback_query: CallbackQuery, callback_data: AdminSenderCallback, state: FSMContext
+):
+    await callback_query.message.edit_text(
+        text="✍️ Введите текст сообщения для рассылки:",
+        reply_markup=build_admin_back_kb("sender"),
+    )
+    await state.update_data(type=callback_data.type, cluster_name=callback_data.data)
+    await state.set_state(AdminSender.waiting_for_message)
+
+
+@router.callback_query(
+    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")
+    await callback_query.message.answer(
+        "✍️ Выберите кластер для рассылки сообщений:",
+        reply_markup=build_clusters_kb(clusters),
+    )
+
+
+@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
+    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
+
+    if not text_message and not photo and not photo_url:
+        await message.answer("⚠ Ошибка! Отправьте текст или изображение для рассылки.")
+        return
+
+    state_data = await state.get_data()
+    send_to = state_data.get("type", "all")
+
+    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 == "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,
+        )
+    else:
+        tg_ids = await session.fetch("SELECT DISTINCT tg_id FROM connections")
+
+    total_users = len(tg_ids)
+    success_count = 0
+
+    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(text=text, reply_markup=build_admin_back_kb("stats"), parse_mode="HTML")
+
+    await state.clear()

handlers/admin/admin_servers.py

@@ -0,0 +1,491 @@
+import asyncio
+from typing import Any
+
+import asyncpg
+from aiogram import F, Router, types
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+from py3xui import AsyncApi
+
+from backup import create_backup_and_send_to_admins
+from config import ADMIN_PASSWORD, ADMIN_USERNAME, DATABASE_URL
+from database import check_unique_server_name, delete_server, get_servers
+from filters.admin import IsAdminFilter
+from handlers.keys.key_utils import create_key_on_cluster
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb
+from keyboards.admin.servers_kb import (
+    AdminServerEditorCallback,
+    build_clusters_editor_kb,
+    build_delete_server_kb,
+    build_manage_cluster_kb,
+    build_manage_server_kb,
+)
+from logger import logger
+
+router = Router()
+
+
+class AdminServersEditor(StatesGroup):
+    waiting_for_cluster_name = State()
+    waiting_for_api_url = State()
+    waiting_for_inbound_id = State()
+    waiting_for_server_name = State()
+    waiting_for_subscription_url = State()
+    waiting_for_new_domain = State()
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "servers"),
+    IsAdminFilter(),
+)
+async def handle_servers(callback_query: CallbackQuery):
+    servers = await get_servers()
+
+    text = (
+        "<b>🔧 Управление кластерами</b>\n\n"
+        "<i>📌 Здесь вы можете добавить новый кластер.</i>\n\n"
+        "<i>🌐 <b>Кластеры</b> — это пространство серверов, в пределах которого создается подписка.</i>\n"
+        "💡 Если вы хотите выдавать по 1 серверу, то добавьте всего 1 сервер в кластер.\n\n"
+        "<i>⚠️ <b>Важно:</b> Кластеры удаляются автоматически, если удалить все серверы внутри них.</i>\n\n"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_clusters_editor_kb(servers),
+    )
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "clusters_add"),
+    IsAdminFilter(),
+)
+async def handle_clusters_add(callback_query: CallbackQuery, state: FSMContext):
+    text = (
+        "🔧 <b>Введите имя нового кластера:</b>\n\n"
+        "<b>Имя кластера должно быть уникальным!</b>\n"
+        "<i>Пример:</i> <code>cluster1</code> или <code>us_east_1</code>"
+    )
+
+    await callback_query.message.edit_text(text=text, reply_markup=build_admin_back_kb("servers"))
+
+    await state.set_state(AdminServersEditor.waiting_for_cluster_name)
+
+
+@router.message(AdminServersEditor.waiting_for_cluster_name, IsAdminFilter())
+async def handle_cluster_name_input(message: Message, state: FSMContext):
+    if not message.text:
+        await message.answer(
+            text="❌ Имя кластера не может быть пустым. Попробуйте снова.", reply_markup=build_admin_back_kb("servers")
+        )
+        return
+
+    cluster_name = message.text.strip()
+    await state.update_data(cluster_name=cluster_name)
+
+    text = (
+        f"<b>Введите имя сервера для кластера {cluster_name}:</b>\n\n"
+        "Рекомендуется указать локацию и номер сервера в имени.\n\n"
+        "<i>Пример:</i> <code>de1</code>, <code>fra1</code>, <code>fi2</code>"
+    )
+
+    await message.answer(
+        text=text,
+        reply_markup=build_admin_back_kb("servers"),
+    )
+
+    await state.set_state(AdminServersEditor.waiting_for_server_name)
+
+
+@router.message(AdminServersEditor.waiting_for_server_name, IsAdminFilter())
+async def handle_server_name_input(message: Message, state: FSMContext, session: Any):
+    if not message.text:
+        await message.answer(
+            text="❌ Имя сервера не может быть пустым. Попробуйте снова.", reply_markup=build_admin_back_kb("servers")
+        )
+        return
+
+    server_name = message.text.strip()
+
+    if len(server_name) > 14:
+        await message.answer(
+            text="❌ Имя сервера не должно превышать 10 символов. Попробуйте снова.",
+            reply_markup=build_admin_back_kb("servers"),
+        )
+        return
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+
+    if not await check_unique_server_name(server_name, session, cluster_name):
+        await message.answer(
+            text="❌ Сервер с таким именем уже существует. Пожалуйста, выберите другое имя.",
+            reply_markup=build_admin_back_kb("servers"),
+        )
+        return
+
+    await state.update_data(server_name=server_name)
+
+    text = (
+        f"<b>Введите API URL для сервера {server_name} в кластере {cluster_name}:</b>\n\n"
+        "API URL должен быть в следующем формате:\n\n"
+        "<code>https://your_domain:port/panel_path</code>\n\n"
+        "URL должен быть без слэша на конце!\n"
+    )
+
+    await message.answer(
+        text=text,
+        reply_markup=build_admin_back_kb("servers"),
+    )
+
+    await state.set_state(AdminServersEditor.waiting_for_api_url)
+
+
+@router.message(AdminServersEditor.waiting_for_api_url, IsAdminFilter())
+async def handle_api_url_input(message: Message, state: FSMContext, session: Any):
+    if not message.text or not message.text.strip().startswith("https://"):
+        await message.answer(
+            text="❌ API URL должен начинаться с <code>https://</code>. Попробуйте снова.",
+            reply_markup=build_admin_back_kb("servers"),
+        )
+        return
+
+    api_url = message.text.strip().rstrip("/")
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+    server_name = user_data.get("server_name")
+    await state.update_data(api_url=api_url)
+
+    text = (
+        f"<b>Введите subscription_url для сервера {server_name} в кластере {cluster_name}:</b>\n\n"
+        "Subscription URL должен быть в следующем формате:\n\n"
+        "<code>https://your_domain:port_sub/sub_path</code>\n\n"
+        "URL должен быть без слэша и имени клиента на конце!\n"
+        "Его можно увидеть в панели 3x-ui в информации о клиенте."
+    )
+
+    await message.answer(
+        text=text,
+        reply_markup=build_admin_back_kb("servers"),
+    )
+
+    await state.set_state(AdminServersEditor.waiting_for_subscription_url)
+
+
+@router.message(AdminServersEditor.waiting_for_subscription_url, IsAdminFilter())
+async def handle_subscription_url_input(message: Message, state: FSMContext):
+    if not message.text or not message.text.strip().startswith("https://"):
+        await message.answer(
+            text="❌ subscription_url должен начинаться с <code>https://</code>. Попробуйте снова.",
+            reply_markup=build_admin_back_kb("servers"),
+        )
+        return
+
+    subscription_url = message.text.strip().rstrip("/")
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+    server_name = user_data.get("server_name")
+    await state.update_data(subscription_url=subscription_url)
+
+    text = (
+        f"<b>Введите inbound_id для сервера {server_name} в кластере {cluster_name}:</b>\n\n"
+        "Это номер подключения vless в вашей панели 3x-ui. Обычно это <b>1</b> при чистой настройке по гайду.\n\n"
+    )
+
+    await message.answer(
+        text=text,
+        reply_markup=build_admin_back_kb("servers"),
+    )
+    await state.set_state(AdminServersEditor.waiting_for_inbound_id)
+
+
+@router.message(AdminServersEditor.waiting_for_inbound_id, IsAdminFilter())
+async def handle_inbound_id_input(message: Message, state: FSMContext):
+    inbound_id = message.text.strip()
+
+    if not inbound_id.isdigit():
+        await message.answer(
+            text="❌ inbound_id должен быть числовым значением. Попробуйте снова.",
+            reply_markup=build_admin_back_kb("servers"),
+        )
+        return
+
+    user_data = await state.get_data()
+    cluster_name = user_data.get("cluster_name")
+    server_name = user_data.get("server_name")
+    api_url = user_data.get("api_url")
+    subscription_url = user_data.get("subscription_url")
+
+    conn = await asyncpg.connect(DATABASE_URL)
+    await conn.execute(
+        """
+        INSERT INTO servers (cluster_name, server_name, api_url, subscription_url, inbound_id) 
+        VALUES ($1, $2, $3, $4, $5)
+        """,
+        cluster_name,
+        server_name,
+        api_url,
+        subscription_url,
+        inbound_id,
+    )
+    await conn.close()
+
+    await message.answer(
+        text=f"✅ Кластер {cluster_name} и сервер {server_name} успешно добавлены!",
+        reply_markup=build_admin_back_kb("servers"),
+    )
+
+    await state.clear()
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "clusters_manage"), IsAdminFilter())
+async def handle_clusters_manage(
+    callback_query: types.CallbackQuery, callback_data: AdminServerEditorCallback, session: Any
+):
+    cluster_name = callback_data.data
+
+    servers = await get_servers(session)
+    cluster_servers = servers.get(cluster_name, [])
+
+    await callback_query.message.edit_text(
+        text=f"🔧 Управление серверами для кластера {cluster_name}",
+        reply_markup=build_manage_cluster_kb(cluster_servers, cluster_name),
+    )
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "servers_availability"), IsAdminFilter())
+async def handle_servers_availability(
+    callback_query: types.CallbackQuery, callback_data: AdminServerEditorCallback, session: Any
+):
+    cluster_name = callback_data.data
+
+    servers = await get_servers(session)
+    cluster_servers = servers.get(cluster_name, [])
+
+    if not cluster_servers:
+        await callback_query.message.edit_text(text=f"Кластер '{cluster_name}' не содержит серверов.")
+        return
+
+    text = (
+        f"🖥️ Проверка доступности серверов для кластера {cluster_name}.\n\n"
+        "Это может занять до 1 минуты, пожалуйста, подождите..."
+    )
+
+    await callback_query.message.edit_text(text=text)
+
+    result_text = f"🖥️ Проверка доступности серверов для кластера {cluster_name} завершена:\n\n"
+    total_online_users = 0
+
+    for server in cluster_servers:
+        xui = AsyncApi(server["api_url"], username=ADMIN_USERNAME, password=ADMIN_PASSWORD)
+
+        try:
+            await xui.login()
+            online_users = len(await xui.client.online())
+            total_online_users += online_users
+            result_text += f"🌍 {server['server_name']}: {online_users} активных пользователей.\n"
+
+        except Exception as e:
+            result_text += f"❌ {server['server_name']}: Не удалось получить информацию. Ошибка: {e}\n"
+
+    result_text += f"\n👥 Общее количество активных пользователей в кластере: {total_online_users}."
+
+    await callback_query.message.edit_text(text=result_text, reply_markup=build_admin_back_kb("servers"))
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "servers_manage"), IsAdminFilter())
+async def handle_servers_manage(callback_query: CallbackQuery, callback_data: AdminServerEditorCallback):
+    server_name = callback_data.data
+    servers = await get_servers()
+
+    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 server:
+        api_url = server["api_url"]
+        subscription_url = server["subscription_url"]
+        inbound_id = server["inbound_id"]
+
+        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}"
+        )
+
+        await callback_query.message.edit_text(
+            text=text,
+            reply_markup=build_manage_server_kb(server_name, cluster_name),
+        )
+    else:
+        await callback_query.message.edit_text(text="❌ Сервер не найден.")
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "servers_delete"), IsAdminFilter())
+async def handle_servers_delete(callback_query: CallbackQuery, callback_data: AdminServerEditorCallback):
+    server_name = callback_data.data
+
+    await callback_query.message.edit_text(
+        text=f"🗑️ Вы уверены, что хотите удалить сервер {server_name}?",
+        reply_markup=build_delete_server_kb(server_name),
+    )
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "servers_delete_confirm"), IsAdminFilter())
+async def handle_servers_delete_confirm(
+    callback_query: types.CallbackQuery, callback_data: AdminServerEditorCallback, session: Any
+):
+    server_name = callback_data.data
+
+    await delete_server(server_name, session)
+
+    await callback_query.message.edit_text(
+        text=f"🗑️ Сервер {server_name} успешно удален.", reply_markup=build_admin_back_kb("servers")
+    )
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "servers_add"), IsAdminFilter())
+async def handle_servers_add(
+    callback_query: types.CallbackQuery, callback_data: AdminServerEditorCallback, state: FSMContext
+):
+    cluster_name = callback_data.data
+
+    await state.update_data(cluster_name=cluster_name)
+
+    text = (
+        f"<b>Введите имя сервера для кластера {cluster_name}:</b>\n\n"
+        "Рекомендуется указать локацию сервера в имени.\n\n"
+        "<i>Пример:</i> <code>server-asia</code>, <code>server-europe</code>"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_admin_back_kb("servers"),
+    )
+
+    await state.set_state(AdminServersEditor.waiting_for_server_name)
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "clusters_backup"), IsAdminFilter())
+async def handle_clusters_backup(
+    callback_query: types.CallbackQuery, callback_data: AdminServerEditorCallback, session: Any
+):
+    cluster_name = callback_data.data
+
+    servers = await get_servers(session)
+    cluster_servers = servers.get(cluster_name, [])
+
+    for server in cluster_servers:
+        xui = AsyncApi(
+            server["api_url"],
+            username=ADMIN_USERNAME,
+            password=ADMIN_PASSWORD,
+        )
+        await create_backup_and_send_to_admins(xui)
+
+    text = (
+        f"<b>Бэкап для кластера {cluster_name} был успешно создан и отправлен администраторам!</b>\n\n"
+        f"🔔 <i>Бэкапы отправлены в боты панелей.</i>"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_admin_back_kb("servers"),
+    )
+
+
+@router.callback_query(AdminServerEditorCallback.filter(F.action == "clusters_sync"), IsAdminFilter())
+async def handle_clusters_sync(
+    callback_query: types.CallbackQuery, callback_data: AdminServerEditorCallback, session: Any
+):
+    cluster_name = callback_data.data
+
+    try:
+        query_keys = """
+                SELECT tg_id, client_id, email, expiry_time
+                FROM keys
+                WHERE server_id = $1
+            """
+        keys_to_sync = await session.fetch(query_keys, cluster_name)
+
+        if not keys_to_sync:
+            await callback_query.message.answer(
+                text=f"❌ Нет ключей для синхронизации в кластере {cluster_name}.",
+                reply_markup=build_admin_back_kb("servers"),
+            )
+            return
+
+        for key in keys_to_sync:
+            try:
+                await create_key_on_cluster(
+                    cluster_name,
+                    key["tg_id"],
+                    key["client_id"],
+                    key["email"],
+                    key["expiry_time"],
+                )
+                await asyncio.sleep(0.6)
+            except Exception as e:
+                logger.error(f"Ошибка при добавлении ключа {key['client_id']} в кластер {cluster_name}: {e}")
+
+        await callback_query.message.answer(
+            text=f"✅ Ключи успешно синхронизированы для кластера {cluster_name}",
+            reply_markup=build_admin_back_kb("servers"),
+        )
+    except Exception as e:
+        logger.error(f"Ошибка синхронизации ключей в кластере {cluster_name}: {e}")
+        await callback_query.message.answer(
+            text=f"❌ Произошла ошибка при синхронизации: {e}", reply_markup=build_admin_back_kb("servers")
+        )
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "change_domain"), IsAdminFilter())
+async def request_new_domain(callback_query: CallbackQuery, state: FSMContext):
+    """Запрашивает у администратора новый домен."""
+    await state.set_state(AdminServersEditor.waiting_for_new_domain)
+    await callback_query.message.edit_text(
+        text="🌐 Введите новый домен (без https://):\nПример: pocomachodomen.ru",
+    )
+
+
+@router.message(AdminServersEditor.waiting_for_new_domain)
+async def process_new_domain(message: Message, state: FSMContext, session: asyncpg.Connection):
+    """Обновляет домен в таблице 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():
+        logger.warning("[DomainChange] Некорректный домен")
+        await message.answer(
+            "🚫 Некорректный домен! Введите домен без http:// и без пробелов.",
+            reply_markup=build_admin_back_kb("admin"),
+        )
+        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)
+        logger.info("[DomainChange] Запрос на обновление домена выполнен успешно.")
+    except Exception as e:
+        logger.error(f"[DomainChange] Ошибка при выполнении запроса: {e}")
+        await message.answer(f"❌ Ошибка при обновлении домена: {e}", reply_markup=build_admin_back_kb("admin"))
+        return
+
+    try:
+        sample = await session.fetchrow("SELECT key FROM keys LIMIT 1")
+        logger.info(f"[DomainChange] Пример обновленной записи: {sample}")
+    except Exception as e:
+        logger.error(f"[DomainChange] Ошибка при выборке обновленной записи: {e}")
+
+    await message.answer(f"✅ Домен успешно изменен на {new_domain}!", reply_markup=build_admin_back_kb("admin"))
+    await state.clear()

handlers/admin/admin_stats.py

@@ -0,0 +1,120 @@
+from datetime import datetime
+from typing import Any
+
+import pytz
+from aiogram import F, Router
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.types import CallbackQuery
+
+from filters.admin import IsAdminFilter
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb
+from keyboards.admin.stats_kb import build_stats_kb
+from logger import logger
+from utils.csv_export import export_payments_csv, export_users_csv
+
+router = Router()
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "stats"),
+    IsAdminFilter(),
+)
+async def handle_stats(callback_query: CallbackQuery, session: Any):
+    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_all_time = int(await session.fetchval("SELECT COALESCE(SUM(amount), 0) FROM payments"))
+
+        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")
+
+        stats_message = (
+            f"📊 <b>Подробная статистика проекта:</b>\n\n"
+            f"👥 Пользователи:\n"
+            f"   📅 За день: <b>{registrations_today}</b>\n"
+            f"   📆 За неделю: <b>{registrations_week}</b>\n"
+            f"   📆 За месяц: <b>{registrations_month}</b>\n"
+            f"   🌐 За все время: <b>{total_users}</b>\n\n"
+            f"🌟 Активные пользователи:\n"
+            f"   🌟 Активных сегодня: <b>{users_updated_today}</b>\n\n"
+            f"👥 Рефералы:\n"
+            f"   🤝 Всего привлечено: <b>{total_referrals}</b>\n\n"
+            f"🔑 Ключи:\n"
+            f"   🌈 Всего сгенерировано: <b>{total_keys}</b>\n"
+            f"   ✅ Действующих: <b>{active_keys}</b>\n"
+            f"   ❌ Просроченных: <b>{expired_keys}</b>\n\n"
+            f"💰 Финансовая статистика:\n"
+            f"   📅 За день: <b>{total_payments_today} ₽</b>\n"
+            f"   📆 За неделю: <b>{total_payments_week} ₽</b>\n"
+            f"   📆 За месяц: <b>{total_payments_month} ₽</b>\n"
+            f"   🏦 За все время: <b>{total_payments_all_time} ₽</b>\n\n"
+            f" ⏳ Последнее обновление: {update_time}"
+        )
+
+        await callback_query.message.edit_text(text=stats_message, reply_markup=build_stats_kb())
+    except TelegramBadRequest as e:
+        if "message is not modified" not in str(e):  # skip when Telegram message is not modified
+            logger.error(f"Error in user_stats_menu: {e}")
+    except Exception as e:
+        logger.error(f"Error in user_stats_menu: {e}")
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "stats_export_users_csv"),
+    IsAdminFilter(),
+)
+async def handle_export_users_csv(callback_query: CallbackQuery, session: Any):
+    kb = build_admin_back_kb("stats")
+
+    try:
+        export = await export_users_csv(session)
+        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)
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "stats_export_payments_csv"),
+    IsAdminFilter(),
+)
+async def handle_export_payments_csv(callback_query: CallbackQuery, session: Any):
+    kb = build_admin_back_kb("stats")
+
+    try:
+        export = await export_payments_csv(session)
+        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)

handlers/admin/admin_users.py

@@ -0,0 +1,717 @@
+import asyncio
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import pytz
+from aiogram import F, Router, types
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, Message
+
+from config import TOTAL_GB
+from database import (
+    delete_key,
+    delete_user_data,
+    get_balance,
+    get_client_id_by_email,
+    get_servers,
+    update_balance,
+    update_key_expiry,
+    update_trial,
+)
+from filters.admin import IsAdminFilter
+from handlers.keys.key_utils import delete_key_from_cluster, get_user_traffic, renew_key_in_cluster, update_subscription
+from handlers.utils import sanitize_key_name
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_kb
+from keyboards.admin.users_kb import (
+    AdminUserEditorCallback,
+    AdminUserKeyEditorCallback,
+    build_editor_kb,
+    build_key_delete_kb,
+    build_key_edit_kb,
+    build_user_delete_kb,
+    build_user_edit_kb,
+    build_user_key_kb,
+    build_users_balance_change_kb,
+    build_users_balance_kb,
+    build_users_key_expiry_kb,
+    build_users_key_show_kb,
+)
+from logger import logger
+
+MOSCOW_TZ = pytz.timezone("Europe/Moscow")
+
+router = Router()
+
+
+class UserEditorState(StatesGroup):
+    # search
+    waiting_for_user_data = State()
+    waiting_for_key_name = State()
+    # updating data
+    waiting_for_balance = State()
+    waiting_for_expiry_time = State()
+    waiting_for_message_text = State()
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "search_user"),
+    IsAdminFilter(),
+)
+async def handle_search_user(callback_query: CallbackQuery, state: FSMContext):
+    text = (
+        "<b>🔍 Поиск пользователя</b>"
+        "\n\n📌 Введите ID, Username или перешлите сообщение пользователя."
+        "\n\n🆔 ID - числовой айди"
+        "\n📝 Username - юзернейм пользователя"
+        "\n\n<i>✉️ Для поиска, вы можете просто переслать сообщение от пользователя.</i>"
+    )
+
+    await state.set_state(UserEditorState.waiting_for_user_data)
+    await callback_query.message.edit_text(text=text, reply_markup=build_admin_back_kb())
+
+
+@router.callback_query(
+    AdminPanelCallback.filter(F.action == "search_key"),
+    IsAdminFilter(),
+)
+async def handle_search_key(callback_query: CallbackQuery, state: FSMContext):
+    await state.set_state(UserEditorState.waiting_for_key_name)
+    await callback_query.message.edit_text(text="🔑 Введите имя ключа для поиска:", reply_markup=build_admin_back_kb())
+
+
+@router.message(UserEditorState.waiting_for_user_data, IsAdminFilter())
+async def handle_user_data_input(message: Message, state: FSMContext, session: Any):
+    kb = build_admin_back_kb()
+
+    if message.forward_from:
+        tg_id = message.forward_from.id
+        await process_user_search(message, state, session, tg_id)
+        return
+
+    if not message.text:
+        await message.answer(text="🚫 Пожалуйста, отправьте текстовое сообщение.", reply_markup=kb)
+        return
+
+    if message.text.isdigit():
+        tg_id = int(message.text)
+    else:
+        # Удаление '@' символа в начале сообщения
+        username = message.text.strip().lstrip("@")
+        # Удаление начала ссылки на профиль
+        username = username.replace("https://t.me/", "")
+
+        user = await session.fetchrow("SELECT tg_id FROM users WHERE username = $1", username)
+
+        if not user:
+            await message.answer(
+                text="🚫 Пользователь с указанным Username не найден!",
+                reply_markup=kb,
+            )
+            return
+
+        tg_id = user["tg_id"]
+
+    await process_user_search(message, state, session, tg_id)
+
+
+@router.message(UserEditorState.waiting_for_key_name, IsAdminFilter())
+async def handle_key_name_input(message: Message, state: FSMContext, session: Any):
+    kb = build_admin_back_kb()
+
+    if not message.text:
+        await message.answer(text="🚫 Пожалуйста, отправьте текстовое сообщение.", reply_markup=kb)
+        return
+
+    key_name = sanitize_key_name(message.text)
+    key_details = await get_key_details(key_name, session)
+
+    if not key_details:
+        await message.answer(text="🚫 Пользователь с указанным именем ключа не найден.", reply_markup=kb)
+        return
+
+    await process_user_search(message, state, session, key_details["tg_id"])
+
+
+@router.callback_query(
+    AdminUserEditorCallback.filter(F.action == "users_send_message"),
+    IsAdminFilter(),
+)
+async def handle_send_message(
+    callback_query: types.CallbackQuery, callback_data: AdminUserEditorCallback, state: FSMContext
+):
+    tg_id = callback_data.tg_id
+
+    await callback_query.message.edit_text(
+        text="✉️ Введите текст сообщения, которое вы хотите отправить пользователю:", reply_markup=build_editor_kb(tg_id)
+    )
+
+    await state.update_data(tg_id=tg_id)
+    await state.set_state(UserEditorState.waiting_for_message_text)
+
+
+@router.message(UserEditorState.waiting_for_message_text, IsAdminFilter())
+async def handle_message_text_input(message: Message, state: FSMContext):
+    data = await state.get_data()
+    tg_id = data.get("tg_id")
+
+    try:
+        await message.bot.send_message(chat_id=tg_id, text=message.text)
+        await message.answer(text="✅ Сообщение успешно отправлено.", reply_markup=build_editor_kb(tg_id))
+    except Exception as e:
+        await message.answer(text=f"❌ Не удалось отправить сообщение: {e}", reply_markup=build_editor_kb(tg_id))
+
+    await state.clear()
+
+
+@router.callback_query(
+    AdminUserEditorCallback.filter(F.action == "users_trial_restore"),
+    IsAdminFilter(),
+)
+async def handle_trial_restore(
+    callback_query: types.CallbackQuery, callback_data: AdminUserEditorCallback, session: Any
+):
+    tg_id = callback_data.tg_id
+
+    await update_trial(tg_id, 0, session)
+    await callback_query.message.edit_text(text="✅ Триал успешно восстановлен!", reply_markup=build_editor_kb(tg_id))
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_balance_edit"), IsAdminFilter())
+async def handle_balance_change(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, session: Any):
+    tg_id = callback_data.tg_id
+
+    records = await session.fetch(
+        """
+       SELECT amount, payment_system, status, created_at
+       FROM payments
+       WHERE tg_id = $1
+       ORDER BY created_at DESC
+       LIMIT 5
+       """,
+        tg_id,
+    )
+
+    balance = await get_balance(tg_id)
+
+    balance = int(balance)
+
+    text = (
+        f"<b>💵 Изменение баланса</b>"
+        f"\n\n🆔 ID: <b>{tg_id}</b>"
+        f"\n💰 Баланс: <b>{balance}Р</b>"
+        f"\n📊 Последние операции (5):"
+    )
+
+    if records:
+        for record in records:
+            amount = record["amount"]
+            payment_system = record["payment_system"]
+            status = record["status"]
+            date = record["created_at"].strftime("%Y-%m-%d %H:%M:%S")
+            text += (
+                f"\n<blockquote>💸 Сумма: {amount} | {payment_system}"
+                f"\n📌 Статус: {status}"
+                f"\n⏳ Дата: {date}</blockquote>"
+            )
+    else:
+        text += "\n <i>🚫 Отсутствуют</i>"
+
+    await callback_query.message.edit_text(text=text, reply_markup=build_users_balance_kb(tg_id))
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_balance_add"), IsAdminFilter())
+async def handle_balance_add(
+    callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, state: FSMContext, session: Any
+):
+    tg_id = callback_data.tg_id
+    amount = callback_data.data
+
+    if amount:
+        await update_balance(tg_id, int(amount), session, is_admin=True)
+        await handle_balance_change(callback_query, callback_data, session)
+        return
+
+    await state.update_data(tg_id=tg_id, op_type="add")
+    await state.set_state(UserEditorState.waiting_for_balance)
+
+    await callback_query.message.edit_text(
+        text="✍️ Введите сумму, которую хотите добавить на баланс пользователя:",
+        reply_markup=build_users_balance_change_kb(tg_id),
+    )
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_balance_take"), IsAdminFilter())
+async def handle_balance_take(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, state: FSMContext):
+    tg_id = callback_data.tg_id
+
+    await state.update_data(tg_id=tg_id, op_type="take")
+    await state.set_state(UserEditorState.waiting_for_balance)
+
+    await callback_query.message.edit_text(
+        text="✍️ Введите сумму, которую хотите вычесть из баланса пользователя:",
+        reply_markup=build_users_balance_change_kb(tg_id),
+    )
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_balance_set"), IsAdminFilter())
+async def handle_balance_set(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, state: FSMContext):
+    tg_id = callback_data.tg_id
+
+    await state.update_data(tg_id=tg_id, op_type="set")
+    await state.set_state(UserEditorState.waiting_for_balance)
+
+    await callback_query.message.edit_text(
+        text="✍️ Введите баланс, который хотите установить пользователю:",
+        reply_markup=build_users_balance_change_kb(tg_id),
+    )
+
+
+@router.message(UserEditorState.waiting_for_balance, IsAdminFilter())
+async def handle_balance_input(message: Message, state: FSMContext, session: Any):
+    data = await state.get_data()
+    tg_id = data.get("tg_id")
+    op_type = data.get("op_type")
+
+    if not message.text.isdigit() or int(message.text) < 0:
+        await message.answer(
+            text="🚫 Пожалуйста, введите корректную сумму!", reply_markup=build_users_balance_change_kb(tg_id)
+        )
+        return
+
+    amount = int(message.text)
+
+    if op_type == "add":
+        text = f"✅ К балансу пользователя добавлено <b>{amount}Р</b>"
+        await update_balance(tg_id, amount, session)
+    elif op_type == "take":
+        text = f"✅ Из баланса пользователя было вычтено <b>{amount}Р</b>"
+        await update_balance(tg_id, -amount, session)
+    else:
+        text = f"✅ Баланс пользователя изменен на <b>{amount}Р</b>"
+        await set_user_balance(tg_id, amount, session)
+
+    await message.answer(text=text, reply_markup=build_users_balance_change_kb(tg_id))
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_key_edit"), IsAdminFilter())
+async def handle_key_edit(
+    callback_query: CallbackQuery,
+    callback_data: AdminUserEditorCallback | AdminUserKeyEditorCallback,
+    session: Any,
+    update: bool = False,
+):
+    email = callback_data.data
+    key_details = await get_key_details(email, session)
+
+    if not key_details:
+        await callback_query.message.edit_text(
+            text="🚫 Информация о ключе не найдена.",
+            reply_markup=build_editor_kb(callback_data.tg_id),
+        )
+        return
+
+    text = (
+        f"<b>🔑 Информация о ключе</b>"
+        f"\n\n<code>{key_details['key']}</code>"
+        f"\n\n⏰ Дата истечения: <b>{key_details['expiry_date']} (UTC)</b>"
+        f"\n🌐 Кластер: <b>{key_details['cluster_name']}</b>"
+        f"\n🆔 ID клиента: <b>{key_details['tg_id']}</b>"
+    )
+
+    if not update or not callback_data.edit:
+        await callback_query.message.edit_text(text=text, reply_markup=build_key_edit_kb(key_details, email))
+    else:
+        await callback_query.message.edit_text(
+            text=text, reply_markup=build_users_key_expiry_kb(callback_data.tg_id, email)
+        )
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_expiry_edit"), IsAdminFilter())
+async def handle_change_expiry(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback):
+    tg_id = callback_data.tg_id
+    email = callback_data.data
+
+    await callback_query.message.edit_reply_markup(reply_markup=build_users_key_expiry_kb(tg_id, email))
+
+
+@router.callback_query(AdminUserKeyEditorCallback.filter(F.action == "add"), IsAdminFilter())
+async def handle_expiry_add(
+    callback_query: CallbackQuery, callback_data: AdminUserKeyEditorCallback, state: FSMContext, session: Any
+):
+    tg_id = callback_data.tg_id
+    email = callback_data.data
+    month = callback_data.month
+
+    key_details = await get_key_details(email, session)
+
+    if not key_details:
+        await callback_query.message.edit_text(
+            text="🚫 Информация о ключе не найдена.",
+            reply_markup=build_editor_kb(tg_id),
+        )
+        return
+
+    if month:
+        await change_expiry_time(key_details["expiry_time"] + month * 30 * 24 * 3600 * 1000, email, session)
+        await handle_key_edit(callback_query, callback_data, session, True)
+        return
+
+    await state.update_data(tg_id=tg_id, email=email, op_type="add")
+    await state.set_state(UserEditorState.waiting_for_expiry_time)
+
+    await callback_query.message.edit_text(
+        text="✍️ Введите количество дней, которое хотите добавить к времени действия ключа:",
+        reply_markup=build_users_key_show_kb(tg_id, email),
+    )
+
+
+@router.callback_query(AdminUserKeyEditorCallback.filter(F.action == "take"), IsAdminFilter())
+async def handle_expiry_take(
+    callback_query: CallbackQuery, callback_data: AdminUserKeyEditorCallback, state: FSMContext
+):
+    tg_id = callback_data.tg_id
+    email = callback_data.data
+
+    await state.update_data(tg_id=tg_id, email=email, op_type="take")
+    await state.set_state(UserEditorState.waiting_for_expiry_time)
+
+    await callback_query.message.edit_text(
+        text="✍️ Введите количество дней, которое хотите вычесть из времени действия ключа:",
+        reply_markup=build_users_key_show_kb(tg_id, email),
+    )
+
+
+@router.callback_query(AdminUserKeyEditorCallback.filter(F.action == "set"), IsAdminFilter())
+async def handle_expiry_set(
+    callback_query: CallbackQuery, callback_data: AdminUserKeyEditorCallback, state: FSMContext, session: Any
+):
+    tg_id = callback_data.tg_id
+    email = callback_data.data
+
+    key_details = await get_key_details(email, session)
+
+    if not key_details:
+        await callback_query.message.edit_text(
+            text="🚫 Информация о ключе не найдена.",
+            reply_markup=build_editor_kb(tg_id),
+        )
+        return
+
+    await state.update_data(tg_id=tg_id, email=email, op_type="set")
+    await state.set_state(UserEditorState.waiting_for_expiry_time)
+
+    text = (
+        "✍️ Введите новое время действия ключа:"
+        "\n\n📌 Формат: <b>год-месяц-день час:минута</b>"
+        f"\n\n📄 Текущая дата: {datetime.fromtimestamp(key_details['expiry_time'] / 1000).strftime('%Y-%m-%d %H:%M')}"
+    )
+
+    await callback_query.message.edit_text(text=text, reply_markup=build_users_key_show_kb(tg_id, email))
+
+
+@router.message(UserEditorState.waiting_for_expiry_time, IsAdminFilter())
+async def handle_expiry_time_input(message: Message, state: FSMContext, session: Any):
+    data = await state.get_data()
+    tg_id = data.get("tg_id")
+    email = data.get("email")
+    op_type = data.get("op_type")
+
+    if op_type != "set" and (not message.text.isdigit() or int(message.text) < 0):
+        await message.answer(
+            text="🚫 Пожалуйста, введите корректное количество дней!",
+            reply_markup=build_users_key_show_kb(tg_id, email),
+        )
+        return
+
+    key_details = await get_key_details(email, session)
+
+    if not key_details:
+        await message.answer(
+            text="🚫 Информация о ключе не найдена.",
+            reply_markup=build_editor_kb(tg_id),
+        )
+        return
+
+    try:
+        current_expiry_time = datetime.fromtimestamp(key_details["expiry_time"] / 1000, tz=MOSCOW_TZ)
+
+        if op_type == "add":
+            days = int(message.text)
+            new_expiry_time = current_expiry_time + timedelta(days=days)
+            text = f"✅ Ко времени действия ключа добавлено <b>{days} дн.</b>"
+
+        elif op_type == "take":
+            days = int(message.text)
+            new_expiry_time = current_expiry_time - timedelta(days=days)
+            text = f"✅ Из времени действия ключа вычтено <b>{days} дн.</b>"
+
+        else:
+            new_expiry_time = datetime.strptime(message.text, "%Y-%m-%d %H:%M")
+            new_expiry_time = MOSCOW_TZ.localize(new_expiry_time)
+            text = f"✅ Время действия ключа изменено на <b>{message.text} (МСК)</b>"
+
+        new_expiry_timestamp = int(new_expiry_time.timestamp() * 1000)
+        await change_expiry_time(new_expiry_timestamp, email, session)
+
+    except ValueError:
+        text = "🚫 Пожалуйста, используйте корректный формат даты (ГГГГ-ММ-ДД ЧЧ:ММ)!"
+    except Exception as e:
+        text = f"❗ Произошла ошибка во время изменения времени действия ключа: {e}"
+
+    await message.answer(text=text, reply_markup=build_users_key_show_kb(tg_id, email))
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_update_key"), IsAdminFilter())
+async def handle_update_key(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, session: Any):
+    tg_id = callback_data.tg_id
+    email = callback_data.data
+
+    try:
+        await update_subscription(tg_id, email, session)
+        await handle_key_edit(callback_query, callback_data, session, True)
+    except TelegramBadRequest:
+        pass
+    except Exception as e:
+        logger.error(f"Ошибка при обновлении ключа {email} администратором: {e}")
+        await callback_query.message.answer(
+            text=f"❗ Произошла ошибка при обновлении ключа: {e}", reply_markup=build_user_key_kb(tg_id, email)
+        )
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_delete_key"), IsAdminFilter())
+async def handle_delete_key(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, session: Any):
+    email = callback_data.data
+    client_id = await session.fetchval("SELECT client_id FROM keys WHERE email = $1", email)
+
+    if client_id is None:
+        await callback_query.message.edit_text(
+            text="🚫 Ключ не найден!", reply_markup=build_editor_kb(callback_data.tg_id)
+        )
+        return
+
+    await callback_query.message.edit_text(
+        text="❓ Вы уверены, что хотите удалить ключ?", reply_markup=build_key_delete_kb(callback_data.tg_id, email)
+    )
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_delete_key_confirm"), IsAdminFilter())
+async def handle_delete_key_confirm(
+    callback_query: types.CallbackQuery, callback_data: AdminUserEditorCallback, session: Any
+):
+    email = callback_data.data
+    record = await session.fetchrow("SELECT client_id FROM keys WHERE email = $1", email)
+
+    kb = build_editor_kb(callback_data.tg_id)
+
+    if record:
+        client_id = record["client_id"]
+        clusters = await get_servers()
+
+        async def delete_key_from_servers():
+            tasks = []
+            for cluster_name, cluster_servers in clusters.items():
+                for _ in cluster_servers:
+                    tasks.append(delete_key_from_cluster(cluster_name, email, client_id))
+            await asyncio.gather(*tasks)
+
+        await delete_key_from_servers()
+        await delete_key(client_id, session)
+
+        await callback_query.message.edit_text(text="✅ Ключ успешно удален.", reply_markup=kb)
+    else:
+        await callback_query.message.edit_text(text="🚫 Ключ не найден или уже удален.", reply_markup=kb)
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_delete_user"), IsAdminFilter())
+async def handle_delete_user(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback):
+    tg_id = callback_data.tg_id
+    await callback_query.message.edit_text(
+        text=f"❗️ Вы уверены, что хотите удалить пользователя с ID {tg_id}?", reply_markup=build_user_delete_kb(tg_id)
+    )
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_delete_user_confirm"), IsAdminFilter())
+async def handle_delete_user_confirm(
+    callback_query: types.CallbackQuery, callback_data: AdminUserEditorCallback, session: Any
+):
+    tg_id = callback_data.tg_id
+    key_records = await session.fetch("SELECT email, client_id FROM keys WHERE tg_id = $1", tg_id)
+
+    async def delete_keys_from_servers():
+        try:
+            tasks = []
+            for email, client_id in key_records:
+                servers = await get_servers()
+                for cluster_id, _cluster in servers.items():
+                    tasks.append(delete_key_from_cluster(cluster_id, email, client_id))
+            await asyncio.gather(*tasks)
+        except Exception as e:
+            logger.error(f"Ошибка при удалении ключей с серверов для пользователя {tg_id}: {e}")
+
+    await delete_keys_from_servers()
+
+    try:
+        await delete_user_data(session, tg_id)
+        await callback_query.message.edit_text(
+            text=f"🗑️ Пользователь с ID {tg_id} был удален.", reply_markup=build_editor_kb(callback_data.tg_id)
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при удалении данных из базы данных для пользователя {tg_id}: {e}")
+        await callback_query.message.edit_text(
+            text=f"❌ Произошла ошибка при удалении пользователя с ID {tg_id}. Попробуйте снова."
+        )
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_editor"), IsAdminFilter())
+async def handle_editor(
+    callback_query: types.CallbackQuery, callback_data: AdminUserEditorCallback, state: FSMContext, session: Any
+):
+    await process_user_search(callback_query.message, state, session, callback_data.tg_id, callback_data.edit)
+
+
+async def process_user_search(
+    message: types.Message, state: FSMContext, session: Any, tg_id: int, edit: bool = False
+) -> None:
+    await state.clear()
+
+    balance = await session.fetchval("SELECT balance FROM connections WHERE tg_id = $1", tg_id)
+
+    if balance is None:
+        await message.answer(
+            text="🚫 Пользователь с указанным ID не найден!",
+            reply_markup=build_admin_back_kb(),
+        )
+        return
+
+    balance = int(balance)
+
+    username = await session.fetchval("SELECT username FROM users WHERE tg_id = $1", tg_id)
+    key_records = await session.fetch("SELECT email, expiry_time FROM keys WHERE tg_id = $1", tg_id)
+    referral_count = await session.fetchval("SELECT COUNT(*) FROM referrals WHERE referrer_tg_id = $1", tg_id)
+
+    text = (
+        f"<b>📊 Информация о пользователе</b>"
+        f"\n\n🆔 ID: <b>{tg_id}</b>"
+        f"\n📄 Логин: <b>@{username}</b>"
+        f"\n💰 Баланс: <b>{balance}</b>"
+        f"\n👥 Количество рефералов: <b>{referral_count}</b>"
+    )
+
+    kb = build_user_edit_kb(tg_id, key_records)
+
+    if edit:
+        try:
+            await message.edit_text(text=text, reply_markup=kb)
+        except TelegramBadRequest:
+            pass
+    else:
+        await message.answer(text=text, reply_markup=kb)
+
+
+async def get_key_details(email, session):
+    record = await session.fetchrow(
+        """
+        SELECT k.client_id, k.key, k.expiry_time, k.server_id, c.tg_id, c.balance
+        FROM keys k
+        JOIN connections c ON k.tg_id = c.tg_id
+        WHERE k.email = $1
+        """,
+        email,
+    )
+
+    if not record:
+        return None
+
+    cluster_name = record["server_id"]
+    expiry_date = datetime.fromtimestamp(record["expiry_time"] / 1000, tz=timezone.utc)
+
+    return {
+        "client_id": record["client_id"],
+        "balance": record["balance"],
+        "tg_id": record["tg_id"],
+        "key": record["key"],
+        "cluster_name": cluster_name,
+        "expiry_time": record["expiry_time"],
+        "expiry_date": expiry_date.strftime("%d %B %Y года %H:%M"),
+    }
+
+
+async def change_expiry_time(expiry_time: int, email: str, session: Any) -> Exception | None:
+    client_id = await get_client_id_by_email(email)
+
+    if client_id is None:
+        return ValueError(f"User with email {email} was not found")
+
+    server_id = await session.fetchrow("SELECT server_id FROM keys WHERE client_id = $1", client_id)
+
+    if not server_id:
+        return ValueError(f"User with client_id {server_id} was not found")
+
+    clusters = await get_servers()
+
+    async def update_key_on_all_servers():
+        tasks = [
+            asyncio.create_task(
+                renew_key_in_cluster(
+                    cluster_name,
+                    email,
+                    client_id,
+                    expiry_time,
+                    total_gb=TOTAL_GB,
+                )
+            )
+            for cluster_name in clusters
+        ]
+
+        await asyncio.gather(*tasks)
+
+    await update_key_on_all_servers()
+    await update_key_expiry(client_id, expiry_time, session)
+
+
+async def set_user_balance(tg_id: int, balance: int, session: Any) -> None:
+    try:
+        await session.execute(
+            "UPDATE connections SET balance = $1 WHERE tg_id = $2",
+            balance,
+            tg_id,
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при установке баланса для пользователя {tg_id}: {e}")
+
+
+@router.callback_query(AdminUserEditorCallback.filter(F.action == "users_traffic"), IsAdminFilter())
+async def handle_user_traffic(
+    callback_query: types.CallbackQuery, callback_data: AdminUserEditorCallback, session: Any
+):
+    """
+    Обработчик кнопки "📊 Трафик".
+    Получает трафик пользователя и отправляет администратору.
+    """
+    tg_id = callback_data.tg_id
+    email = callback_data.data
+
+    await callback_query.message.edit_text("⏳ Получаем данные о трафике, пожалуйста, подождите...")
+
+    traffic_data = await get_user_traffic(session, tg_id, email)
+
+    if traffic_data["status"] == "error":
+        await callback_query.message.edit_text(traffic_data["message"], reply_markup=build_editor_kb(tg_id, True))
+        return
+
+    total_traffic = 0
+
+    result_text = f"📊 <b>Трафик подписки {email}:</b>\n\n"
+
+    for server, traffic in traffic_data["traffic"].items():
+        if isinstance(traffic, str):
+            result_text += f"❌ {server}: {traffic}\n"
+        else:
+            result_text += f"🌍 {server}: <b>{traffic} ГБ</b>\n"
+            total_traffic += traffic
+
+    result_text += f"\n🔢 <b>Общий трафик:</b> {total_traffic:.2f} ГБ"
+
+    await callback_query.message.edit_text(result_text, reply_markup=build_editor_kb(tg_id, True))

handlers/balance.py

@@ -1,10 +0,0 @@
-import aiosqlite
-from aiogram import Router, types
-
-router = Router()
-
-@router.callback_query(lambda c: c.data == 'view_balance')
-async def process_callback_view_balance(callback_query: types.CallbackQuery):
-    tg_id = callback_query.from_user.id
-    
-   

handlers/buttons/add_subscribe.py

@@ -0,0 +1,6 @@
+DOWNLOAD_IOS_BUTTON = "🍏 Скачать iOS"
+DOWNLOAD_ANDROID_BUTTON = "🤖 Скачать Android"
+IMPORT_IOS = "🍏 Подключить"
+IMPORT_ANDROID = "🤖 Подключить"
+PC_BUTTON = "💻 Компьютеры"
+TV_BUTTON = "📺 Андроид TV"

handlers/buttons/gifts.py

@@ -0,0 +1,9 @@
+GIFT = "🎁 Подарить подписку"
+MY_GIFTS = "🎁 Мои подарки"
+PROFILE = "👤 Личный кабинет"
+BACK = "В меню подарков"
+GIFTS_ABOUT = "<b>Дарите подарки и следите, чтобы они дошли до адресата! 🎄</b>"
+SHARE_GIFT = "🎁 Поделиться подарком"
+APPLY = "✅ Подтвердить"
+CANCEL = "❌ Отмена"
+NO_GIFTS = "У вас нет подарков."

handlers/buttons/notification.py

@@ -0,0 +1,3 @@
+RENEW_KEY = "🔄 Продлить подписку"
+ADD_KEY = "➕ Добавить подписку"
+PROFILE = "👤 Личный кабинет"

handlers/buttons/profile.py

@@ -0,0 +1,10 @@
+ADD_SUB = "➕ Подписка"
+MY_SUBS = "📱 Мои подписки"
+BALANCE = "💰 Баланс"
+BALANCE_HISTORY = "📊 История пополнения"
+PAYMENT = "💳 Пополнить баланс"
+INVITE = "👥 Пригласить"
+GIFTS = "🎁 Подарить"
+TARRIFS = "💡 Тарифы"
+INSTRUCTIONS = "📘 Инструкции"
+MAIN_MENU = "⬅️ Главное меню"

handlers/buttons/yookassa.py

@@ -0,0 +1,12 @@
+PAY = "Пополнить"
+PAY_2 = "Оплатить"
+BACK = "⬅️ Назад"
+CUSTOM_SUM = "💰 Ввести свою сумму"
+PROFILE = "👤 Личный кабинет"
+KEY_CREATION_PAYMENT_MESSAGE = (
+    "Вы выбрали пополнение на {amount} рублей для создания нового ключа. Перейдите по ссылке для оплаты:"
+)
+KEY_RENEWAL_PAYMENT_MESSAGE = (
+    "Вы выбрали пополнение на {amount} рублей для продления ключа. Перейдите по ссылке для оплаты:"
+)
+DEFAULT_PAYMENT_MESSAGE = "Вы выбрали пополнение на {amount} рублей. Перейдите по ссылке для оплаты:"

handlers/captcha.py

@@ -0,0 +1,75 @@
+import random
+import secrets
+from typing import Any
+
+from aiogram import F, Router
+from aiogram.fsm.context import FSMContext
+from aiogram.types import CallbackQuery, Message
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from config import CAPTCHA_EMOJIS
+from logger import logger
+
+from .utils import edit_or_send_message
+
+router = Router()
+
+
+async def generate_captcha(message: Message, state: FSMContext):
+    correct_emoji, correct_text = secrets.choice(list(CAPTCHA_EMOJIS.items()))
+    wrong_emojis = random.sample([e for e in CAPTCHA_EMOJIS.keys() if e != correct_emoji], 3)
+
+    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,
+    )
+
+    builder = InlineKeyboardBuilder()
+    for emoji in all_emojis:
+        builder.button(text=emoji, callback_data=f"captcha_{emoji}")
+    builder.adjust(2, 2)
+
+    return {
+        "text": f"🔒 Для подтверждения, что вы не робот, выберите кнопку с {correct_text}",
+        "markup": builder.as_markup(),
+    }
+
+
+@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
+
+    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")
+
+    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
+
+    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"],
+        )

handlers/coupons.py

@@ -0,0 +1,77 @@
+from typing import Any
+
+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 database import (
+    check_coupon_usage,
+    create_coupon_usage,
+    get_coupon_by_code,
+    update_balance,
+    update_coupon_usage_count,
+)
+
+from .utils import edit_or_send_message
+
+
+class CouponActivationState(StatesGroup):
+    waiting_for_coupon_code = State()
+
+
+router = Router()
+
+
+@router.callback_query(F.data == "activate_coupon")
+@router.message(F.text == "/activate_coupon")
+async def handle_activate_coupon(callback_query_or_message: Message | CallbackQuery, state: FSMContext):
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    if isinstance(callback_query_or_message, CallbackQuery):
+        target_message = callback_query_or_message.message
+    else:
+        target_message = callback_query_or_message
+
+    await edit_or_send_message(
+        target_message=target_message,
+        text="<b>🎫 Введите код купона:</b>\n\n"
+        "📝 Пожалуйста, введите действующий код купона, который вы хотите активировать. 🔑",
+        reply_markup=builder.as_markup(),
+        media_path=None,
+    )
+    await state.set_state(CouponActivationState.waiting_for_coupon_code)
+
+
+@router.message(CouponActivationState.waiting_for_coupon_code)
+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)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    await message.answer(activation_result, reply_markup=builder.as_markup())
+    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)
+
+    if not coupon_record:
+        return "<b>❌ Купон не найден</b> 🚫 или его использование ограничено. 🔒 Пожалуйста, проверьте код и попробуйте снова. 🔍"
+
+    usage_exists = await check_coupon_usage(coupon_record["id"], user_id, session)
+
+    if usage_exists:
+        return "<b>❌ Вы уже активировали этот купон.</b> 🚫 Купоны могут быть активированы только один раз. 🔒"
+
+    coupon_amount = coupon_record["amount"]
+
+    await update_coupon_usage_count(coupon_record["id"], session)
+    await create_coupon_usage(coupon_record["id"], user_id, session)
+
+    await update_balance(user_id, coupon_amount, session)
+    return f"<b>✅ Купон успешно активирован! 🎉</b>\n\nНа ваш баланс добавлено <b>{coupon_amount} рублей</b> 💰."

handlers/donate.py

@@ -0,0 +1,115 @@
+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.utils.keyboard import InlineKeyboardBuilder
+
+from config import RUB_TO_XTR
+from logger import logger
+
+from .utils import edit_or_send_message
+
+
+class DonateState(StatesGroup):
+    entering_donate_amount = State()
+    waiting_for_donate_confirmation = State()
+    waiting_for_donate_payment = State()
+
+
+router = Router()
+
+
+@router.callback_query(F.data == "donate")
+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="💰 Ввести сумму доната",
+            callback_data="enter_custom_donate_amount",
+        )
+    )
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    text = (
+        "🌟 Поддержите наш проект! 💪\n\n"
+        "💖 Каждый донат помогает развивать и улучшать сервис. "
+        "🤝 Мы ценим вашу поддержку и работаем над тем, чтобы сделать наш продукт еще лучше. 🚀💡"
+    )
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=text,
+        reply_markup=builder.as_markup(),
+    )
+
+
+@router.callback_query(F.data == "enter_custom_donate_amount")
+async def process_enter_donate_amount(callback_query: CallbackQuery, state: FSMContext):
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data="donate"))
+    text = "💸 Введите сумму доната в рублях:"
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=text,
+        reply_markup=builder.as_markup(),
+    )
+
+    await state.set_state(DonateState.entering_donate_amount)
+
+
+@router.message(DonateState.entering_donate_amount)
+async def process_donate_amount_input(message: Message, state: FSMContext):
+    if message.text.isdigit():
+        amount = int(message.text)
+        if amount // RUB_TO_XTR <= 0:
+            await message.answer(f"Сумма доната должна быть больше {RUB_TO_XTR}. Пожалуйста, введите сумму еще раз:")
+            return
+
+        await state.update_data(amount=amount)
+        await state.set_state(DonateState.waiting_for_donate_confirmation)
+
+        try:
+            builder = InlineKeyboardBuilder()
+            builder.row(InlineKeyboardButton(text="Задонатить", pay=True))
+            builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data="donate"))
+
+            await message.answer_invoice(
+                title=f"Донат проекту {amount} рублей",
+                description="Спасибо за вашу поддержку!",
+                prices=[LabeledPrice(label="Донат", amount=int(amount // RUB_TO_XTR))],
+                provider_token="",
+                payload=f"{amount}_donate",
+                currency="XTR",
+                reply_markup=builder.as_markup(),
+            )
+            await state.set_state(DonateState.waiting_for_donate_payment)
+        except Exception as e:
+            logger.error(f"Ошибка при создании доната: {e}")
+    else:
+        await message.answer("Некорректная сумма. Пожалуйста, введите сумму еще раз:")
+
+
+@router.pre_checkout_query(DonateState.waiting_for_donate_payment)
+async def on_pre_checkout_query(pre_checkout_query: PreCheckoutQuery):
+    await pre_checkout_query.answer(ok=True)
+
+
+@router.message(F.successful_payment, DonateState.waiting_for_donate_payment)
+async def on_successful_donate(message: Message, state: FSMContext):
+    try:
+        amount = float(message.successful_payment.invoice_payload.split("_")[0])
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+        await message.answer(
+            text=f"🙏 Спасибо за донат {amount} рублей! Ваша поддержка очень важна для нас. 💖",
+            reply_markup=builder.as_markup(),
+        )
+        await state.clear()
+    except ValueError as e:
+        logger.error(f"Ошибка конвертации user_id или amount: {e}")
+    except Exception as e:
+        logger.error(f"Произошла ошибка при обработке доната: {e}")

handlers/instructions.py

@@ -1,22 +0,0 @@
-from aiogram import types
-from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
-
-
-async def send_instructions(callback_query: types.CallbackQuery):
-    instructions_message = (
-        "*📋 Инструкции по использованию вашего ключа:*\n\n"
-        "1. Скачайте приложение для вашего устройства:\n"
-        "   - Для Android: [V2Ray](https://play.google.com/store/apps/details?id=com.v2ray.ang&hl=ru&pli=1)\n"
-        "   - Для iPhone: [Streisand](https://apps.apple.com/ru/app/streisand/id6450534064)\n"
-        "   - Для Windows: [Hiddify Next](https://github.com/hiddify/hiddify-next/releases/latest/download/Hiddify-Windows-Setup-x64.Msix)\n\n"
-        "2. Скопируйте предоставленный ключ, который вы получили ранее.\n"
-        "3. Откройте приложение и нажмите на плюсик сверху справа.\n"
-        "4. Выберите 'Вставить из буфера обмена' для добавления ключа.\n\n"
-        "💬 Если у вас возникнут вопросы, не стесняйтесь обращаться в поддержку."
-    )
-
-    back_button = InlineKeyboardButton(text='🔙 Назад', callback_data='back_to_main')
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[[back_button]])
-
-    await callback_query.message.edit_text(instructions_message, parse_mode='Markdown', reply_markup=keyboard)
-    await callback_query.answer()

handlers/instructions/__init__.py

@@ -0,0 +1,11 @@
+__all__ = ("router",)
+
+from aiogram import Router
+
+from .instructions import router as instructions_router
+
+router = Router(name="instructions_main_router")
+
+router.include_routers(
+    instructions_router,
+)

handlers/instructions/instructions.py

@@ -0,0 +1,118 @@
+import os
+from typing import Any
+
+from aiogram import F, Router, types
+from aiogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    Message,
+)
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from config import CONNECT_MACOS, CONNECT_WINDOWS, SUPPORT_CHAT_URL
+from database import get_key_details
+from handlers.texts import (
+    CONNECT_TV_TEXT,
+    INSTRUCTION_PC,
+    INSTRUCTIONS,
+    KEY_MESSAGE,
+    SUBSCRIPTION_DETAILS_TEXT,
+)
+from handlers.utils import edit_or_send_message
+
+router = Router()
+
+
+@router.callback_query(F.data == "instructions")
+@router.message(F.text == "/instructions")
+async def send_instructions(callback_query_or_message: CallbackQuery | Message):
+    instructions_message = INSTRUCTIONS
+    image_path = os.path.join("img", "instructions.jpg")
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="💬 Поддержка", url=SUPPORT_CHAT_URL))
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    if isinstance(callback_query_or_message, CallbackQuery):
+        target_message = callback_query_or_message.message
+    else:
+        target_message = callback_query_or_message
+
+    await edit_or_send_message(
+        target_message=target_message,
+        text=instructions_message,
+        reply_markup=builder.as_markup(),
+        media_path=image_path,
+    )
+
+
+@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:
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+        await edit_or_send_message(
+            target_message=callback_query.message,
+            text="❌ <b>Ключ не найден. Проверьте имя ключа.</b> 🔍",
+            reply_markup=builder.as_markup(),
+            media_path=None,
+        )
+        return
+
+    key = record["key"]
+    key_message_text = KEY_MESSAGE.format(key)
+    instruction_message = f"{key_message_text}{INSTRUCTION_PC}"
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="💻 Подключить Windows", url=f"{CONNECT_WINDOWS}{key}"))
+    builder.row(InlineKeyboardButton(text="💻 Подключить MacOS", url=f"{CONNECT_MACOS}{key}"))
+    builder.row(InlineKeyboardButton(text="🆘 Поддержка", url=SUPPORT_CHAT_URL))
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data=f"view_key|{key_name}"))
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=instruction_message,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+    )
+
+
+
+@router.callback_query(F.data.startswith("connect_tv|"))
+async def process_connect_tv(callback_query: CallbackQuery):
+    key_name = callback_query.data.split("|")[1]
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="▶ Продолжить", callback_data=f"continue_tv|{key_name}"))
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data=f"view_key|{key_name}"))
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=CONNECT_TV_TEXT,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+        disable_web_page_preview=True,
+    )
+
+
+@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]
+    tg_id = callback_query.from_user.id
+
+    record = await get_key_details(key_name, session)
+    subscription_link = record["key"]
+    message_text = SUBSCRIPTION_DETAILS_TEXT.format(subscription_link=subscription_link)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="📖 Полная инструкция", url="https://vpn4tv.com/quick-guide.html"))
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data=f"connect_tv|{key_name}"))
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message, text=message_text, reply_markup=builder.as_markup(), media_path=None
+    )

handlers/keys.py

@@ -1,290 +0,0 @@
-from datetime import datetime, timedelta
-
-import asyncpg
-from aiogram import Router, types
-
-from auth import login_with_credentials
-from bot import bot
-from client import delete_client, extend_client_key
-from config import ADMIN_PASSWORD, ADMIN_USERNAME, DATABASE_URL
-from database import get_balance, update_balance
-
-router = Router()
-
-from datetime import datetime, timedelta
-
-import asyncpg
-from aiogram import Router, types
-
-from auth import login_with_credentials
-from bot import bot
-from client import delete_client, extend_client_key
-from config import ADMIN_PASSWORD, ADMIN_USERNAME, DATABASE_URL
-from database import get_balance, update_balance
-
-router = Router()
-
-# Обработка запроса на просмотр ключей
-@router.callback_query(lambda c: c.data == 'view_keys')
-async def process_callback_view_keys(callback_query: types.CallbackQuery):
-    tg_id = callback_query.from_user.id
-
-    try:
-        conn = await asyncpg.connect(DATABASE_URL)
-        try:
-            records = await conn.fetch('''
-                SELECT email, client_id FROM keys WHERE tg_id = $1
-            ''', tg_id)
-
-            if records:
-                # Создаем кнопки для каждого ключа
-                buttons = []
-                for record in records:
-                    key_name = record['email']
-                    client_id = record['client_id']
-                    # Заменяем подчеркивание на вертикальную черту в callback_data
-                    button = types.InlineKeyboardButton(text=f"🔑 {key_name}", callback_data=f'view_key|{key_name}|{client_id}')
-                    buttons.append([button])
-
-                # Создаем клавиатуру с кнопками
-                inline_keyboard = types.InlineKeyboardMarkup(inline_keyboard=buttons)
-                response_message = "<b>Выберите ключ для просмотра информации:</b>"
-
-                # Редактируем сообщение с клавиатурой
-                await bot.edit_message_text(response_message, chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=inline_keyboard, parse_mode="HTML")
-            else:
-                # Если нет ключей, добавляем кнопку "Создать ключ" и "Назад"
-                response_message = "<b>У вас нет ключей.</b>"
-
-                # Кнопка "Создать ключ"
-                create_key_button = types.InlineKeyboardButton(text='➕ Создать ключ', callback_data='create_key')
-                back_button = types.InlineKeyboardButton(text='🔙 Назад', callback_data='view_profile')  # Измените на правильное значение для кнопки "Назад"
-                
-                keyboard = types.InlineKeyboardMarkup(inline_keyboard=[[create_key_button], [back_button]])
-
-                await bot.edit_message_text(response_message, chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=keyboard, parse_mode="HTML")
-
-        finally:
-            await conn.close()
-
-    except Exception as e:
-        await handle_error(tg_id, callback_query, f"Ошибка при получении ключей: {e}")
-
-    await callback_query.answer()
-
-@router.callback_query(lambda c: c.data.startswith('view_key|'))
-async def process_callback_view_key(callback_query: types.CallbackQuery):
-    tg_id = callback_query.from_user.id
-    # Разделяем данные по вертикальной черте
-    key_name, client_id = callback_query.data.split('|')[1], callback_query.data.split('|')[2]
-
-    try:
-        conn = await asyncpg.connect(DATABASE_URL)
-        try:
-            record = await conn.fetchrow('''
-                SELECT k.key, k.expiry_time 
-                FROM keys k
-                WHERE k.tg_id = $1 AND k.email = $2
-            ''', tg_id, key_name)
-
-            if record:
-                key = record['key']
-                expiry_time = record['expiry_time']
-                expiry_date = datetime.utcfromtimestamp(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>"
-
-                response_message = (f"🔑 <b>Ваш ключ:</b>\n<pre>{key}</pre>\n"
-                                    f"📅 <b>Дата окончания:</b> {expiry_date.strftime('%Y-%m-%d %H:%M:%S')}\n"
-                                    f"{days_left_message}")
-
-                # Кнопки для продления, инструкций и удаления
-                renew_button = types.InlineKeyboardButton(text='⏳ Продлить ключ', callback_data=f'renew_key|{client_id}')
-                instructions_button = types.InlineKeyboardButton(text='📘 Инструкции', callback_data='instructions')
-                delete_button = types.InlineKeyboardButton(text='❌ Удалить ключ', callback_data=f'delete_key|{client_id}')
-                back_button = types.InlineKeyboardButton(text='🔙 Назад в профиль', callback_data='view_profile')
-                keyboard = types.InlineKeyboardMarkup(inline_keyboard=[[renew_button], [instructions_button], [delete_button], [back_button]])
-
-                await bot.edit_message_text(response_message, chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=keyboard, parse_mode="HTML")
-            else:
-                await bot.edit_message_text("<b>Информация о ключе не найдена.</b>", chat_id=tg_id, message_id=callback_query.message.message_id, parse_mode="HTML")
-
-        finally:
-            await conn.close()
-
-    except Exception as e:
-        await handle_error(tg_id, callback_query, f"Ошибка при получении информации о ключе: {e}")
-
-    await callback_query.answer()
-
-# Обработка запроса на удаление ключа
-@router.callback_query(lambda c: c.data.startswith('delete_key|'))
-async def process_callback_delete_key(callback_query: types.CallbackQuery):
-    tg_id = callback_query.from_user.id
-    client_id = callback_query.data.split('|')[1]  # Используем разделитель вертикальная черта
-
-    confirmation_keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
-        [types.InlineKeyboardButton(text='✅ Да, удалить', callback_data=f'confirm_delete|{client_id}')],
-        [types.InlineKeyboardButton(text='❌ Нет, отменить', callback_data='view_keys')]
-    ])
-
-    await bot.edit_message_text("<b>Вы уверены, что хотите удалить ключ?</b>", chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=confirmation_keyboard, parse_mode="HTML")
-    await callback_query.answer()
-
-
-# Обработка выбора плана продления
-@router.callback_query(lambda c: c.data.startswith('renew_key|'))
-async def process_callback_renew_key(callback_query: types.CallbackQuery):
-    tg_id = callback_query.from_user.id
-    client_id = callback_query.data.split('|')[1]  # Используем разделитель вертикальная черта
-
-    try:
-        conn = await asyncpg.connect(DATABASE_URL)
-        try:
-            record = await conn.fetchrow('SELECT email, expiry_time FROM keys WHERE client_id = $1', client_id)
-
-            if record:
-                email = record['email']
-                expiry_time = record['expiry_time']
-                current_time = datetime.utcnow().timestamp() * 1000  # Получаем текущее время в миллисекундах
-
-                # Добавляем новые планы продления (6 месяцев и год)
-                keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
-                    [types.InlineKeyboardButton(text='📅 1 месяц (100 руб.)', callback_data=f'renew_plan|1|{client_id}')],
-                    [types.InlineKeyboardButton(text='📅 3 месяца (285 руб.)', callback_data=f'renew_plan|3|{client_id}')],
-                    [types.InlineKeyboardButton(text='📅 6 месяцев (540 руб.)', callback_data=f'renew_plan|6|{client_id}')],
-                    [types.InlineKeyboardButton(text='📅 12 месяцев (1000 руб.)', callback_data=f'renew_plan|12|{client_id}')],
-                    [types.InlineKeyboardButton(text='🔙 Назад', callback_data='view_profile')]
-                ])
-
-                balance = await get_balance(tg_id)
-                response_message = (f"<b>Выберите план продления:</b>\n"
-                                    f"💰 <b>Баланс:</b> {balance} руб.\n"
-                                    f"📅 <b>Текущая дата истечения ключа:</b> {datetime.utcfromtimestamp(expiry_time / 1000).strftime('%Y-%m-%d %H:%M:%S')}")
-
-                await bot.edit_message_text(response_message, chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=keyboard, parse_mode="HTML")
-
-        finally:
-            await conn.close()
-
-    except Exception as e:
-        await bot.edit_message_text(f"<b>Ошибка при выборе плана:</b> {e}", chat_id=tg_id, message_id=callback_query.message.message_id, parse_mode="HTML")
-
-    await callback_query.answer()
-
-
-@router.callback_query(lambda c: c.data.startswith('confirm_delete|'))
-async def process_callback_confirm_delete(callback_query: types.CallbackQuery):
-    tg_id = callback_query.from_user.id
-    client_id = callback_query.data.split('|')[1]  # Используем разделитель вертикальная черта
-
-    try:
-        conn = await asyncpg.connect(DATABASE_URL)
-        try:
-            record = await conn.fetchrow('SELECT email FROM keys WHERE client_id = $1', client_id)
-
-            if record:
-                email = record['email']
-                
-                session = login_with_credentials(ADMIN_USERNAME, ADMIN_PASSWORD)
-                success = delete_client(session, client_id)
-
-                if success:
-                    await conn.execute('DELETE FROM keys WHERE client_id = $1', client_id)
-                    response_message = "Ключ был успешно удален."
-                else:
-                    response_message = "Ошибка при удалении клиента через API."
-
-            else:
-                response_message = "Ключ не найден или уже удален."
-
-            back_button = types.InlineKeyboardButton(text='Назад', callback_data='view_keys')
-            keyboard = types.InlineKeyboardMarkup(inline_keyboard=[[back_button]])
-
-            await bot.edit_message_text(response_message, chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=keyboard)
-
-        finally:
-            await conn.close()
-
-    except Exception as e:
-        await bot.edit_message_text(f"Ошибка при удалении ключа: {e}", chat_id=tg_id, message_id=callback_query.message.message_id)
-
-    await callback_query.answer()
-
-@router.callback_query(lambda c: c.data.startswith('renew_plan|'))
-async def process_callback_renew_plan(callback_query: types.CallbackQuery):
-    tg_id = callback_query.from_user.id
-    plan, client_id = callback_query.data.split('|')[1], callback_query.data.split('|')[2]  # '1', '3', '6' или '12' и client_id
-    days_to_extend = 30 * int(plan)  # Умножаем на количество месяцев (1 месяц = 30 дней)
-
-    try:
-        conn = await asyncpg.connect(DATABASE_URL)
-        try:
-            record = await conn.fetchrow('SELECT email, expiry_time FROM keys WHERE client_id = $1', client_id)
-
-            if record:
-                email = record['email']
-                expiry_time = record['expiry_time']
-                current_time = datetime.utcnow().timestamp() * 1000  # Текущее время в миллисекундах
-
-                # Проверяем, если ключ истек, то продлеваем от текущей даты, иначе продлеваем от текущей даты истечения
-                if expiry_time <= current_time:
-                    new_expiry_time = int(current_time + timedelta(days=days_to_extend).total_seconds() * 1000)
-                else:
-                    new_expiry_time = int(expiry_time + timedelta(days=days_to_extend).total_seconds() * 1000)
-
-                # Стоимость продления в зависимости от выбранного плана
-                if plan == '1':
-                    cost = 100
-                elif plan == '3':
-                    cost = 285
-                elif plan == '6':
-                    cost = 540  # Стоимость для 6 месяцев
-                elif plan == '12':
-                    cost = 1000  # Стоимость для 12 месяцев
-
-                balance = await get_balance(tg_id)
-                if balance < cost:
-                    replenish_button = types.InlineKeyboardButton(text='Пополнить баланс', callback_data='replenish_balance')
-                    back_button = types.InlineKeyboardButton(text='Назад', callback_data='view_profile')
-                    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[[replenish_button], [back_button]])
-
-                    await bot.edit_message_text("Недостаточно средств для продления ключа.", chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=keyboard)
-                    return
-
-                # Продлеваем ключ через API
-                session = login_with_credentials(ADMIN_USERNAME, ADMIN_PASSWORD)
-                success = extend_client_key(session, tg_id, client_id, email, new_expiry_time)
-
-                if success:
-                    # Обновляем баланс и ключ в базе данных
-                    await update_balance(tg_id, -cost)
-                    await conn.execute('UPDATE keys SET expiry_time = $1 WHERE client_id = $2', new_expiry_time, client_id)
-                    response_message = f"Ваш ключ был успешно продлен на {days_to_extend // 30} месяц(-а)."
-                    back_button = types.InlineKeyboardButton(text='Назад', callback_data='view_profile')
-                    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[[back_button]])
-                    await bot.edit_message_text(response_message, chat_id=tg_id, message_id=callback_query.message.message_id, reply_markup=keyboard)
-                else:
-                    await bot.edit_message_text("Ошибка при продлении ключа.", chat_id=tg_id, message_id=callback_query.message.message_id)
-            else:
-                await bot.edit_message_text("Ключ не найден.", chat_id=tg_id, message_id=callback_query.message.message_id)
-
-        finally:
-            await conn.close()
-
-    except Exception as e:
-        await bot.edit_message_text(f"Ошибка при продлении ключа: {e}", chat_id=tg_id, message_id=callback_query.message.message_id)
-
-    await callback_query.answer()
-
-
-async def handle_error(tg_id, callback_query, message):
-    await bot.edit_message_text(message, chat_id=tg_id, message_id=callback_query.message.message_id)

handlers/keys/__init__.py

@@ -0,0 +1,13 @@
+__all__ = ("router",)
+
+from aiogram import Router
+
+from .key_management import router as management_router
+from .keys import router as keys_router
+
+router = Router(name="keys_main_router")
+
+router.include_routers(
+    keys_router,
+    management_router,
+)

handlers/keys/key_management.py

@@ -0,0 +1,538 @@
+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
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from py3xui import AsyncApi
+
+from bot import bot
+from client import delete_client
+from config import (
+    ADMIN_PASSWORD,
+    ADMIN_USERNAME,
+    CONNECT_ANDROID,
+    CONNECT_IOS,
+    CONNECT_PHONE_BUTTON,
+    DOWNLOAD_ANDROID,
+    DOWNLOAD_IOS,
+    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,
+)
+from handlers.buttons.add_subscribe import (
+    DOWNLOAD_ANDROID_BUTTON,
+    DOWNLOAD_IOS_BUTTON,
+    IMPORT_ANDROID,
+    IMPORT_IOS,
+    PC_BUTTON,
+    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 DISCOUNTS, key_message_success
+from handlers.utils import edit_or_send_message, generate_random_email, get_least_loaded_cluster
+from logger import logger
+
+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}.")
+            updated = await update_trial(tg_id, 1, session)
+            if updated:
+                await edit_or_send_message(
+                    target_message=message_or_query if isinstance(message_or_query, Message) else message_or_query.message,
+                    text="⏳ Пожалуйста, подождите, создаем вам подключение...",
+                    reply_markup=None,  
+                )
+
+                await create_key(tg_id, expiry_time, state, session, message_or_query)
+                return
+            else:
+                logger.error(f"Не удалось обновить статус триального периода для пользователя {tg_id}.")
+
+    builder = InlineKeyboardBuilder()
+    for index, (plan_id, price) in enumerate(RENEWAL_PRICES.items()):
+        discount_text = ""
+        if 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="👤 Личный кабинет", 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="💳 Выберите тарифный план для создания нового ключа:",
+        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):
+    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="💳 Пополнить баланс", callback_data="pay"))
+            builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+            await edit_or_send_message(
+                target_message=callback_query.message,
+                text=f"💳 Недостаточно средств. Для продолжения необходимо пополнить баланс на {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="⏳ Подождите, создаем вам подключение...",
+        reply_markup=builder.as_markup(),
+    )
+
+    expiry_time = datetime.now(moscow_tz) + timedelta(days=duration_days)
+    await create_key(tg_id, expiry_time, None, session, callback_query, None, plan_id)
+    await update_balance(tg_id, -plan_price, session)
+
+
+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 FROM servers WHERE cluster_name = $1",
+            least_loaded_cluster,
+        )
+        countries = [server["server_name"] for server in servers]
+        logger.info(f"[Country Selection] Список серверов: {countries}")
+
+        builder = InlineKeyboardBuilder()
+        ts = int(expiry_time.timestamp())
+        for country in countries:
+            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="⬅️ Назад", callback_data="profile"))
+
+        if target_message:
+            await edit_or_send_message(
+                target_message=target_message,
+                text="🌍 Пожалуйста, выберите страну для вашего ключа:",
+                reply_markup=builder.as_markup(),
+                media_path=None,
+            )
+        else:
+            await bot.send_message(
+                chat_id=tg_id,
+                text="🌍 Пожалуйста, выберите страну для вашего ключа:",
+                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)
+        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,
+        )
+        await update_trial(tg_id, 1, 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()
+    builder.row(InlineKeyboardButton(text="💬 Поддержка", url=SUPPORT_CHAT_URL))
+    if CONNECT_PHONE_BUTTON:
+        builder.row(InlineKeyboardButton(text="📱 Подключить телефон", callback_data=f"connect_phone|{key_name}"))
+    else:
+        builder.row(
+            InlineKeyboardButton(text=DOWNLOAD_IOS_BUTTON, url=DOWNLOAD_IOS),
+            InlineKeyboardButton(text=DOWNLOAD_ANDROID_BUTTON, url=DOWNLOAD_ANDROID),
+        )
+        builder.row(
+            InlineKeyboardButton(text=IMPORT_IOS, url=f"{CONNECT_IOS}{public_link}"),
+            InlineKeyboardButton(text=IMPORT_ANDROID, url=f"{CONNECT_ANDROID}{public_link}"),
+        )
+    builder.row(
+        InlineKeyboardButton(text=PC_BUTTON, callback_data=f"connect_pc|{email}"),
+        InlineKeyboardButton(text=TV_BUTTON, callback_data=f"connect_tv|{email}"),
+    )
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", 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} 📅")
+
+    if target_message:
+        await edit_or_send_message(
+            target_message=target_message, text=key_message_text, reply_markup=builder.as_markup(), media_path=None
+        )
+    else:
+        await bot.send_message(
+            chat_id=tg_id,
+            text=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)
+
+        servers = await session.fetch("SELECT server_name FROM servers")
+        countries = [row["server_name"] for row in servers]
+        logger.info(f"Доступные страны для смены локации: {countries}")
+
+        builder = InlineKeyboardBuilder()
+        for country in countries:
+            callback_data = f"select_country|{country}|{ts}|{old_key_name}"
+            builder.row(InlineKeyboardButton(text=country, callback_data=callback_data))
+        builder.row(InlineKeyboardButton(text="⬅️ Назад", 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):
+    """
+    Обрабатывает выбор страны.
+    Формат 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, None, 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:
+        key_name = old_key_name
+    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_key_details = await get_key_details(old_key_name, session)
+            old_client_id = old_key_details.get("client_id") if old_key_details else None
+            old_email = old_key_details.get("email") if old_key_details else None
+            old_server_id = old_key_details.get("server_id") if old_key_details else None
+
+            if old_client_id and old_email and 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,
+                    )
+                    deletion_success = await delete_client(
+                        xui,
+                        old_server_info["inbound_id"],
+                        old_email,
+                        old_client_id,
+                    )
+                    if not deletion_success:
+                        raise ValueError(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 client_id = $1, email = $2, expiry_time = $3, key = $4, server_id = $5
+                WHERE tg_id = $6 AND email = $7
+                """,
+                client_id,
+                email,
+                expiry_timestamp,
+                public_link,
+                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,
+            )
+
+    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="💬 Поддержка", url=SUPPORT_CHAT_URL))
+    if CONNECT_PHONE_BUTTON:
+        builder.row(InlineKeyboardButton(text="📱 Подключить телефон", callback_data=f"connect_phone|{key_name}"))
+    else:
+        builder.row(
+            InlineKeyboardButton(text=DOWNLOAD_IOS_BUTTON, url=DOWNLOAD_IOS),
+            InlineKeyboardButton(text=DOWNLOAD_ANDROID_BUTTON, url=DOWNLOAD_ANDROID),
+        )
+        builder.row(
+            InlineKeyboardButton(text=IMPORT_IOS, url=f"{CONNECT_IOS}{public_link}"),
+            InlineKeyboardButton(text=IMPORT_ANDROID, url=f"{CONNECT_ANDROID}{public_link}"),
+        )
+    builder.row(
+        InlineKeyboardButton(text=PC_BUTTON, callback_data=f"connect_pc|{email}"),
+        InlineKeyboardButton(text=TV_BUTTON, callback_data=f"connect_tv|{email}"),
+    )
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", 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} 📅")
+
+    await edit_or_send_message(
+        target_message=callback_query.message, text=key_message_text, reply_markup=builder.as_markup(), media_path=None
+    )
+
+    if state:
+        await state.clear()

handlers/keys/key_utils.py

@@ -0,0 +1,459 @@
+import asyncio
+from typing import Any
+
+from py3xui import AsyncApi
+
+from client import ClientConfig, add_client, delete_client, extend_client_key, get_client_traffic, toggle_client
+from config import ADMIN_PASSWORD, ADMIN_USERNAME, LIMIT_IP, PUBLIC_LINK, SUPERNODE, TOTAL_GB, USE_COUNTRY_SELECTION
+from database import get_servers, store_key
+from handlers.utils import get_least_loaded_cluster
+from logger import logger
+
+
+async def create_key_on_cluster(
+    cluster_id: str, tg_id: int, client_id: str, email: str, expiry_timestamp: int, plan: int = None
+):
+    """
+    Создает ключ на всех серверах указанного кластера (или на конкретном сервере, если cluster_id — это имя сервера).
+    """
+    try:
+        servers = await get_servers()
+        cluster = servers.get(cluster_id)
+
+        if not cluster:
+            found_servers = []
+            for _key, server_list in servers.items():
+                for server_info in server_list:
+                    if server_info.get("server_name", "").lower() == cluster_id.lower():
+                        found_servers.append(server_info)
+            if found_servers:
+                cluster = found_servers
+            else:
+                raise ValueError(f"Кластер или сервер с ID/именем {cluster_id} не найден.")
+
+        semaphore = asyncio.Semaphore(2)
+
+        if SUPERNODE:
+            for server_info in cluster:
+                await create_client_on_server(
+                    server_info, tg_id, client_id, email, expiry_timestamp, semaphore, plan=plan
+                )
+        else:
+            await asyncio.gather(
+                *(
+                    create_client_on_server(server, tg_id, client_id, email, expiry_timestamp, semaphore, plan=plan)
+                    for server in cluster
+                )
+            )
+
+    except Exception as e:
+        logger.error(f"Ошибка при создании ключа: {e}")
+        raise e
+
+
+async def create_client_on_server(
+    server_info: dict,
+    tg_id: int,
+    client_id: str,
+    email: str,
+    expiry_timestamp: int,
+    semaphore: asyncio.Semaphore,
+    plan: int = None,
+):
+    """
+    Создает клиента на указанном сервере.
+    """
+    async with semaphore:
+        xui = AsyncApi(
+            server_info["api_url"],
+            username=ADMIN_USERNAME,
+            password=ADMIN_PASSWORD,
+        )
+
+        inbound_id = server_info.get("inbound_id")
+        server_name = server_info.get("server_name", "unknown")
+
+        if not inbound_id:
+            logger.warning(f"INBOUND_ID отсутствует для сервера {server_name}. Пропуск.")
+            return
+
+        if SUPERNODE:
+            unique_email = f"{email}_{server_name.lower()}"
+            sub_id = email
+        else:
+            unique_email = email
+            sub_id = unique_email
+
+        total_gb_value = int(TOTAL_GB) if plan is None else int(plan) * int(TOTAL_GB)
+
+        await add_client(
+            xui,
+            ClientConfig(
+                client_id=client_id,
+                email=unique_email,
+                tg_id=tg_id,
+                limit_ip=LIMIT_IP,
+                total_gb=total_gb_value,
+                expiry_time=expiry_timestamp,
+                enable=True,
+                flow="xtls-rprx-vision",
+                inbound_id=int(inbound_id),
+                sub_id=sub_id,
+            ),
+        )
+
+        if SUPERNODE:
+            await asyncio.sleep(0.7)
+
+
+async def renew_key_in_cluster(cluster_id, email, client_id, new_expiry_time, total_gb):
+    try:
+        servers = await get_servers()
+        cluster = servers.get(cluster_id)
+
+        if not cluster:
+            found_servers = []
+            for _key, server_list in servers.items():
+                for server_info in server_list:
+                    if server_info.get("server_name", "").lower() == cluster_id.lower():
+                        found_servers.append(server_info)
+            if found_servers:
+                cluster = found_servers
+            else:
+                raise ValueError(f"Кластер или сервер с ID/именем {cluster_id} не найден.")
+
+        tasks = []
+        for server_info in cluster:
+            xui = AsyncApi(
+                server_info["api_url"],
+                username=ADMIN_USERNAME,
+                password=ADMIN_PASSWORD,
+            )
+
+            inbound_id = server_info.get("inbound_id")
+            server_name = server_info.get("server_name", "unknown")
+
+            if not inbound_id:
+                logger.warning(f"INBOUND_ID отсутствует для сервера {server_name}. Пропуск.")
+                continue
+
+            if SUPERNODE:
+                unique_email = f"{email}_{server_name.lower()}"
+                sub_id = email
+            else:
+                unique_email = email
+                sub_id = unique_email
+
+            tasks.append(
+                extend_client_key(xui, int(inbound_id), unique_email, new_expiry_time, client_id, total_gb, sub_id)
+            )
+
+        await asyncio.gather(*tasks)
+
+    except Exception as e:
+        logger.error(f"Не удалось продлить ключ {client_id} в кластере/на сервере {cluster_id}: {e}")
+        raise e
+
+
+async def delete_key_from_cluster(cluster_id, email, client_id):
+    """Удаление ключа с серверов в кластере или с конкретного сервера"""
+    try:
+        servers = await get_servers()
+        cluster = servers.get(cluster_id)
+
+        if not cluster:
+            found_servers = []
+            for _, server_list in servers.items():
+                for server_info in server_list:
+                    if server_info.get("server_name", "").lower() == cluster_id.lower():
+                        found_servers.append(server_info)
+
+            if found_servers:
+                cluster = found_servers
+            else:
+                raise ValueError(f"Кластер или сервер с ID/именем {cluster_id} не найден.")
+
+        tasks = []
+        for server_info in cluster:
+            xui = AsyncApi(
+                server_info["api_url"],
+                username=ADMIN_USERNAME,
+                password=ADMIN_PASSWORD,
+            )
+
+            inbound_id = server_info.get("inbound_id")
+            if not inbound_id:
+                logger.warning(
+                    f"INBOUND_ID отсутствует для сервера {server_info.get('server_name', 'unknown')}. Пропуск."
+                )
+                continue
+
+            tasks.append(
+                delete_client(
+                    xui,
+                    int(inbound_id),
+                    email,
+                    client_id,
+                )
+            )
+
+        await asyncio.gather(*tasks)
+
+    except Exception as e:
+        logger.error(f"Не удалось удалить ключ {client_id} в кластере/на сервере {cluster_id}: {e}")
+        raise e
+
+
+async def update_key_on_cluster(tg_id, client_id, email, expiry_time, cluster_id):
+    """
+    Обновляет ключ на всех серверах указанного кластера (или сервера, если передано имя).
+    """
+    try:
+        servers = await get_servers()
+        cluster = servers.get(cluster_id)
+
+        if not cluster:
+            found_servers = []
+            for _key, server_list in servers.items():
+                for server_info in server_list:
+                    if server_info.get("server_name", "").lower() == cluster_id.lower():
+                        found_servers.append(server_info)
+            if found_servers:
+                cluster = found_servers
+            else:
+                raise ValueError(f"Кластер или сервер с ID/именем {cluster_id} не найден.")
+
+        tasks = []
+        for server_info in cluster:
+            xui = AsyncApi(
+                server_info["api_url"],
+                username=ADMIN_USERNAME,
+                password=ADMIN_PASSWORD,
+            )
+
+            inbound_id = server_info.get("inbound_id")
+            if not inbound_id:
+                logger.warning(
+                    f"INBOUND_ID отсутствует для сервера {server_info.get('server_name', 'unknown')}. Пропуск."
+                )
+                continue
+
+            tasks.append(
+                add_client(
+                    xui,
+                    ClientConfig(
+                        client_id=client_id,
+                        email=email,
+                        tg_id=tg_id,
+                        limit_ip=LIMIT_IP,
+                        total_gb=TOTAL_GB,
+                        expiry_time=expiry_time,
+                        enable=True,
+                        flow="xtls-rprx-vision",
+                        inbound_id=int(inbound_id),
+                        sub_id=email,
+                    ),
+                )
+            )
+
+        await asyncio.gather(*tasks)
+
+        logger.info(f"Ключ успешно обновлен для {client_id} на всех серверах в кластере {cluster_id}")
+
+    except Exception as e:
+        logger.error(f"Ошибка при обновлении ключа на серверах кластера {cluster_id} для {client_id}: {e}")
+        raise e
+
+
+async def update_subscription(tg_id: int, email: str, session: Any) -> None:
+    record = await session.fetchrow(
+        """
+        SELECT k.key, k.expiry_time, k.email, k.server_id, k.client_id
+        FROM keys k
+        WHERE k.tg_id = $1 AND k.email = $2
+        """,
+        tg_id,
+        email,
+    )
+
+    if not record:
+        raise ValueError(f"The key {email} does not exist in database")
+
+    expiry_time = record["expiry_time"]
+    client_id = record["client_id"]
+    public_link = f"{PUBLIC_LINK}{email}/{tg_id}"
+
+    await session.execute(
+        """
+        DELETE FROM keys
+        WHERE tg_id = $1 AND email = $2
+        """,
+        tg_id,
+        email,
+    )
+
+    least_loaded_cluster_id = await get_least_loaded_cluster()
+
+    await asyncio.gather(
+        update_key_on_cluster(
+            tg_id,
+            client_id,
+            email,
+            expiry_time,
+            least_loaded_cluster_id,
+        )
+    )
+
+    await store_key(
+        tg_id,
+        client_id,
+        email,
+        expiry_time,
+        public_link,
+        server_id=least_loaded_cluster_id,
+        session=session,
+    )
+
+
+async def get_user_traffic(session: Any, tg_id: int, email: str) -> dict[str, Any]:
+    """
+    Получает трафик пользователя на всех серверах, где у него есть ключ.
+
+    Args:
+        session (Any): Сессия базы данных.
+        tg_id (int): ID пользователя Telegram.
+        email (str): Email пользователя.
+
+    Returns:
+        dict[str, Any]: Структура с данными о трафике.
+    """
+
+    query = "SELECT client_id, server_id FROM keys WHERE tg_id = $1 AND email = $2"
+    rows = await session.fetch(query, tg_id, email)
+
+    if not rows:
+        return {"status": "error", "message": "❌ У пользователя нет активных ключей."}
+
+    server_ids = {row["server_id"] for row in rows}
+
+    query_servers = """
+        SELECT server_name, api_url FROM servers 
+        WHERE server_name = ANY($1) OR cluster_name = ANY($1)
+    """
+    server_rows = await session.fetch(query_servers, list(server_ids))
+
+    if not server_rows:
+        logger.error(f"❌ Не найдено серверов для: {server_ids}")
+        return {"status": "error", "message": f"❌ Серверы не найдены: {', '.join(server_ids)}"}
+
+    servers_map = {row["server_name"]: row["api_url"] for row in server_rows}
+
+    user_traffic_data = {}
+
+    async def fetch_traffic(api_url: str, client_id: str, server: str) -> tuple[str, Any]:
+        """
+        Получает трафик с сервера для заданного client_id.
+        Возвращает кортеж: (server, used_gb) или (server, ошибка).
+        """
+        xui = AsyncApi(api_url, username=ADMIN_USERNAME, password=ADMIN_PASSWORD)
+        try:
+            traffic_info = await get_client_traffic(xui, client_id)
+            if traffic_info["status"] == "success" and traffic_info["traffic"]:
+                client_data = traffic_info["traffic"][0]
+                used_gb = (client_data.up + client_data.down) / 1073741824
+                return server, round(used_gb, 2)
+            else:
+                return server, "Ошибка получения трафика"
+        except Exception as e:
+            return server, f"Ошибка: {e}"
+
+    tasks = []
+    for row in rows:
+        client_id = row["client_id"]
+        server_id = row["server_id"]
+        if server_id in servers_map:
+            api_url = servers_map[server_id]
+            tasks.append(fetch_traffic(api_url, client_id, server_id))
+        else:
+            for server, api_url in servers_map.items():
+                tasks.append(fetch_traffic(api_url, client_id, server))
+
+    results = await asyncio.gather(*tasks)
+    for server, result in results:
+        user_traffic_data[server] = result
+
+    return {"status": "success", "traffic": user_traffic_data}
+
+
+async def toggle_client_on_cluster(cluster_id: str, email: str, client_id: str, enable: bool = True) -> dict[str, Any]:
+    """
+    Включает или отключает клиента на всех серверах указанного кластера.
+
+    Args:
+        cluster_id (str): ID кластера или имя сервера
+        email (str): Email клиента
+        client_id (str): UUID клиента
+        enable (bool): True для включения, False для отключения
+
+    Returns:
+        dict[str, Any]: Результат операции с информацией по каждому серверу
+    """
+    try:
+        servers = await get_servers()
+        cluster = servers.get(cluster_id)
+
+        if not cluster:
+            found_servers = []
+            for _, server_list in servers.items():
+                for server_info in server_list:
+                    if server_info.get("server_name", "").lower() == cluster_id.lower():
+                        found_servers.append(server_info)
+
+            if found_servers:
+                cluster = found_servers
+            else:
+                raise ValueError(f"Кластер или сервер с ID/именем {cluster_id} не найден.")
+
+        results = {}
+        tasks = []
+
+        for server_info in cluster:
+            xui = AsyncApi(
+                server_info["api_url"],
+                username=ADMIN_USERNAME,
+                password=ADMIN_PASSWORD,
+            )
+
+            inbound_id = server_info.get("inbound_id")
+            server_name = server_info.get("server_name", "unknown")
+
+            if not inbound_id:
+                logger.warning(f"INBOUND_ID отсутствует для сервера {server_name}. Пропуск.")
+                results[server_name] = False
+                continue
+
+            if SUPERNODE:
+                unique_email = f"{email}_{server_name.lower()}"
+            else:
+                unique_email = email
+
+            tasks.append(toggle_client(xui, int(inbound_id), unique_email, client_id, enable))
+
+        task_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        for server_info, result in zip(cluster, task_results, strict=False):
+            server_name = server_info.get("server_name", "unknown")
+            if isinstance(result, Exception):
+                logger.error(f"Ошибка на сервере {server_name}: {result}")
+                results[server_name] = False
+            else:
+                results[server_name] = result
+
+        status = "включен" if enable else "отключен"
+        logger.info(f"Клиент {email} {status} на серверах кластера {cluster_id}")
+
+        return {"status": "success" if any(results.values()) else "error", "results": results}
+
+    except Exception as e:
+        logger.error(f"Ошибка при изменении состояния клиента {email} в кластере {cluster_id}: {e}")
+        return {"status": "error", "error": str(e)}

handlers/keys/keys.py

@@ -0,0 +1,554 @@
+import asyncio
+import locale
+import os
+from datetime import datetime, timedelta
+from typing import Any
+
+import asyncpg
+import pytz
+from aiogram import F, Router, types
+from aiogram.types import CallbackQuery, InlineKeyboardButton, Message
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from bot import bot
+from config import (
+    CONNECT_ANDROID,
+    CONNECT_IOS,
+    CONNECT_PHONE_BUTTON,
+    DATABASE_URL,
+    DOWNLOAD_ANDROID,
+    DOWNLOAD_IOS,
+    ENABLE_DELETE_KEY_BUTTON,
+    ENABLE_UPDATE_SUBSCRIPTION_BUTTON,
+    PUBLIC_LINK,
+    RENEWAL_PLANS,
+    TOTAL_GB,
+    USE_COUNTRY_SELECTION,
+    USE_NEW_PAYMENT_FLOW,
+)
+from database import (
+    check_server_name_by_cluster,
+    create_temporary_data,
+    delete_key,
+    get_balance,
+    get_key_by_server,
+    get_key_details,
+    get_keys,
+    get_servers,
+    update_balance,
+    update_key_expiry,
+)
+from handlers.buttons.add_subscribe import (
+    DOWNLOAD_ANDROID_BUTTON,
+    DOWNLOAD_IOS_BUTTON,
+    IMPORT_ANDROID,
+    IMPORT_IOS,
+    PC_BUTTON,
+    TV_BUTTON,
+)
+from handlers.keys.key_utils import (
+    delete_key_from_cluster,
+    renew_key_in_cluster,
+    update_subscription,
+)
+from handlers.payments.robokassa_pay import handle_custom_amount_input
+from handlers.payments.yookassa_pay import process_custom_amount_input
+from handlers.texts import (
+    DISCOUNTS,
+    KEY_NOT_FOUND_MSG,
+    PLAN_SELECTION_MSG,
+    SUBSCRIPTION_DESCRIPTION,
+    SUCCESS_RENEWAL_MSG,
+    key_message,
+)
+from handlers.utils import edit_or_send_message, handle_error
+from logger import logger
+
+locale.setlocale(locale.LC_TIME, "ru_RU.UTF-8")
+
+router = Router()
+
+
+@router.callback_query(F.data == "view_keys")
+@router.message(F.text == "/subs")
+async def process_callback_or_message_view_keys(callback_query_or_message: Message | CallbackQuery, session: Any):
+    if isinstance(callback_query_or_message, CallbackQuery):
+        target_message = callback_query_or_message.message
+    else:
+        target_message = callback_query_or_message
+
+    try:
+        records = await get_keys(target_message.chat.id, session)
+        inline_keyboard, response_message = build_keys_response(records)
+        image_path = os.path.join("img", "pic_keys.jpg")
+
+        await edit_or_send_message(
+            target_message=target_message, text=response_message, reply_markup=inline_keyboard, media_path=image_path
+        )
+    except Exception as e:
+        error_message = f"Ошибка при получении ключей: {e}"
+        await target_message.answer(text=error_message)
+
+
+def build_keys_response(records):
+    """
+    Формирует сообщение и клавиатуру для устройств с указанием срока действия подписки.
+    """
+    builder = InlineKeyboardBuilder()
+    moscow_tz = pytz.timezone("Europe/Moscow")
+
+    if records:
+        response_message = "<b>🔑 Список ваших подписок:</b>\n\n<blockquote>"
+        for record in records:
+            key_name = record["email"]
+            expiry_time = record.get("expiry_time")
+
+            if expiry_time:
+                expiry_date_full = datetime.fromtimestamp(expiry_time / 1000, tz=moscow_tz)
+                formatted_date_full = expiry_date_full.strftime("до %d.%m.%y, %H:%M")
+                formatted_date_short = expiry_date_full.strftime("до %d.%m.%y")
+            else:
+                formatted_date_full = "без срока действия"
+                formatted_date_short = "без срока действия"
+
+            button_text = f"🔑{key_name} ({formatted_date_short})"
+            builder.row(InlineKeyboardButton(text=button_text, callback_data=f"view_key|{key_name}"))
+
+            response_message += f"• <b>{key_name}</b> ({formatted_date_full})\n"
+
+        response_message += "</blockquote>\n"
+
+    else:
+        response_message = (
+            "<b>🔑 У вас пока нет подписок.</b>\n\nВы можете создать новую подписку для подключения устройств."
+        )
+
+    builder.row(InlineKeyboardButton(text="➕ Добавить подписку", callback_data="create_key"))
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    inline_keyboard = builder.as_markup()
+    return inline_keyboard, response_message
+
+
+@router.callback_query(F.data.startswith("view_key|"))
+async def process_callback_view_key(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(key_name, session)
+        if record:
+            key = record["key"]
+            expiry_time = record["expiry_time"]
+            server_name = record["server_id"]
+            country = server_name
+            expiry_date = datetime.utcfromtimestamp(expiry_time / 1000)
+            current_date = datetime.utcnow()
+            time_left = expiry_date - current_date
+
+            if time_left.total_seconds() <= 0:
+                days_left_message = "<b>🕒 Статус подписки:</b>\n🔴 Истекла\nОсталось часов: 0\nОсталось минут: 0"
+            else:
+                total_seconds = int(time_left.total_seconds())
+                days = total_seconds // 86400
+                hours = (total_seconds % 86400) // 3600
+                minutes = (total_seconds % 3600) // 60
+                days_left_message = f"Осталось: <b>{days}</b> дней, <b>{hours}</b> часов, <b>{minutes}</b> минут"
+
+            formatted_expiry_date = expiry_date.strftime("%d %B %Y года")
+            response_message = key_message(
+                key, formatted_expiry_date, days_left_message, server_name, country if USE_COUNTRY_SELECTION else None
+            )
+
+            builder = InlineKeyboardBuilder()
+
+            if not key.startswith(PUBLIC_LINK) or ENABLE_UPDATE_SUBSCRIPTION_BUTTON:
+                builder.row(
+                    InlineKeyboardButton(
+                        text="🔄 Обновить подписку",
+                        callback_data=f"update_subscription|{key_name}",
+                    )
+                )
+
+            if CONNECT_PHONE_BUTTON:
+                builder.row(
+                    InlineKeyboardButton(text="📱 Подключить телефон", callback_data=f"connect_phone|{key_name}")
+                )
+            else:
+                builder.row(
+                    InlineKeyboardButton(text=DOWNLOAD_IOS_BUTTON, url=DOWNLOAD_IOS),
+                    InlineKeyboardButton(text=DOWNLOAD_ANDROID_BUTTON, url=DOWNLOAD_ANDROID),
+                )
+                builder.row(
+                    InlineKeyboardButton(text=IMPORT_IOS, url=f"{CONNECT_IOS}{key}"),
+                    InlineKeyboardButton(text=IMPORT_ANDROID, url=f"{CONNECT_ANDROID}{key}"),
+                )
+
+            builder.row(
+                InlineKeyboardButton(text=PC_BUTTON, callback_data=f"connect_pc|{key_name}"),
+                InlineKeyboardButton(text=TV_BUTTON, callback_data=f"connect_tv|{key_name}"),
+            )
+
+            if ENABLE_DELETE_KEY_BUTTON:
+                builder.row(
+                    InlineKeyboardButton(text="⏳ Продлить", callback_data=f"renew_key|{key_name}"),
+                    InlineKeyboardButton(text="❌ Удалить", callback_data=f"delete_key|{key_name}"),
+                )
+            else:
+                builder.row(InlineKeyboardButton(text="⏳ Продлить подписку", callback_data=f"renew_key|{key_name}"))
+
+            if USE_COUNTRY_SELECTION:
+                builder.row(
+                    InlineKeyboardButton(text="🌍 Сменить локацию", callback_data=f"change_location|{key_name}")
+                )
+
+            builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data="view_keys"))
+            builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+            keyboard = builder.as_markup()
+            image_path = os.path.join("img", "pic_view.jpg")
+
+            if not os.path.isfile(image_path):
+                await callback_query.message.answer("Файл изображения не найден.")
+                return
+
+            await edit_or_send_message(
+                target_message=callback_query.message,
+                text=response_message,
+                reply_markup=keyboard,
+                media_path=image_path,
+            )
+        else:
+            await callback_query.message.answer(text="<b>Информация о подписке не найдена.</b>")
+    except Exception as e:
+        await handle_error(
+            tg_id,
+            callback_query,
+            f"Ошибка при получении информации о ключе: {e}",
+        )
+
+
+@router.callback_query(F.data.startswith("connect_phone|"))
+async def process_callback_connect_phone(callback_query: CallbackQuery):
+    email = callback_query.data.split("|")[1]
+
+    conn = None
+    try:
+        conn = await asyncpg.connect(DATABASE_URL)
+        key_data = await conn.fetchrow(
+            """
+            SELECT key FROM keys WHERE email = $1
+            """,
+            email,
+        )
+        if not key_data:
+            await callback_query.message.answer("❌ Ошибка: ключ не найден.")
+            return
+
+        key_link = key_data["key"]
+
+    except Exception as e:
+        logger.error(f"Ошибка при получении ключа для {email}: {e}")
+        await callback_query.message.answer("❌ Произошла ошибка. Попробуйте позже.")
+        return
+    finally:
+        if conn:
+            await conn.close()
+
+    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),
+    )
+    builder.row(
+        InlineKeyboardButton(text=IMPORT_IOS, url=f"{CONNECT_IOS}{key_link}"),
+        InlineKeyboardButton(text=IMPORT_ANDROID, url=f"{CONNECT_ANDROID}{key_link}"),
+    )
+    builder.row(InlineKeyboardButton(text="📖 Ручная установка", callback_data="instructions"))
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", 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("update_subscription|"))
+async def process_callback_update_subscription(callback_query: CallbackQuery, session: Any):
+    tg_id = callback_query.message.chat.id
+    email = callback_query.data.split("|")[1]
+
+    try:
+        await update_subscription(tg_id, email, session)
+        await process_callback_view_key(callback_query, session)
+    except Exception as e:
+        logger.error(f"Ошибка при обновлении ключа {email} пользователем: {e}")
+        await handle_error(tg_id, callback_query, f"Ошибка при обновлении подписки: {e}")
+
+
+@router.callback_query(F.data.startswith("delete_key|"))
+async def process_callback_delete_key(callback_query: CallbackQuery):
+    client_id = callback_query.data.split("|")[1]
+    try:
+        confirmation_keyboard = types.InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    types.InlineKeyboardButton(
+                        text="✅ Да, удалить",
+                        callback_data=f"confirm_delete|{client_id}",
+                    )
+                ],
+                [types.InlineKeyboardButton(text="❌ Нет, отменить", callback_data="view_keys")],
+            ]
+        )
+
+        if callback_query.message.caption:
+            await callback_query.message.edit_caption(
+                caption="<b>Вы уверены, что хотите удалить ключ?</b>", reply_markup=confirmation_keyboard
+            )
+        else:
+            await callback_query.message.edit_text(
+                text="<b>Вы уверены, что хотите удалить ключ?</b>", reply_markup=confirmation_keyboard
+            )
+
+    except Exception as e:
+        logger.error(f"Ошибка при обработке запроса на удаление ключа {client_id}: {e}")
+
+
+@router.callback_query(F.data.startswith("renew_key|"))
+async def process_callback_renew_key(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(key_name, session)
+        if record:
+            client_id = record["client_id"]
+            expiry_time = record["expiry_time"]
+
+            builder = InlineKeyboardBuilder()
+
+            for plan_id, plan_details in RENEWAL_PLANS.items():
+                months = plan_details["months"]
+                price = plan_details["price"]
+                discount = DISCOUNTS.get(plan_id, 0)
+                button_text = f"📅 {months} месяц{'а' if months > 1 else ''} ({price} руб.)" + (
+                    f" {discount}% скидка" if discount > 0 else ""
+                )
+                builder.row(
+                    InlineKeyboardButton(
+                        text=button_text,
+                        callback_data=f"renew_plan|{months}|{client_id}",
+                    )
+                )
+
+            builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data="view_keys"))
+
+            balance = await get_balance(tg_id)
+
+            response_message = PLAN_SELECTION_MSG.format(
+                balance=balance,
+                expiry_date=datetime.utcfromtimestamp(expiry_time / 1000).strftime("%Y-%m-%d %H:%M:%S"),
+            )
+
+            await edit_or_send_message(
+                target_message=callback_query.message,
+                text=response_message,
+                reply_markup=builder.as_markup(),
+                media_path=None,
+            )
+        else:
+            await callback_query.message.answer("<b>Ключ не найден.</b>")
+    except Exception as e:
+        logger.error(e)
+
+
+@router.callback_query(F.data.startswith("confirm_delete|"))
+async def process_callback_confirm_delete(callback_query: CallbackQuery, session: Any):
+    email = callback_query.data.split("|")[1]
+    try:
+        record = await get_key_details(email, session)
+        if record:
+            client_id = record["client_id"]
+            response_message = "Ключ успешно удален."
+            back_button = types.InlineKeyboardButton(text="Назад", callback_data="view_keys")
+            keyboard = types.InlineKeyboardMarkup(inline_keyboard=[[back_button]])
+
+            await delete_key(client_id, session)
+
+            await edit_or_send_message(
+                target_message=callback_query.message, text=response_message, reply_markup=keyboard, media_path=None
+            )
+
+            servers = await get_servers(session)
+
+            async def delete_key_from_servers():
+                try:
+                    tasks = []
+                    for cluster_id, _cluster in servers.items():
+                        tasks.append(delete_key_from_cluster(cluster_id, email, client_id))
+                    await asyncio.gather(*tasks)
+                except Exception as e:
+                    logger.error(f"Ошибка при удалении ключа {client_id}: {e}")
+
+            asyncio.create_task(delete_key_from_servers())
+
+            await delete_key(client_id, session)
+        else:
+            response_message = "Ключ не найден или уже удален."
+            back_button = types.InlineKeyboardButton(text="Назад", callback_data="view_keys")
+            keyboard = types.InlineKeyboardMarkup(inline_keyboard=[[back_button]])
+            await edit_or_send_message(
+                target_message=callback_query.message, text=response_message, reply_markup=keyboard, media_path=None
+            )
+    except Exception as e:
+        logger.error(e)
+
+
+@router.callback_query(F.data.startswith("renew_plan|"))
+async def process_callback_renew_plan(callback_query: CallbackQuery, session: Any):
+    tg_id = callback_query.message.chat.id
+    plan, client_id = callback_query.data.split("|")[1], callback_query.data.split("|")[2]
+    days_to_extend = 30 * int(plan)
+
+    gb_multiplier = {"1": 1, "3": 3, "6": 6, "12": 12}
+    total_gb = TOTAL_GB * gb_multiplier.get(plan, 1) if TOTAL_GB > 0 else 0
+
+    try:
+        record = await get_key_by_server(tg_id, client_id, session)
+
+        if record:
+            email = record["email"]
+            expiry_time = record["expiry_time"]
+            current_time = datetime.utcnow().timestamp() * 1000
+
+            if expiry_time <= current_time:
+                new_expiry_time = int(current_time + timedelta(days=days_to_extend).total_seconds() * 1000)
+            else:
+                new_expiry_time = int(expiry_time + timedelta(days=days_to_extend).total_seconds() * 1000)
+
+            cost = RENEWAL_PLANS[plan]["price"]
+            balance = await get_balance(tg_id)
+
+            if balance < cost:
+                required_amount = cost - balance
+
+                logger.info(
+                    f"[RENEW] Пользователю {tg_id} не хватает {required_amount}₽. Запуск доплаты через {USE_NEW_PAYMENT_FLOW}"
+                )
+
+                await create_temporary_data(
+                    session,
+                    tg_id,
+                    "waiting_for_renewal_payment",
+                    {
+                        "plan": plan,
+                        "client_id": client_id,
+                        "cost": cost,
+                        "required_amount": required_amount,
+                        "new_expiry_time": new_expiry_time,
+                        "total_gb": total_gb,
+                        "email": email,
+                    },
+                )
+
+                if USE_NEW_PAYMENT_FLOW == "YOOKASSA":
+                    logger.info(f"[RENEW] Запуск оплаты через Юкассу для пользователя {tg_id}")
+                    await process_custom_amount_input(callback_query, session)
+                elif USE_NEW_PAYMENT_FLOW == "ROBOKASSA":
+                    logger.info(f"[RENEW] Запуск оплаты через Робокассу для пользователя {tg_id}")
+                    await handle_custom_amount_input(callback_query, session)
+                else:
+                    logger.info(f"[RENEW] Отправка сообщения о доплате пользователю {tg_id}")
+                    builder = InlineKeyboardBuilder()
+                    builder.row(InlineKeyboardButton(text="💳 Пополнить баланс", callback_data="pay"))
+                    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+                    await edit_or_send_message(
+                        target_message=callback_query.message,
+                        text=f"💳 Недостаточно средств. Пополните баланс на {required_amount}₽.",
+                        reply_markup=builder.as_markup(),
+                        media_path=None,
+                    )
+                return
+
+            logger.info(f"[RENEW] Средств достаточно. Продление ключа для пользователя {tg_id}")
+            await complete_key_renewal(tg_id, client_id, email, new_expiry_time, total_gb, cost, callback_query, plan)
+
+        else:
+            await callback_query.message.answer(KEY_NOT_FOUND_MSG)
+            logger.error(f"[RENEW] Ключ с client_id={client_id} не найден.")
+    except Exception as e:
+        logger.error(f"[RENEW] Ошибка при продлении ключа для пользователя {tg_id}: {e}")
+
+
+async def complete_key_renewal(tg_id, client_id, email, new_expiry_time, total_gb, cost, callback_query, plan):
+    logger.info(
+        f"[RENEW] Начинаю процесс продления ключа с параметрами: "
+        f"tg_id={tg_id}, client_id={client_id}, email={email}, "
+        f"new_expiry_time={new_expiry_time}, total_gb={total_gb}, cost={cost}, "
+        f"callback_query={'есть' if callback_query else 'отсутствует'}, plan={plan}"
+    )
+
+    response_message = SUCCESS_RENEWAL_MSG.format(months=plan)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    if callback_query:
+        try:
+            await edit_or_send_message(
+                target_message=callback_query.message,
+                text=response_message,
+                reply_markup=builder.as_markup(),
+                media_path=None,
+            )
+        except Exception as e:
+            logger.error(f"Ошибка редактирования сообщения в complete_key_renewal: {e}")
+            await callback_query.message.answer(response_message, reply_markup=builder.as_markup())
+    else:
+        await bot.send_message(tg_id, response_message, reply_markup=builder.as_markup())
+
+    conn = await asyncpg.connect(DATABASE_URL)
+
+    logger.info(f"[RENEW] Получение данных о ключе для email: {email}")
+    key_info = await get_key_details(email, conn)
+    if not key_info:
+        logger.error(f"[RENEW] Ключ с client_id {client_id} для пользователя {tg_id} не найден.")
+        await conn.close()
+        return
+
+    server_id = key_info["server_id"]
+
+    if USE_COUNTRY_SELECTION:
+        logger.info(f"[RENEW] USE_COUNTRY_SELECTION включён. Проверяю информацию о сервере {server_id}")
+        cluster_info = await check_server_name_by_cluster(server_id, conn)
+        if not cluster_info:
+            logger.error(f"[RENEW] Сервер {server_id} не найден в таблице servers.")
+            await conn.close()
+            return
+        cluster_id = cluster_info["cluster_name"]
+        logger.info(f"[RENEW] Информация о сервере получена: {cluster_info}. Использую cluster_id: {cluster_id}")
+    else:
+        cluster_id = server_id
+        logger.info(f"[RENEW] USE_COUNTRY_SELECTION выключен. Использую server_id в качестве cluster_id: {cluster_id}")
+
+    logger.info(f"[RENEW] Запуск продления ключа для пользователя {tg_id} на {plan} мес. в кластере {cluster_id}.")
+
+    async def renew_key_on_cluster():
+        logger.info(
+            f"[RENEW] Запуск renew_key_on_cluster с параметрами: "
+            f"cluster_id={cluster_id}, email={email}, client_id={client_id}, "
+            f"new_expiry_time={new_expiry_time}, total_gb={total_gb}"
+        )
+        await renew_key_in_cluster(cluster_id, email, client_id, new_expiry_time, total_gb)
+        logger.info("[RENEW] Продление ключа на сервере завершено. Обновляю срок действия в базе данных.")
+        await update_key_expiry(client_id, new_expiry_time, conn)
+        logger.info("[RENEW] Срок действия ключа обновлён. Обновляю баланс пользователя.")
+        await update_balance(tg_id, -cost, conn)
+        logger.info(f"[RENEW] Ключ {client_id} успешно продлён на {plan} мес. для пользователя {tg_id}.")
+
+    logger.info("[RENEW] Инициализация процесса продления ключа в кластере.")
+    await renew_key_on_cluster()
+
+    logger.info("[RENEW] Процесс продления ключа завершён. Закрываю соединение с базой данных.")
+    await conn.close()

handlers/keys/subscriptions.py

@@ -0,0 +1,378 @@
+import asyncio
+import base64
+import random
+import re
+import time
+import urllib.parse
+from datetime import datetime
+
+import aiohttp
+import asyncpg
+import pytz
+from aiohttp import web
+
+from config import (
+    DATABASE_URL,
+    PROJECT_NAME,
+    SUB_MESSAGE,
+    SUPERNODE,
+    SUPPORT_CHAT_URL,
+    TOTAL_GB,
+    TRANSITION_DATE_STR,
+    USE_COUNTRY_SELECTION,
+    USERNAME_BOT,
+)
+from database import get_key_details, get_servers
+from handlers.utils import convert_to_bytes
+from logger import logger
+
+
+async def fetch_url_content(url: str, identifier: str) -> list[str]:
+    """
+    Получает содержимое подписки по URL и декодирует его.
+
+    Args:
+        url: URL для получения содержимого
+        identifier: Идентификатор пользователя (tg_id или email)
+
+    Returns:
+        Список строк из подписки
+    """
+    try:
+        logger.info(f"Получение URL: {url} для идентификатора: {identifier}")
+        timeout = aiohttp.ClientTimeout(total=5)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(url, ssl=False) as response:
+                if response.status == 200:
+                    content = await response.text()
+                    logger.info(f"Успешно получен контент с {url} для идентификатора: {identifier}")
+                    return base64.b64decode(content).decode("utf-8").split("\n")
+                else:
+                    logger.error(
+                        f"Не удалось получить {url} для идентификатора: {identifier}, статус: {response.status}"
+                    )
+                    return []
+    except TimeoutError:
+        logger.error(f"Таймаут при получении {url} для идентификатора: {identifier}")
+        return []
+    except Exception as e:
+        logger.error(f"Ошибка при получении {url} для идентификатора: {identifier}: {e}")
+        return []
+
+
+async def combine_unique_lines(urls: list[str], identifier: str, query_string: str) -> list[str]:
+    """
+    Объединяет строки подписки из нескольких URL, удаляя дубликаты.
+
+    Args:
+        urls: Список URL для получения подписок
+        identifier: Идентификатор пользователя (tg_id или email)
+        query_string: Строка запроса для добавления к URL
+
+    Returns:
+        Список уникальных строк из всех подписок
+    """
+    if SUPERNODE:
+        logger.info(f"Режим SUPERNODE активен. Возвращаем первую ссылку для идентификатора: {identifier}")
+        if not urls:
+            return []
+        url_with_query = f"{urls[0]}?{query_string}" if query_string else urls[0]
+        return await fetch_url_content(url_with_query, identifier)
+
+    logger.info(f"Начинаем объединение подписок для идентификатора: {identifier}, запрос: {query_string}")
+    urls_with_query = [f"{url}?{query_string}" if query_string else url for url in urls]
+    logger.info(f"Составлены URL-адреса: {urls_with_query}")
+
+    tasks = [fetch_url_content(url, identifier) for url in urls_with_query]
+    results = await asyncio.gather(*tasks)
+    all_lines = set()
+    for lines in results:
+        all_lines.update(filter(None, lines))
+    logger.info(
+        f"Объединено {len(all_lines)} строк после фильтрации и удаления дубликатов для идентификатора: {identifier}"
+    )
+    return list(all_lines)
+
+
+async def get_subscription_urls(server_id: str, email: str, conn) -> list[str]:
+    """
+    Получает список URL-адресов для подписки в зависимости от режима выбора страны.
+
+    Args:
+        server_id: Идентификатор сервера или кластера
+        email: Email пользователя
+        conn: Соединение с базой данных
+
+    Returns:
+        Список URL-адресов для подписки
+    """
+    if USE_COUNTRY_SELECTION:
+        logger.info(f"Режим выбора страны активен. Ищем сервер {server_id} в БД.")
+        server_data = await conn.fetchrow("SELECT subscription_url FROM servers WHERE server_name = $1", server_id)
+        if not server_data:
+            logger.warning(f"Не найден сервер {server_id} в БД!")
+            return []
+        subscription_url = server_data["subscription_url"]
+        urls = [f"{subscription_url}/{email}"]
+        logger.info(f"Используем подписку {urls[0]}")
+        return urls
+
+    servers = await get_servers(conn)
+    logger.info(f"Режим выбора страны отключен. Используем кластер {server_id}.")
+    cluster_servers = servers.get(server_id, [])
+    if not cluster_servers:
+        logger.warning(f"Не найдены сервера для {server_id}")
+        return []
+    urls = [f"{server['subscription_url']}/{email}" for server in cluster_servers]
+    logger.info(f"Найдено {len(urls)} URL-адресов в кластере {server_id}")
+    return urls
+
+
+def get_transition_timestamp() -> int:
+    """
+    Получает временную метку перехода с учетом часового пояса Москвы.
+
+    Returns:
+        Временная метка перехода в миллисекундах
+    """
+    moscow_tz = pytz.timezone("Europe/Moscow")
+    transition_date_naive = datetime.strptime(TRANSITION_DATE_STR, "%Y-%m-%d %H:%M:%S")
+    transition_date = moscow_tz.localize(transition_date_naive)
+    transition_timestamp_ms = int(transition_date.timestamp() * 1000)
+    return transition_timestamp_ms
+
+
+def calculate_traffic(cleaned_subscriptions: list[str], expiry_time_ms: int | None) -> str:
+    """
+    Рассчитывает информацию о трафике на основе подписок.
+
+    Args:
+        cleaned_subscriptions: Список строк подписки
+        expiry_time_ms: Время истечения подписки в миллисекундах
+
+    Returns:
+        Строка с информацией о трафике
+    """
+    expire_timestamp = int(expiry_time_ms / 1000) if expiry_time_ms else 0
+
+    if TOTAL_GB != 0:
+        country_remaining = {}
+        for line in cleaned_subscriptions:
+            if "#" not in line:
+                continue
+
+            try:
+                _, meta = line.split("#", 1)
+            except ValueError:
+                continue
+
+            parts = meta.split("-")
+            country = parts[0].strip()
+            remaining_str = parts[1].strip() if len(parts) == 2 else ""
+
+            if remaining_str:
+                remaining_str = remaining_str.replace(",", ".")
+                m_total = re.search(r"([\d\.]+)\s*([GMKTB]B)", remaining_str, re.IGNORECASE)
+                if m_total:
+                    value = float(m_total.group(1))
+                    unit = m_total.group(2).upper()
+                    remaining_bytes = convert_to_bytes(value, unit)
+                    country_remaining[country] = remaining_bytes
+
+        num_countries = len(country_remaining)
+        issued_per_country = TOTAL_GB
+        total_traffic_bytes = issued_per_country * num_countries
+        consumed_traffic_bytes = total_traffic_bytes - sum(country_remaining.values())
+
+        if consumed_traffic_bytes < 0:
+            consumed_traffic_bytes = 0
+    else:
+        consumed_traffic_bytes = 1
+        total_traffic_bytes = 0
+
+    return f"upload=0; download={consumed_traffic_bytes}; total={total_traffic_bytes}; expire={expire_timestamp}"
+
+
+def clean_subscription_line(line: str) -> str:
+    """
+    Очищает строку подписки, оставляя только нужную информацию.
+
+    Args:
+        line: Исходная строка подписки
+
+    Returns:
+        Очищенная строка подписки
+    """
+    if "#" not in line:
+        return line
+
+    try:
+        base, meta = line.split("#", 1)
+    except ValueError:
+        return line
+
+    parts = meta.split("-")
+    country = parts[0].strip() if parts else ""
+    traffic = ""
+
+    for part in parts[1:]:
+        part_decoded = urllib.parse.unquote(part).strip()
+        if re.search(r"\d+(?:[.,]\d+)?\s*(?:GB|MB|KB|TB)", part_decoded, re.IGNORECASE):
+            traffic = part_decoded
+            break
+
+    meta_clean = f"{country} - {traffic}" if traffic else country
+    return base + "#" + meta_clean
+
+
+def format_time_left(expiry_time_ms: int | None) -> str:
+    """
+    Форматирует оставшееся время подписки.
+
+    Args:
+        expiry_time_ms: Время истечения подписки в миллисекундах
+
+    Returns:
+        Отформатированная строка с оставшимся временем
+    """
+    if not expiry_time_ms:
+        return "N/A"
+
+    now_ms = int(time.time() * 1000)
+    remaining_sec = max((expiry_time_ms - now_ms) / 1000, 0)
+    days = int(remaining_sec // 86400)
+    hours = int((remaining_sec % 86400) // 3600)
+
+    return f"{days}D,{hours}H ⏳" if days else f"{hours}H ⏳"
+
+
+def prepare_headers(
+    user_agent: str, project_name: str, subscription_info: str, subscription_userinfo: str
+) -> dict[str, str]:
+    """
+    Подготавливает заголовки ответа в зависимости от User-Agent клиента.
+
+    Args:
+        user_agent: User-Agent клиента
+        project_name: Название проекта
+        subscription_info: Информация о подписке
+        subscription_userinfo: Информация о трафике
+
+    Returns:
+        Словарь с заголовками ответа
+    """
+    if "Happ" in user_agent:
+        encoded_project_name = f"{project_name}"
+        announce_str = f"↖️Бот | {subscription_info} | Поддержка↗️"
+        return {
+            "Content-Type": "text/plain; charset=utf-8",
+            "Content-Disposition": "inline",
+            "profile-update-interval": "3",
+            "profile-title": "base64:" + base64.b64encode(encoded_project_name.encode("utf-8")).decode("utf-8"),
+            "support-url": SUPPORT_CHAT_URL,
+            "announce": "base64:" + base64.b64encode(announce_str.encode("utf-8")).decode("utf-8"),
+            "profile-web-page-url": f"https://t.me/{USERNAME_BOT}",
+            "subscription-userinfo": subscription_userinfo,
+        }
+    elif "Hiddify" in user_agent:
+        parts = subscription_info.split(' - ')[0].split(': ')
+        key_info = parts[1] if len(parts) > 1 else parts[0]
+
+        encoded_project_name = f"{project_name}\n📄 Подписка: {key_info}"
+        return {
+            "profile-update-interval": "3",
+            "profile-title": "base64:" + base64.b64encode(encoded_project_name.encode("utf-8")).decode("utf-8"),
+            "subscription-userinfo": subscription_userinfo,
+        }
+    else:
+        encoded_project_name = f"{project_name}\n{subscription_info}"
+        return {
+            "Content-Type": "text/plain; charset=utf-8",
+            "Content-Disposition": "inline",
+            "profile-update-interval": "3",
+            "profile-title": "base64:" + base64.b64encode(encoded_project_name.encode("utf-8")).decode("utf-8"),
+        }
+
+
+async def handle_subscription(request: web.Request, old_subscription: bool = False) -> web.Response:
+    """
+    Обрабатывает запрос на подписку (старую или новую).
+
+    Args:
+        request: Объект запроса
+        old_subscription: Флаг, указывающий на тип подписки (старая или новая)
+
+    Returns:
+        Ответ с подпиской или сообщением об ошибке
+    """
+    email = request.match_info.get("email")
+    tg_id = request.match_info.get("tg_id") if not old_subscription else None
+
+    if not email or (not old_subscription and not tg_id):
+        logger.warning("Получен запрос с отсутствующими параметрами")
+        return web.Response(text="❌ Неверные параметры запроса.", status=400)
+
+    logger.info(
+        f"Обработка запроса для {'старого' if old_subscription else 'нового'} клиента: email={email}, tg_id={tg_id}"
+    )
+
+    conn = await asyncpg.connect(DATABASE_URL)
+    try:
+        client_data = await get_key_details(email, conn)
+        if not client_data:
+            logger.warning(f"Клиент с email {email} не найден в базе.")
+            return web.Response(text="❌ Клиент с таким email не найден.", status=404)
+
+        stored_tg_id = client_data.get("tg_id")
+        server_id = client_data["server_id"]
+
+        if not old_subscription and str(tg_id) != str(stored_tg_id):
+            logger.warning(f"Неверный tg_id для клиента с email {email}.")
+            return web.Response(text="❌ Неверные данные. Получите свой ключ в боте.", status=403)
+
+        if old_subscription:
+            created_at_ms = client_data["created_at"]
+            created_at_datetime = datetime.utcfromtimestamp(created_at_ms / 1000)
+            logger.info(f"created_at для {email}: {created_at_datetime}, server_id: {server_id}")
+
+            transition_timestamp_ms = get_transition_timestamp()
+            logger.info(f"Время перехода (с учетом часового пояса Москвы): {transition_timestamp_ms}")
+
+            if created_at_ms >= transition_timestamp_ms:
+                logger.info(f"Клиент с email {email} является новым.")
+                return web.Response(text="❌ Эта ссылка устарела. Пожалуйста, обновите ссылку.", status=400)
+
+        expiry_time_ms = client_data.get("expiry_time")
+        time_left = format_time_left(expiry_time_ms)
+
+        urls = await get_subscription_urls(server_id, email, conn)
+        if not urls:
+            return web.Response(text="❌ Сервер не найден.", status=404)
+
+        query_string = request.query_string if not old_subscription else ""
+        combined_subscriptions = await combine_unique_lines(urls, tg_id or email, query_string)
+        random.shuffle(combined_subscriptions)
+
+        cleaned_subscriptions = [clean_subscription_line(line) for line in combined_subscriptions]
+
+        base64_encoded = base64.b64encode("\n".join(cleaned_subscriptions).encode("utf-8")).decode("utf-8")
+        subscription_info = f"📄 Подписка: {email} - {time_left}"
+
+        user_agent = request.headers.get("User-Agent", "")
+        subscription_userinfo = calculate_traffic(cleaned_subscriptions, expiry_time_ms)
+        headers = prepare_headers(user_agent, PROJECT_NAME, subscription_info, subscription_userinfo)
+
+        logger.info(f"Возвращаем объединенные подписки для email: {email}")
+        return web.Response(text=base64_encoded, headers=headers)
+    finally:
+        await conn.close()
+
+
+async def handle_old_subscription(request: web.Request) -> web.Response:
+    """Обработка запроса для старых клиентов."""
+    return await handle_subscription(request, old_subscription=True)
+
+
+async def handle_new_subscription(request: web.Request) -> web.Response:
+    """Обработка запроса для новых клиентов."""
+    return await handle_subscription(request, old_subscription=False)

handlers/notifications.py

@@ -1,85 +0,0 @@
-from datetime import datetime, timedelta
-
-import asyncpg
-from aiogram import Bot, Router, types
-from aiogram.filters import Command
-from aiogram.fsm.context import FSMContext
-from aiogram.fsm.state import State, StatesGroup
-from aiogram.types import (  # Импортируем необходимые классы
-    InlineKeyboardButton, InlineKeyboardMarkup)
-
-from bot import bot
-from config import ADMIN_ID, DATABASE_URL
-from database import get_all_users
-
-router = Router()
-
-class NotificationStates(StatesGroup):
-    waiting_for_notification_text = State()
-
-from datetime import datetime, timedelta
-
-import asyncpg
-from aiogram import Bot, Router, types
-from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
-
-from bot import bot
-from config import DATABASE_URL
-
-router = Router()
-
-async def notify_expiring_keys(bot: Bot):
-    try:
-        conn = await asyncpg.connect(DATABASE_URL)
-        try:
-            # Получаем все ключи, которые истекают в течение следующих 10 часов
-            threshold_time = (datetime.utcnow() + timedelta(hours=10)).timestamp() * 1000  # В миллисекундах
-            records = await conn.fetch('''
-                SELECT tg_id, email, expiry_time, client_id FROM keys 
-                WHERE expiry_time <= $1 AND expiry_time > $2
-            ''', threshold_time, datetime.utcnow().timestamp() * 1000)
-
-            for record in records:
-                tg_id = record['tg_id']
-                email = record['email']
-                expiry_time = record['expiry_time']
-
-                # Рассчитываем оставшееся время и уменьшаем его на 3 часа
-                time_left = (expiry_time / 1000) - datetime.utcnow().timestamp()
-                hours_left = max(0, int(time_left // 3600) - 3)
-
-                expiry_date = datetime.utcfromtimestamp(expiry_time / 1000).strftime('%Y-%m-%d %H:%M:%S')
-
-                # Создаем клавиатуру с выбором тарифов
-                keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                    [InlineKeyboardButton(text='1 месяц (100 руб.)', callback_data=f'renew_plan|1|{record["client_id"]}')],
-                    [InlineKeyboardButton(text='3 месяца (250 руб.)', callback_data=f'renew_plan|3|{record["client_id"]}')],
-                    [InlineKeyboardButton(text='Пополнить баланс', callback_data='replenish_balance')]
-                ])
-
-                message = f"Ваш ключ <b>{email}</b> истечет через <b>{hours_left} часов</b> (<b>{expiry_date}</b>). Пожалуйста, продлите его."
-                await bot.send_message(chat_id=tg_id, text=message, parse_mode='HTML', reply_markup=keyboard)
-
-            # Обрабатываем истекшие ключи
-            expired_records = await conn.fetch('''
-                SELECT tg_id, email FROM keys 
-                WHERE expiry_time <= $1
-            ''', datetime.utcnow().timestamp() * 1000)
-
-            for record in expired_records:
-                tg_id = record['tg_id']
-                email = record['email']
-
-                keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                    [InlineKeyboardButton(text='1 месяц (100 руб.)', callback_data=f'renew_plan|1|{record["client_id"]}')],
-                    [InlineKeyboardButton(text='3 месяца (250 руб.)', callback_data=f'renew_plan|3|{record["client_id"]}')],
-                    [InlineKeyboardButton(text='Пополнить баланс', callback_data='replenish_balance')]
-                ])
-
-                message = f"Ваш ключ <b>{email}</b> уже истек. Пожалуйста, продлите его."
-                await bot.send_message(chat_id=tg_id, text=message, parse_mode='HTML', reply_markup=keyboard)
-
-        finally:
-            await conn.close()
-    except Exception as e:
-        print(f"Ошибка при отправке уведомлений: {e}")

handlers/notifications/__init__.py

@@ -0,0 +1,10 @@
+__all__ = ("router",)
+
+from aiogram import Router
+
+from .general_notifications import router as general_notifications_router
+from .special_notifications import router as special_notifications_router
+
+router = Router(name="notifications_main_router")
+
+router.include_routers(general_notifications_router, special_notifications_router)

handlers/notifications/general_notifications.py

@@ -0,0 +1,391 @@
+import asyncio
+from datetime import datetime, timedelta
+
+import asyncpg
+import pytz
+from aiogram import Bot, Router
+
+from config import (
+    DATABASE_URL,
+    NOTIFICATION_TIME,
+    NOTIFY_DELETE_DELAY,
+    NOTIFY_DELETE_KEY,
+    NOTIFY_MAXPRICE,
+    NOTIFY_RENEW,
+    NOTIFY_RENEW_EXPIRED,
+    RENEWAL_PRICES,
+    TOTAL_GB,
+    TRIAL_TIME_DISABLE,
+)
+from database import (
+    add_notification,
+    check_notification_time,
+    delete_key,
+    get_all_keys,
+    get_balance,
+    get_last_notification_time,
+    update_balance,
+    update_key_expiry,
+)
+from handlers.keys.key_utils import delete_key_from_cluster, renew_key_in_cluster
+from handlers.texts import KEY_EXPIRY_10H, KEY_EXPIRY_24H, KEY_RENEWED
+from keyboards.notifications.notify_kb import build_notification_expired_kb, build_notification_kb
+from logger import logger
+
+from .notify_utils import send_notification
+from .special_notifications import notify_inactive_trial_users, notify_users_no_traffic
+
+router = Router()
+
+moscow_tz = pytz.timezone("Europe/Moscow")
+
+
+async def periodic_notifications(bot: Bot):
+    """
+    Обработчик, который:
+    1. Получает список всех ключей.
+    2. Отправляет уведомления пользователям о неактивном пробном периоде (если триал включен).
+    3. Отправляет уведомления об истекающих ключах (10h и 24h).
+    4. Проверяет истекшие ключи.
+    5. Проверяет пользователей с нулевым трафиком.
+    """
+    while True:
+        conn = None
+        try:
+            conn = await asyncpg.connect(DATABASE_URL)
+            current_time = int(datetime.now(moscow_tz).timestamp() * 1000)
+
+            threshold_time_10h = int((datetime.now(moscow_tz) + timedelta(hours=10)).timestamp() * 1000)
+            threshold_time_24h = int((datetime.now(moscow_tz) + timedelta(days=1)).timestamp() * 1000)
+
+            logger.info("Начало обработки уведомлений.")
+
+            try:
+                keys = await get_all_keys(session=conn)
+            except Exception as e:
+                logger.error(f"Ошибка при получении ключей: {e}")
+                keys = []
+
+            if not TRIAL_TIME_DISABLE:
+                await notify_inactive_trial_users(bot, conn)
+                await asyncio.sleep(0.5)
+
+            await notify_24h_keys(bot, conn, current_time, threshold_time_24h, keys)
+            await asyncio.sleep(1)
+            await notify_10h_keys(bot, conn, current_time, threshold_time_10h, keys)
+            await asyncio.sleep(1)
+            await handle_expired_keys(bot, conn, current_time, keys)
+            await asyncio.sleep(0.5)
+            await notify_users_no_traffic(bot, conn, current_time, keys)
+            await asyncio.sleep(0.5)
+
+        except Exception as e:
+            logger.error(f"❌ Ошибка в periodic_notifications: {e}")
+        finally:
+            if conn:
+                await conn.close()
+                logger.info("Соединение с базой данных закрыто.")
+
+        await asyncio.sleep(NOTIFICATION_TIME)
+
+
+async def notify_24h_keys(bot: Bot, conn: asyncpg.Connection, current_time: int, threshold_time_24h: int, keys: list):
+    logger.info("Начало проверки подписок, истекающих через 24 часа.")
+
+    expiring_keys = [
+        key for key in keys if key.get("expiry_time") and current_time < key.get("expiry_time") <= threshold_time_24h
+    ]
+    logger.info(f"Найдено {len(expiring_keys)} подписок, истекающих через 24 часа.")
+
+    for key in expiring_keys:
+        tg_id = key["tg_id"]
+        email = key.get("email", "")
+        expiry_timestamp = key.get("expiry_time")
+        notification_id = f"{email}_key_24h"
+
+        try:
+            can_notify = await check_notification_time(tg_id, notification_id, hours=24, session=conn)
+        except Exception as e:
+            logger.error(f"Ошибка проверки уведомления для пользователя {tg_id}: {e}")
+            continue
+
+        if not can_notify:
+            continue
+
+        hours_left = int((expiry_timestamp - current_time) / (1000 * 3600))
+        days_left_message = (
+            f"⏳ Осталось времени: {hours_left} часов" if hours_left > 0 else "⏳ Последний день подписки!"
+        )
+
+        expiry_datetime = datetime.fromtimestamp(expiry_timestamp / 1000, tz=moscow_tz)
+        formatted_expiry_date = expiry_datetime.strftime("%d %B %Y, %H:%M (МСК)")
+
+        notification_text = KEY_EXPIRY_24H.format(
+            email=email,
+            days_left_message=days_left_message,
+            formatted_expiry_date=formatted_expiry_date,
+        )
+
+        if NOTIFY_RENEW:
+            await process_auto_renew_or_notify(bot, conn, key, notification_id, 1, "notify_24h.jpg", notification_text)
+        else:
+            keyboard = build_notification_kb(email)
+            try:
+                await send_notification(bot, tg_id, "notify_24h.jpg", notification_text, keyboard)
+                logger.info(f"Отправлено уведомление об истечении подписки через 24 часа для пользователя {tg_id}.")
+                await add_notification(tg_id, notification_id, session=conn)
+            except Exception as e:
+                logger.error(f"Не удалось отправить уведомление пользователю {tg_id}: {e}")
+
+    logger.info("✅ Обработка всех уведомлений за 24 часа завершена.")
+    await asyncio.sleep(1)
+
+
+async def notify_10h_keys(bot: Bot, conn: asyncpg.Connection, current_time: int, threshold_time_10h: int, keys: list):
+    """
+    Отправляет уведомления пользователям о том, что их подписка истекает через 10 часов.
+    """
+    logger.info("Начало проверки подписок, истекающих через 10 часов.")
+
+    expiring_keys = [
+        key for key in keys if key.get("expiry_time") and current_time < key.get("expiry_time") <= threshold_time_10h
+    ]
+    logger.info(f"Найдено {len(expiring_keys)} подписок, истекающих через 10 часов.")
+
+    for key in expiring_keys:
+        tg_id = key["tg_id"]
+        email = key.get("email", "")
+        expiry_timestamp = key.get("expiry_time")
+        notification_id = f"{email}_key_10h"
+
+        try:
+            can_notify = await check_notification_time(tg_id, notification_id, hours=10, session=conn)
+        except Exception as e:
+            logger.error(f"Ошибка проверки уведомления для пользователя {tg_id}: {e}")
+            continue
+
+        if not can_notify:
+            continue
+
+        hours_left = int((expiry_timestamp - current_time) / (1000 * 3600))
+        hours_left_message = (
+            f"⏳ Осталось времени: {hours_left} часов" if hours_left > 0 else "⏳ Последний день подписки!"
+        )
+
+        expiry_datetime = datetime.fromtimestamp(expiry_timestamp / 1000, tz=moscow_tz)
+        formatted_expiry_date = expiry_datetime.strftime("%d %B %Y, %H:%M (МСК)")
+
+        notification_text = KEY_EXPIRY_10H.format(
+            email=email,
+            hours_left_message=hours_left_message,
+            formatted_expiry_date=formatted_expiry_date,
+        )
+
+        if NOTIFY_RENEW:
+            try:
+                await process_auto_renew_or_notify(
+                    bot, conn, key, notification_id, 1, "notify_10h.jpg", notification_text
+                )
+            except Exception as e:
+                logger.error(f"Ошибка авто-продления/уведомления для пользователя {tg_id}: {e}")
+        else:
+            keyboard = build_notification_kb(email)
+            try:
+                await send_notification(bot, tg_id, "notify_10h.jpg", notification_text, keyboard)
+                logger.info(f"Отправлено уведомление об истечении подписки через 10 часов для пользователя {tg_id}.")
+                await add_notification(tg_id, notification_id, session=conn)
+            except Exception as e:
+                logger.error(f"Не удалось отправить уведомление пользователю {tg_id}: {e}")
+
+    logger.info("✅ Обработка всех уведомлений за 10 часов завершена.")
+    await asyncio.sleep(1)
+
+
+async def handle_expired_keys(bot: Bot, conn: asyncpg.Connection, current_time: int, keys: list):
+    """
+    Обрабатывает истекшие ключи, проверяя продление или удаление.
+    """
+    logger.info("Начало обработки истекших ключей.")
+
+    expired_keys = [key for key in keys if key.get("expiry_time") and key.get("expiry_time") < current_time]
+    logger.info(f"Найдено {len(expired_keys)} истекших ключей.")
+
+    for key in expired_keys:
+        tg_id = key["tg_id"]
+        email = key.get("email", "")
+        client_id = key.get("client_id")
+        server_id = key.get("server_id")
+        notification_id = f"{email}_key_expired"
+
+        try:
+            last_notification_time = await get_last_notification_time(tg_id, notification_id, session=conn)
+        except Exception as e:
+            logger.error(f"Ошибка получения времени последнего уведомления для пользователя {tg_id}: {e}")
+            continue
+
+        if NOTIFY_RENEW_EXPIRED:
+            try:
+                balance = await get_balance(tg_id)
+            except Exception as e:
+                logger.error(f"Ошибка получения баланса для пользователя {tg_id}: {e}")
+                continue
+
+            renewal_period_months = 1
+            renewal_cost = RENEWAL_PRICES[str(renewal_period_months)]
+
+            if balance >= renewal_cost:
+                try:
+                    await process_auto_renew_or_notify(
+                        bot, conn, key, notification_id, 1, "notify_expired.jpg", "Ваш ключ продлён!"
+                    )
+                except Exception as e:
+                    logger.error(f"Ошибка авто-продления для пользователя {tg_id}: {e}")
+                continue
+
+        if NOTIFY_DELETE_KEY:
+            delete_immediately = NOTIFY_DELETE_DELAY == 0
+            delete_after_delay = False
+
+            if last_notification_time is not None:
+                delete_after_delay = (current_time - last_notification_time) / (1000 * 60) >= NOTIFY_DELETE_DELAY
+                logger.info(
+                    f"Прошло минут={(current_time - last_notification_time) / (1000 * 60):.2f} "
+                    f"NOTIFY_DELETE_DELAY={NOTIFY_DELETE_DELAY}"
+                )
+
+            if delete_immediately or delete_after_delay:
+                try:
+                    await delete_key_from_cluster(server_id, email, client_id)
+                    await delete_key(client_id, conn)
+                    logger.info(f"🗑 Ключ {client_id} для пользователя {tg_id} успешно удалён.")
+
+                    keyboard = build_notification_expired_kb()
+                    try:
+                        await send_notification(
+                            bot,
+                            tg_id,
+                            "notify_expired.jpg",
+                            (
+                                f"Ваша подписка {email} была удалена, так как вы не продлили её действие.\n\n"
+                                "Перейдите в личный кабинет и получите новую!"
+                            ),
+                            keyboard,
+                        )
+                        logger.info(f"📢 Отправлено уведомление об удалении подписки {email} пользователю {tg_id}.")
+                    except Exception as e:
+                        logger.error(f"Не удалось отправить уведомление об удалении пользователю {tg_id}: {e}")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка удаления ключа {client_id} для пользователя {tg_id}: {e}")
+                continue
+
+        if last_notification_time is None:
+            keyboard = build_notification_kb(email)
+
+            if NOTIFY_DELETE_DELAY > 0:
+                hours = NOTIFY_DELETE_DELAY // 60
+                minutes = NOTIFY_DELETE_DELAY % 60
+
+                if hours > 0:
+                    if minutes > 0:
+                        delay_message = f"⚠️ Ваша подписка {email} истекла.\n\nЕсли вы не продлите её, она будет удалена через {hours} час{'а' if hours == 1 else 'ов'} и {minutes} минут."
+                    else:
+                        delay_message = f"⚠️ Ваша подписка {email} истекла.\n\nЕсли вы не продлите её, она будет удалена через {hours} час{'а' if hours == 1 else 'ов'}."
+                else:
+                    delay_message = f"⚠️ Ваша подписка {email} истекла.\n\nЕсли вы не продлите её, она будет удалена через {NOTIFY_DELETE_DELAY} минут."
+
+            else:
+                delay_message = f"⚠ Ваша подписка {email} истекла!\n\nПродлите доступ, чтобы возобновить услуги."
+
+            try:
+                await send_notification(
+                    bot,
+                    tg_id,
+                    "notify_expired.jpg",
+                    delay_message,
+                    keyboard,
+                )
+                await add_notification(tg_id, notification_id, session=conn)
+                logger.info(
+                    f"📢 Отправлено уведомление о необходимости продления подписки {email} пользователю {tg_id}."
+                )
+            except Exception as e:
+                logger.error(f"Не удалось отправить уведомление о продлении подписки пользователю {tg_id}: {e}")
+
+    logger.info("✅ Обработка истекших ключей завершена.")
+    await asyncio.sleep(1)
+
+
+async def process_auto_renew_or_notify(
+    bot, conn, key: dict, notification_id: str, renewal_period_months: int, standard_photo: str, standard_caption: str
+):
+    """
+    Если баланс пользователя позволяет, продлевает ключ на максимальный возможный срок и списывает средства;
+    иначе отправляет стандартное уведомление.
+    """
+    tg_id = key.get("tg_id")
+    email = key.get("email", "")
+    renew_notification_id = f"{email}_renew"
+
+    try:
+        can_renew = await check_notification_time(tg_id, renew_notification_id, hours=24, session=conn)
+        if not can_renew:
+            logger.info(
+                f"⏳ Подписка {email} уже продлевалась в течение последних 24 часов, повторное продление отменено."
+            )
+            return
+
+        balance = await get_balance(tg_id)
+
+    except Exception as e:
+        logger.error(f"Ошибка получения данных для пользователя {tg_id}: {e}")
+        return
+
+    if NOTIFY_MAXPRICE:
+        renewal_period_months = max(
+            (int(months) for months, price in RENEWAL_PRICES.items() if balance >= price), default=None
+        )
+    else:
+        renewal_period_months = 1 if balance >= RENEWAL_PRICES["1"] else None
+
+    if renewal_period_months:
+        renewal_period_months = int(renewal_period_months)
+        renewal_cost = RENEWAL_PRICES[str(renewal_period_months)]
+        client_id = key.get("client_id")
+        server_id = key.get("server_id")
+        current_expiry = key.get("expiry_time")
+        new_expiry_time = current_expiry + renewal_period_months * 30 * 24 * 3600 * 1000
+
+        formatted_expiry_date = datetime.fromtimestamp(new_expiry_time / 1000, moscow_tz).strftime("%d %B %Y, %H:%M")
+
+        logger.info(
+            f"[Автопродление] Продление подписки {email} на {renewal_period_months} мес. для пользователя {tg_id}. Баланс: {balance}, списываем: {renewal_cost}"
+        )
+
+        try:
+            await renew_key_in_cluster(server_id, email, client_id, new_expiry_time, TOTAL_GB)
+            await update_balance(tg_id, -renewal_cost, session=conn)
+            await update_key_expiry(client_id, new_expiry_time, conn)
+
+            await add_notification(tg_id, renew_notification_id, session=conn)
+
+            logger.info(
+                f"✅ Ключ {client_id} продлён на {renewal_period_months} мес. для пользователя {tg_id}. Списано {renewal_cost}."
+            )
+
+            renewed_message = KEY_RENEWED.format(
+                email=email, months=renewal_period_months, expiry_date=formatted_expiry_date
+            )
+
+            keyboard = build_notification_expired_kb()
+            await send_notification(bot, tg_id, "notify_expired.jpg", renewed_message, keyboard)
+
+        except KeyError as e:
+            logger.error(f"❌ Ошибка форматирования сообщения KEY_RENEWED: отсутствует ключ {e}")
+        except Exception as e:
+            logger.error(f"❌ Ошибка при продлении ключа {client_id} для пользователя {tg_id}: {e}")
+
+    else:
+        keyboard = build_notification_kb(email)
+        await send_notification(bot, tg_id, standard_photo, standard_caption, keyboard)
+        logger.info(f"📢 Отправлено уведомление об истекающей подписке {email} пользователю {tg_id}.")
+        await add_notification(tg_id, notification_id, session=conn)

handlers/notifications/notify_utils.py

@@ -0,0 +1,52 @@
+import os
+
+import aiofiles
+from aiogram import Bot, types
+from aiogram.exceptions import TelegramForbiddenError
+from aiogram.types import BufferedInputFile, InlineKeyboardMarkup
+
+from logger import logger
+
+
+async def send_notification(
+    bot: Bot,
+    tg_id: int,
+    image_filename: str,
+    caption: str,
+    keyboard: InlineKeyboardMarkup,
+):
+    """
+    Отправляет уведомление с изображением, если файл существует, иначе отправляет текстовое сообщение.
+    Если возникает TelegramForbiddenError (например, бот заблокирован пользователем),
+    функция логирует ошибку и прекращает попытки отправки уведомления.
+    """
+    photo_path = os.path.join("img", image_filename)
+    if os.path.isfile(photo_path):
+        try:
+            async with aiofiles.open(photo_path, "rb") as image_file:
+                image_data = await image_file.read()
+            buffered_photo = BufferedInputFile(image_data, filename=image_filename)
+            await bot.send_photo(tg_id, buffered_photo, caption=caption, reply_markup=keyboard)
+        except TelegramForbiddenError as e:
+            logger.error(f"Ошибка отправки фото для пользователя {tg_id}: {e}")
+            return
+        except Exception as e:
+            logger.error(f"Ошибка отправки фото для пользователя {tg_id}: {e}")
+            try:
+                await bot.send_message(tg_id, caption, reply_markup=keyboard)
+            except TelegramForbiddenError as e:
+                logger.error(f"Ошибка отправки fallback-сообщения для пользователя {tg_id}: {e}")
+                return
+            except Exception as e:
+                logger.error(f"Неизвестная ошибка при отправке fallback-сообщения для пользователя {tg_id}: {e}")
+                return
+    else:
+        logger.error(f"Файл с изображением не найден: {photo_path}")
+        try:
+            await bot.send_message(tg_id, caption, reply_markup=keyboard)
+        except TelegramForbiddenError as e:
+            logger.error(f"Ошибка отправки сообщения для пользователя {tg_id}: {e}")
+            return
+        except Exception as e:
+            logger.error(f"Неизвестная ошибка при отправке сообщения для пользователя {tg_id}: {e}")
+            return

handlers/notifications/special_notifications.py

@@ -0,0 +1,209 @@
+import asyncio
+from datetime import datetime, timedelta
+
+import asyncpg
+import pytz
+from aiogram import Bot, Router, types
+from aiogram.exceptions import TelegramForbiddenError
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from config import NOTIFY_EXTRA_DAYS, NOTIFY_INACTIVE, NOTIFY_INACTIVE_TRAFFIC, SUPPORT_CHAT_URL, TRIAL_TIME
+from database import (
+    add_notification,
+    check_notification_time,
+    create_blocked_user,
+)
+from handlers.keys.key_utils import get_user_traffic
+from logger import logger
+
+router = Router()
+
+moscow_tz = pytz.timezone("Europe/Moscow")
+
+
+async def notify_inactive_trial_users(bot: Bot, conn: asyncpg.Connection):
+    """
+    Проверяет пользователей, не активировавших пробный период, и отправляет им напоминания.
+    Первое уведомление — стандартное.
+    Если прошло 24 часа и триал не активирован, отправляется уведомление с бонусом +2 дня.
+    """
+    logger.info("Проверка пользователей, не активировавших пробный период...")
+
+    inactive_trial_users = await conn.fetch(
+        """
+        SELECT tg_id, username, first_name, last_name FROM users 
+        WHERE tg_id IN (
+            SELECT tg_id FROM connections 
+            WHERE trial IN (0, -1)
+        )
+        AND tg_id NOT IN (
+            SELECT tg_id FROM blocked_users
+        )
+        AND tg_id NOT IN (
+            SELECT DISTINCT tg_id FROM keys
+        )
+        """
+    )
+    logger.info(f"👥 Найдено {len(inactive_trial_users)} неактивных пользователей.")
+
+    for user in inactive_trial_users:
+        tg_id = user["tg_id"]
+        username = user["username"]
+        first_name = user["first_name"]
+        last_name = user["last_name"]
+        display_name = username or first_name or last_name or "Пользователь"
+
+        try:
+            can_notify = await check_notification_time(tg_id, "inactive_trial", hours=NOTIFY_INACTIVE, session=conn)
+
+            if can_notify:
+                builder = InlineKeyboardBuilder()
+                builder.row(
+                    types.InlineKeyboardButton(
+                        text="🚀 Активировать пробный период",
+                        callback_data="create_key",
+                    )
+                )
+                builder.row(types.InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+                keyboard = builder.as_markup()
+
+                trial_extended = await conn.fetchval(
+                    """
+                    SELECT EXISTS (
+                        SELECT 1 FROM notifications 
+                        WHERE tg_id = $1 AND notification_type = 'inactive_trial'
+                    )
+                    """,
+                    tg_id,
+                )
+
+                if trial_extended:
+                    message = (
+                        f"<b>{display_name}</b>, у нас для тебя подарок! 🎁\n\n"
+                        "<blockquote>"
+                        f"Мы добавили тебе +{NOTIFY_EXTRA_DAYS} дополнительных дня к пробному периоду!\n"
+                        f"Теперь у тебя есть еще шанс протестировать наш VPN целых {NOTIFY_EXTRA_DAYS + TRIAL_TIME} дня!\n"
+                        "</blockquote>"
+                        "Нажми на кнопку ниже, чтобы активировать доступ с бонусом +2 дня! 👇"
+                    )
+
+                    await conn.execute("UPDATE connections SET trial = -1 WHERE tg_id = $1", tg_id)
+                else:
+                    message = (
+                        f"👋 <b>Привет, {display_name}!</b>\n\n"
+                        "<blockquote>"
+                        f"🎉 У тебя есть бесплатный пробный период на {TRIAL_TIME} дней!\n"
+                        "Не упусти возможность попробовать наш VPN прямо сейчас.\n"
+                        "</blockquote>"
+                        "Нажми на кнопку ниже, чтобы активировать пробный доступ! 👇"
+                    )
+
+                try:
+                    await bot.send_message(tg_id, message, reply_markup=keyboard)
+                    logger.info(f"📩 Отправлено уведомление неактивному пользователю {tg_id}.")
+                    await add_notification(tg_id, "inactive_trial", session=conn)
+
+                except TelegramForbiddenError:
+                    logger.warning(f"🚫 Бот заблокирован пользователем {tg_id}. Добавляем в blocked_users.")
+                    await create_blocked_user(tg_id, conn)
+                except Exception as e:
+                    logger.error(f"⚠ Ошибка при отправке уведомления пользователю {tg_id}: {e}")
+
+        except Exception as e:
+            logger.error(f"⚠ Ошибка при обработке пользователя {tg_id}: {e}")
+
+        await asyncio.sleep(1)
+
+    logger.info("✅ Проверка пользователей с неактивным пробным периодом завершена.")
+
+
+async def notify_users_no_traffic(bot: Bot, conn: asyncpg.Connection, current_time: int, keys: list):
+    """
+    Проверяет трафик пользователей, у которых ещё не отправлялось уведомление о нулевом трафике.
+    Если трафик 0 ГБ и прошло более 2 часов с момента создания ключа, отправляет уведомление,
+    но исключает пользователей, у которых подписка недавно продлилась.
+    """
+    logger.info("Проверка пользователей с нулевым трафиком...")
+
+    current_dt = datetime.fromtimestamp(current_time / 1000, tz=moscow_tz)
+
+    for key in keys:
+        tg_id = key.get("tg_id")
+        email = key.get("email")
+        created_at = key.get("created_at")
+        client_id = key.get("client_id")
+        expiry_time = key.get("expiry_time")
+        notified = key.get("notified")
+
+        if created_at is None:
+            logger.warning(f"Для {email} нет значения created_at. Пропускаем.")
+            continue
+
+        if notified is True:
+            continue
+
+        created_at_dt = pytz.utc.localize(datetime.fromtimestamp(created_at / 1000)).astimezone(moscow_tz)
+        created_at_plus_2 = created_at_dt + timedelta(hours=NOTIFY_INACTIVE_TRAFFIC)
+
+        if expiry_time:
+            expiry_dt = pytz.utc.localize(datetime.fromtimestamp(expiry_time / 1000)).astimezone(moscow_tz)
+            renewal_threshold = expiry_dt - timedelta(days=30)
+            renewal_recent = current_dt - renewal_threshold < timedelta(hours=NOTIFY_INACTIVE_TRAFFIC)
+
+            if renewal_recent:
+                continue
+
+        if current_dt < created_at_plus_2:
+            continue
+
+        try:
+            traffic_data = await get_user_traffic(conn, tg_id, email)
+        except Exception as e:
+            logger.error(f"Ошибка получения трафика для {email}: {e}")
+            continue
+
+        if traffic_data.get("status") != "success":
+            logger.warning(f"⚠ Ошибка при получении трафика для {email}: {traffic_data.get('message')}")
+            continue
+
+        total_traffic = sum(
+            value if isinstance(value, (int, float)) else 0 for value in traffic_data.get("traffic", {}).values()
+        )
+        logger.info(f"Ключ для {email}: общий трафик: {total_traffic} ГБ")
+
+        if total_traffic == 0:
+            logger.info(f"⚠ У пользователя {tg_id} ({email}) 0 ГБ трафика. Отправляем уведомление.")
+
+            builder = InlineKeyboardBuilder()
+            builder.row(types.InlineKeyboardButton(text="🔧 Написать в поддержку", url=SUPPORT_CHAT_URL))
+            builder.row(types.InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+            keyboard = builder.as_markup()
+
+            message = (
+                f"⚠ <b>Ваша VPN-подписка {email} активна, но трафик не используется.</b>\n\n"
+                "<blockquote>Если у вас возникли сложности с подключением, "
+                "нажмите кнопку ниже, чтобы связаться с поддержкой.</blockquote>\n\n"
+                "🛠 Мы поможем вам разобраться! 💡"
+            )
+
+            try:
+                await bot.send_message(tg_id, message, reply_markup=keyboard)
+                logger.info(f"📩 Отправлено уведомление пользователю {tg_id} о нулевом трафике.")
+                await conn.execute(
+                    "UPDATE keys SET notified = TRUE WHERE tg_id = $1 AND client_id = $2", tg_id, client_id
+                )
+            except TelegramForbiddenError:
+                logger.warning(f"🚫 Бот заблокирован пользователем {tg_id}.")
+                await create_blocked_user(tg_id, conn)
+            except Exception as e:
+                logger.error(f"⚠ Ошибка при отправке уведомления пользователю {tg_id}: {e}")
+        else:
+            try:
+                await conn.execute(
+                    "UPDATE keys SET notified = TRUE WHERE tg_id = $1 AND client_id = $2", tg_id, client_id
+                )
+                logger.info(f"Ключ для {email} имеет трафик. Обновлено notified = TRUE.")
+            except Exception as e:
+                logger.error(f"Ошибка обновления notified для пользователя {tg_id}: {e}")
+
+    logger.info("✅ Обработка пользователей с нулевым трафиком завершена.")

handlers/pay.py

@@ -1,218 +1,79 @@
-import asyncpg
+from aiogram import F, Router
-from aiogram import Router, types
+from aiogram.types import CallbackQuery, InlineKeyboardButton
-from aiogram.fsm.context import FSMContext
+from aiogram.utils.keyboard import InlineKeyboardBuilder
-from aiogram.fsm.state import State, StatesGroup
-from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 
-from bot import bot
+from config import (
-from config import ADMIN_ID, DATABASE_URL
+    CRYPTO_BOT_ENABLE,
-from database import (add_connection, check_connection_exists, get_balance,
+    DONATIONS_ENABLE,
-                      get_key_count, update_balance)
+    ROBOKASSA_ENABLE,
-from handlers.profile import process_callback_view_profile
+    STARS_ENABLE,
+    YOOKASSA_ENABLE,
+    YOOMONEY_ENABLE,
+)
+
+from .utils import edit_or_send_message
 
 router = Router()
 
-class ReplenishBalanceState(StatesGroup):
-    choosing_transfer_method = State()
-    choosing_amount = State()
-    waiting_for_admin_confirmation = State()
 
-async def send_message_with_deletion(chat_id, text, reply_markup=None, state=None, message_key='last_message_id'):
+@router.callback_query(F.data == "pay")
-    if state:
+async def handle_pay(callback_query: CallbackQuery):
-        try:
+    builder = InlineKeyboardBuilder()
-            state_data = await state.get_data()
-            previous_message_id = state_data.get(message_key)
 
-            if previous_message_id:
+    if YOOKASSA_ENABLE:
-                await bot.delete_message(chat_id=chat_id, message_id=previous_message_id)
+        builder.row(
-    
+            InlineKeyboardButton(
-            sent_message = await bot.send_message(chat_id=chat_id, text=text, reply_markup=reply_markup)
+                text="💳 ЮКасса: быстрый перевод",
-            if state:
+                callback_data="pay_yookassa",
-                await state.update_data({message_key: sent_message.message_id})
+            )
-    
+        )
-        except Exception as e:
+    if YOOMONEY_ENABLE:
-            print(f"Ошибка при удалении/отправке сообщения: {e}")
+        builder.row(
-            return None
+            InlineKeyboardButton(
-
+                text="💳 ЮМани: оплата по карте",
-    return sent_message
+                callback_data="pay_yoomoney",
-
+            )
-@router.callback_query(lambda c: c.data == 'replenish_balance')
+        )
-async def process_callback_replenish_balance(callback_query: types.CallbackQuery, state: FSMContext):
+    if CRYPTO_BOT_ENABLE:
-    tg_id = callback_query.from_user.id
+        builder.row(
-
+            InlineKeyboardButton(
-    # Проверяем, есть ли у пользователя ключи
+                text="💰 CryptoBot: криптовалюта",
-    key_count = await get_key_count(tg_id)
+                callback_data="pay_cryptobot",
-    
+            )
-    # Если ключей нет, проверяем, существует ли запись с таким tg_id
+        )
-    if key_count == 0:
+    if STARS_ENABLE:
-        exists = await check_connection_exists(tg_id)
+        builder.row(
-        # Если записи нет, создаем нового клиента в базе данных
+            InlineKeyboardButton(
-        if not exists:
+                text="⭐ Оплата Звездами",
-            await add_connection(tg_id, balance=0.0, trial=0)
+                callback_data="pay_stars",
-
+            )
-    await state.set_state(ReplenishBalanceState.choosing_transfer_method)
+        )
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+    if ROBOKASSA_ENABLE:
-        [InlineKeyboardButton(text='По реквизитам', callback_data='transfer_method_requisites')],
+        builder.row(
-        [InlineKeyboardButton(text='⬅️ Назад', callback_data='back_to_profile')]
+            InlineKeyboardButton(
-    ])
+                text="⭐ RoboKassa",
-    
+                callback_data="pay_robokassa",
-    await callback_query.message.edit_text(
+            )
-        text="Выберите метод перевода:",
-        reply_markup=keyboard
-    )
-    await callback_query.answer()
-
-@router.callback_query(lambda c: c.data == 'back_to_profile')
-async def back_to_profile_handler(callback_query: types.CallbackQuery, state: FSMContext):
-    await process_callback_view_profile(callback_query, state)
-
-@router.callback_query(lambda c: c.data.startswith('transfer_method_'))
-async def process_transfer_method_selection(callback_query: types.CallbackQuery, state: FSMContext):
-    data = callback_query.data.split('_', 2)
-    
-    if len(data) != 3:
-        await send_message_with_deletion(callback_query.from_user.id, "Неверные данные для выбора метода перевода.", state=state, message_key='transfer_method_error_message_id')
-        return
-    
-    transfer_method = data[2]
-    
-    if transfer_method == 'requisites':
-        amount_keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text='100 RUB', callback_data='amount_100'), InlineKeyboardButton(text='300 RUB', callback_data='amount_300')],
-            [InlineKeyboardButton(text='600 RUB', callback_data='amount_600'), InlineKeyboardButton(text='1000 RUB', callback_data='amount_1000')],
-            [InlineKeyboardButton(text='⬅️ Назад', callback_data='back_to_profile')]
-        ])
-        
-        await callback_query.message.edit_text(
-            text="Выберите сумму пополнения:",
-            reply_markup=amount_keyboard
         )
-        await state.update_data(transfer_method=transfer_method)
-        await state.set_state(ReplenishBalanceState.choosing_amount)
-    
-    else:
-        await send_message_with_deletion(callback_query.from_user.id, "Неверный метод перевода.", state=state, message_key='transfer_method_error_message_id')
-        return
 
+    builder.row(InlineKeyboardButton(text="🎟️ Активировать купон", callback_data="activate_coupon"))
+    if DONATIONS_ENABLE:
+        builder.row(InlineKeyboardButton(text="💰 Поддержать проект", callback_data="donate"))
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
 
-@router.callback_query(lambda c: c.data.startswith('amount_'))
+    payment_text = (
-async def process_amount_selection(callback_query: types.CallbackQuery, state: FSMContext):
+        "💸 <b>Выберите удобный способ пополнения баланса:</b>\n"
-    data = callback_query.data.split('_', 1)
+        "<blockquote>"
-
+        "• Быстро и безопасно\n"
-    if len(data) != 2:
+        "• Поддержка разных платежных систем\n"
-        await send_message_with_deletion(callback_query.from_user.id, "Неверные данные для выбора суммы.", state=state, message_key='amount_error_message_id')
+        "• Моментальное зачисление средств 🚀\n"
-        return
+        "</blockquote>"
-
-    amount_str = data[1]
-    try:
-        amount = int(amount_str)
-    except ValueError:
-        await send_message_with_deletion(callback_query.from_user.id, "Некорректная сумма.", state=state, message_key='amount_error_message_id')
-        return
-
-    state_data = await state.get_data()
-    amount_selection_message_id = state_data.get('amount_selection_message_id')
-
-    if amount_selection_message_id:
-        try:
-            await bot.delete_message(chat_id=callback_query.from_user.id, message_id=amount_selection_message_id)
-        except Exception as e:
-            print(f"Ошибка при удалении сообщения: {e}")
-
-    await state.update_data(amount=amount)
-    await state.set_state(ReplenishBalanceState.waiting_for_admin_confirmation)
-
-    transfer_method = state_data.get('transfer_method')
-    message = (
-        "Банк: Т-Банк\n"
-        "2200701036597224\n"
-        "Получатель: Лисицын В.Д.\n"
-        "\n"
-        "После перевода отправьте чек и дождитесь подтверждения."
     )
 
-    await callback_query.message.edit_text(
+    await edit_or_send_message(
-        text=message,
+        target_message=callback_query.message,
-        reply_markup=None
+        text=payment_text,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+        disable_web_page_preview=False,
     )
-
-    admin_keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text='Подтвердить', callback_data=f'admin_confirm_{callback_query.from_user.id}_{transfer_method}_{amount}')],
-        [InlineKeyboardButton(text='Отклонить', callback_data=f'admin_decline_{callback_query.from_user.id}_{transfer_method}_{amount}')]
-    ])
-
-    admin_message = (
-        f"Пользователь {callback_query.from_user.full_name} запросил пополнение баланса.\n"
-        f"Метод перевода: {transfer_method}\n"
-        f"Сумма пополнения: {amount} RUB\n"
-        "Пожалуйста, подтвердите или отклоните запрос."
-    )
-    
-    await send_message_with_deletion(ADMIN_ID, admin_message, reply_markup=admin_keyboard, state=state, message_key='admin_request_message_id')
-    await callback_query.answer()
-
-@router.callback_query(lambda c: c.data.startswith('admin_'))
-async def process_admin_confirmation(callback_query: types.CallbackQuery, state: FSMContext):
-    if callback_query.from_user.id != ADMIN_ID:
-        await send_message_with_deletion(callback_query.from_user.id, "Вы не являетесь администратором.", state=state, message_key='admin_error_message_id')
-        return
-
-    data = callback_query.data.split('_', 4)
-    
-    if len(data) < 5:
-        await send_message_with_deletion(callback_query.from_user.id, "Неверные данные для обработки запроса.", state=state, message_key='admin_error_message_id')
-        return
-
-    action = data[1]
-    user_id_str = data[2]
-    transfer_method = data[3]
-    amount_str = data[4]
-
-    try:
-        user_id = int(user_id_str)
-        amount = int(amount_str)
-
-        state_data = await state.get_data()
-        requisites_message_id = state_data.get('requisites_message_id')
-
-        if action == 'confirm':
-            conn = await asyncpg.connect(DATABASE_URL)
-            try:
-                await update_balance(user_id, amount)
-                balance = await get_balance(user_id)
-
-                profile_button = InlineKeyboardButton(text='Профиль', callback_data='view_profile')
-                profile_keyboard = InlineKeyboardMarkup(inline_keyboard=[[profile_button]])
-
-                await send_message_with_deletion(callback_query.from_user.id, f"Баланс пользователя успешно пополнен на {amount} RUB.\nТекущий баланс: {balance}", state=state, message_key='admin_confirm_message_id')
-
-                await bot.send_message(
-                    user_id, 
-                    f"Ваш баланс был успешно пополнен на {amount} RUB.", 
-                    reply_markup=profile_keyboard
-                )
-
-                requisites_message_id = state_data.get('requisites_message_id')
-                if requisites_message_id:
-                    try:
-                        await bot.delete_message(chat_id=user_id, message_id=requisites_message_id)
-                    except Exception as e:
-                        print(f"Ошибка при удалении сообщения: {e}")
-
-            finally:
-                await conn.close()
-
-        elif action == 'decline':
-            await send_message_with_deletion(callback_query.from_user.id, "Пополнение баланса отклонено.", state=state, message_key='admin_decline_message_id')
-            await bot.send_message(user_id, "Ваш запрос на пополнение баланса был отклонен.")
-
-    except ValueError:
-        await send_message_with_deletion(callback_query.from_user.id, "Некорректные данные суммы.", state=state, message_key='admin_error_message_id')
-        return
-    except Exception as e:
-        await send_message_with_deletion(callback_query.from_user.id, f"Ошибка при пополнении баланса: {e}", state=state, message_key='admin_error_message_id')
-        print(f"Ошибка при пополнении баланса: {e}")
-
-    finally:
-        await state.clear()
-        await callback_query.answer()

handlers/payments/__init__.py

@@ -0,0 +1,32 @@
+__all__ = ("router",)
+
+from aiogram import Router
+from config import (
+    CRYPTO_BOT_ENABLE,
+    ROBOKASSA_ENABLE,
+    STARS_ENABLE,
+    YOOKASSA_ENABLE,
+    YOOMONEY_ENABLE,
+)
+
+from .cryprobot_pay import router as cryprobot_router
+from .gift import router as gift_router
+from .robokassa_pay import router as robokassa_router
+from .stars_pay import router as stars_router
+from .yookassa_pay import router as yookassa_router
+from .yoomoney_pay import router as yoomoney_router
+
+router = Router(name="payments_main_router")
+
+if YOOKASSA_ENABLE:
+    router.include_router(yookassa_router)
+if YOOMONEY_ENABLE:
+    router.include_router(yoomoney_router)
+if ROBOKASSA_ENABLE:
+    router.include_router(robokassa_router)
+if CRYPTO_BOT_ENABLE:
+    router.include_router(cryprobot_router)
+if STARS_ENABLE:
+    router.include_router(stars_router)
+
+router.include_router(gift_router)

handlers/payments/robokassa_pay.py

@@ -0,0 +1,317 @@
+import hashlib
+from typing import Any
+
+import asyncpg
+from aiogram import F, Router, types
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from aiohttp import web
+from config import (
+    DATABASE_URL,
+    ROBOKASSA_ENABLE,
+    ROBOKASSA_LOGIN,
+    ROBOKASSA_PASSWORD1,
+    ROBOKASSA_PASSWORD2,
+    ROBOKASSA_TEST_MODE,
+)
+from robokassa import HashAlgorithm, Robokassa
+
+from database import (
+    add_connection,
+    add_payment,
+    check_connection_exists,
+    get_key_count,
+    get_temporary_data,
+    update_balance,
+)
+from handlers.payments.utils import send_payment_success_notification
+from handlers.texts import PAYMENT_OPTIONS
+from handlers.utils import edit_or_send_message
+from logger import logger
+
+router = Router()
+
+
+class ReplenishBalanceState(StatesGroup):
+    choosing_amount_robokassa = State()
+    waiting_for_payment_confirmation_robokassa = State()
+
+
+if ROBOKASSA_ENABLE:
+    robokassa = Robokassa(
+        merchant_login=ROBOKASSA_LOGIN,
+        password1=ROBOKASSA_PASSWORD1,
+        password2=ROBOKASSA_PASSWORD2,
+        algorithm=HashAlgorithm.md5,
+        is_test=ROBOKASSA_TEST_MODE,
+    )
+
+    logger.info("Robokassa initialized with login: {}", ROBOKASSA_LOGIN)
+
+
+def generate_payment_link(amount, inv_id, description, tg_id):
+    """Генерация ссылки на оплату."""
+    logger.debug(f"Generating payment link for amount: {amount}, inv_id: {inv_id}, description: {description}")
+    payment_link = robokassa._payment.link.generate_by_script(
+        out_sum=amount,
+        inv_id=inv_id,
+        description="пополнение баланса",
+        id=f"{tg_id}",
+    )
+    logger.info(f"Generated payment link: {payment_link}")
+    return payment_link
+
+
+@router.callback_query(F.data == "pay_robokassa")
+async def process_callback_pay_robokassa(callback_query: types.CallbackQuery, state: FSMContext, session: Any):
+    tg_id = callback_query.message.chat.id
+    logger.info(f"User {tg_id} initiated Robokassa payment.")
+
+    builder = InlineKeyboardBuilder()
+    for i in range(0, len(PAYMENT_OPTIONS), 2):
+        if i + 1 < len(PAYMENT_OPTIONS):
+            builder.row(
+                InlineKeyboardButton(
+                    text=PAYMENT_OPTIONS[i]["text"],
+                    callback_data=f'robokassa_amount|{PAYMENT_OPTIONS[i]["callback_data"]}',
+                ),
+                InlineKeyboardButton(
+                    text=PAYMENT_OPTIONS[i + 1]["text"],
+                    callback_data=f'robokassa_amount|{PAYMENT_OPTIONS[i + 1]["callback_data"]}',
+                ),
+            )
+        else:
+            builder.row(
+                InlineKeyboardButton(
+                    text=PAYMENT_OPTIONS[i]["text"],
+                    callback_data=f'robokassa_amount|{PAYMENT_OPTIONS[i]["callback_data"]}',
+                )
+            )
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data="pay"))
+
+    key_count = await get_key_count(tg_id)
+
+    if key_count == 0:
+        exists = await check_connection_exists(tg_id)
+        if not exists:
+            await add_connection(tg_id, balance=0.0, trial=0, session=session)
+            logger.info(f"Created new connection for user {tg_id} with balance 0.0.")
+
+    await callback_query.message.delete()
+    
+    new_message = await callback_query.message.answer(
+        text="Выберите сумму пополнения:",
+        reply_markup=builder.as_markup(),
+    )
+    await state.update_data(message_id=new_message.message_id, chat_id=new_message.chat.id) 
+    await state.set_state(ReplenishBalanceState.choosing_amount_robokassa)
+    logger.info(f"Displayed amount selection for user {tg_id}.")
+
+
+@router.callback_query(F.data.startswith("robokassa_amount|"))
+async def process_amount_selection(callback_query: types.CallbackQuery, state: FSMContext):
+    logger.info(f"Получены данные callback_data: {callback_query.data}")
+
+    data = callback_query.data.split("|")
+    if len(data) != 3 or data[1] != "amount":
+        logger.error("Ошибка: callback_data не соответствует формату.")
+        await edit_or_send_message(
+            target_message=callback_query.message,
+            text="Ошибка: данные повреждены.",
+            reply_markup=types.InlineKeyboardMarkup(),
+            force_text=True,
+        )
+        return
+
+    amount_str = data[2]
+    try:
+        amount = int(amount_str)
+        if amount <= 0:
+            raise ValueError("Сумма должна быть положительным числом.")
+    except ValueError as e:
+        logger.error(f"Некорректное значение суммы: {amount_str}. Ошибка: {e}")
+        await edit_or_send_message(
+            target_message=callback_query.message,
+            text="Некорректная сумма.",
+            reply_markup=types.InlineKeyboardMarkup(),
+            force_text=True,
+        )
+        return
+
+    await state.update_data(amount=amount)
+    logger.info(f"User {callback_query.message.chat.id} selected amount: {amount}.")
+    inv_id = 0
+
+    tg_id = callback_query.message.chat.id
+    payment_url = generate_payment_link(amount, inv_id, "Пополнение баланса", tg_id)
+
+    logger.info(f"Payment URL for user {callback_query.message.chat.id}: {payment_url}")
+
+    confirm_keyboard = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [InlineKeyboardButton(text="Оплатить", url=payment_url)],
+            [InlineKeyboardButton(text="⬅️ Назад", callback_data="pay_robokassa")],
+        ]
+    )
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=f"Вы выбрали пополнение на {amount} рублей. Для оплаты перейдите по ссылке ниже:",
+        reply_markup=confirm_keyboard,
+        force_text=True,
+    )
+    logger.info(f"Payment link sent to user {callback_query.message.chat.id}.")
+
+
+async def robokassa_webhook(request):
+    """Обработка webhook-уведомлений от Robokassa с учетом shp_id."""
+    try:
+        params = await request.post()
+
+        logger.info(f"Received webhook params: {params}")
+
+        amount = params.get("OutSum")
+        inv_id = params.get("InvId")
+        shp_id = params.get("shp_id")
+        signature_value = params.get("SignatureValue")
+
+        logger.info(f"OutSum: {amount}, InvId: {inv_id}, shp_id: {shp_id}, SignatureValue: {signature_value}")
+
+        if not check_payment_signature(params):
+            logger.error("Неверная подпись или данные запроса.")
+            return web.Response(status=400)
+
+        if not amount or not inv_id or not shp_id:
+            logger.error("Отсутствуют обязательные параметры.")
+            return web.Response(status=400)
+
+        tg_id = shp_id
+
+        logger.info(f"Processing payment for user {tg_id} with amount {amount}.")
+
+        await update_balance(int(tg_id), float(amount))
+        await send_payment_success_notification(tg_id, float(amount))
+
+        await add_payment(int(tg_id), float(amount), "robokassa")
+
+        logger.info(f"Payment successful. Balance updated for user {tg_id}.")
+
+        return web.Response(text=f"OK{inv_id}")
+
+    except Exception as e:
+        logger.error(f"Error processing webhook: {e}")
+        return web.Response(status=500)
+
+
+def check_payment_signature(params):
+    """Проверка подписи запроса от Robokassa с учетом shp_id."""
+    out_sum = params.get("OutSum")
+    inv_id = params.get("InvId")
+    signature_value = params.get("SignatureValue")
+    shp_id = params.get("shp_id")
+
+    signature_string = f"{out_sum}:{inv_id}:{ROBOKASSA_PASSWORD2}:shp_id={shp_id}"
+
+    logger.info(f"Signature string before hashing: {signature_string}")
+
+    expected_signature = hashlib.md5(signature_string.encode("utf-8")).hexdigest().upper()
+
+    logger.info(f"Expected signature: {expected_signature}")
+    logger.info(f"Received signature: {signature_value}")
+
+    return signature_value.upper() == expected_signature.upper()
+
+
+@router.callback_query(F.data == "enter_custom_amount_robokassa")
+async def process_custom_amount_selection(callback_query: types.CallbackQuery, state: FSMContext):
+    tg_id = callback_query.message.chat.id
+    logger.info(f"User {tg_id} chose to enter a custom amount.")
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="🔙 Назад", callback_data="pay_robokassa"))
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text="Пожалуйста, введите сумму пополнения.",
+        reply_markup=builder.as_markup(),
+        force_text=True,
+    )
+
+    await state.set_state(ReplenishBalanceState.waiting_for_payment_confirmation_robokassa)
+
+
+@router.message(ReplenishBalanceState.waiting_for_payment_confirmation_robokassa)
+async def handle_custom_amount_input(
+    message: types.Message | types.CallbackQuery, state: FSMContext = None, session: Any = None
+):
+    if isinstance(message, types.CallbackQuery):
+        tg_id = message.message.chat.id
+        target_message = message.message
+    else:
+        tg_id = message.chat.id
+        target_message = message
+
+    logger.info(f"User {tg_id} initiated payment through ROBOKASSA")
+    inv_id = 0
+
+    try:
+        conn = await asyncpg.connect(DATABASE_URL)
+        user_data = await get_temporary_data(conn, tg_id)
+        await conn.close()
+
+        if not user_data:
+            await edit_or_send_message(
+                target_message=target_message,
+                text="Данные для оплаты не найдены. Попробуйте снова.",
+                reply_markup=types.InlineKeyboardMarkup(),
+            )
+            return
+
+        state_type = user_data["state"]
+        amount = user_data["data"].get("required_amount", 0)
+
+        if amount <= 0:
+            await edit_or_send_message(
+                target_message=target_message,
+                text="Недостаточная сумма для пополнения.",
+                reply_markup=types.InlineKeyboardMarkup(),
+            )
+            return
+
+        payment_url = generate_payment_link(amount, inv_id, "Пополнение баланса", tg_id)
+        logger.info(f"Generated payment link for user {tg_id}: {payment_url}")
+
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text="💳 Оплатить", url=payment_url))
+        builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data="pay_robokassa"))
+
+        if state_type == "waiting_for_payment":
+            message_text = (
+                f"Вы выбрали пополнение на {amount} рублей для создания нового ключа. Перейдите по ссылке для оплаты:"
+            )
+        elif state_type == "waiting_for_renewal_payment":
+            message_text = (
+                f"Вы выбрали пополнение на {amount} рублей для продления ключа. Перейдите по ссылке для оплаты:"
+            )
+        else:
+            await edit_or_send_message(
+                target_message=target_message,
+                text="Некорректное состояние данных. Попробуйте снова.",
+                reply_markup=types.InlineKeyboardMarkup(),
+            )
+            return
+
+        await edit_or_send_message(target_message=target_message, text=message_text, reply_markup=builder.as_markup())
+
+        if isinstance(state, FSMContext):
+            await state.clear()
+
+    except Exception as e:
+        logger.error(f"Ошибка при создании платежа для пользователя {tg_id}: {e}")
+        await edit_or_send_message(
+            target_message=target_message,
+            text="Произошла ошибка при создании платежа. Попробуйте позже.",
+            reply_markup=types.InlineKeyboardMarkup(),
+        )

handlers/profile.py

@@ -1,70 +1,254 @@
-from datetime import datetime
+import os
+from typing import Any
 
-from aiogram import Router, types
+import asyncpg
+from aiogram import F, Router
+from aiogram.enums import ParseMode
 from aiogram.fsm.context import FSMContext
-from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import (
-from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineQuery,
+    InlineQueryResultArticle,
+    InputTextMessageContent,
+    Message,
+)
+from aiogram.utils.keyboard import InlineKeyboardBuilder
 
-from bot import bot  # Импортируем объект bot
+from config import (
-from database import get_balance, get_key_count
+    DATABASE_URL,
+    INLINE_MODE,
+    INSTRUCTIONS_BUTTON,
+    NEWS_MESSAGE,
+    REFERRAL_OFFERS,
+    RENEWAL_PLANS,
+    TRIAL_TIME,
+    USERNAME_BOT,
+)
+from database import get_balance, get_key_count, get_last_payments, get_referral_stats, get_trial
+from handlers.buttons.profile import (
+    ADD_SUB,
+    BALANCE,
+    BALANCE_HISTORY,
+    GIFTS,
+    INSTRUCTIONS,
+    INVITE,
+    MAIN_MENU,
+    MY_SUBS,
+    PAYMENT,
+)
+from handlers.texts import get_referral_link, invite_message_send, profile_message_send
+from keyboards.admin.panel_kb import AdminPanelCallback
+from logger import logger
+import html
+
+from .utils import edit_or_send_message
 
 router = Router()
 
-class ReplenishBalanceState(StatesGroup):
-    choosing_transfer_method = State()
-    waiting_for_admin_confirmation = State()
 
-async def process_callback_view_profile(callback_query: types.CallbackQuery, state: FSMContext):
+@router.callback_query(F.data == "profile")
-    tg_id = callback_query.from_user.id
+@router.message(F.text == "/profile")
-    username = callback_query.from_user.full_name  # Получаем имя пользователя
+async def process_callback_view_profile(
+    callback_query_or_message: Message | CallbackQuery,
+    state: FSMContext,
+    admin: bool,
+):
+    if isinstance(callback_query_or_message, CallbackQuery):
+        chat_id = callback_query_or_message.message.chat.id
+        username = html.escape(callback_query_or_message.from_user.full_name)  
+        target_message = callback_query_or_message.message
+    else:
+        chat_id = callback_query_or_message.chat.id
+        username = html.escape(callback_query_or_message.from_user.full_name)
+        target_message = callback_query_or_message
 
+    image_path = os.path.join("img", "profile.jpg")
+    logger.info(f"Переход в профиль. Используется изображение: {image_path}")
+
+    key_count = await get_key_count(chat_id)
+    balance = await get_balance(chat_id) or 0
+
+    conn = await asyncpg.connect(DATABASE_URL)
     try:
-        # Получаем количество ключей
+        trial_status = await get_trial(chat_id, conn)
-        key_count = await get_key_count(tg_id)
+
-        
+        profile_message = profile_message_send(username, chat_id, int(balance), key_count)
-        # Получаем баланс
+        if key_count == 0:
-        balance = await get_balance(tg_id)
+            profile_message += (
-        if balance is None:
+                "\n<blockquote>🔧 <i>Нажмите кнопку ➕ Подписка, чтобы настроить VPN-подключение</i></blockquote>"
-            balance = 0  # По умолчанию 0, если баланс неизвестен
+            )
-        
+        else:
-        profile_message = (
+            profile_message += f"\n<blockquote> <i>{NEWS_MESSAGE}</i></blockquote>"
-            f"<b>Профиль: {username}</b>\n\n"
+
-            f"🔹 <b>ID:</b> {tg_id}\n"
+        builder = InlineKeyboardBuilder()
-            f"🔹 <b>Баланс:</b> {balance} RUB\n"
+        if trial_status == 0 or key_count == 0:
-            f"🔹 <b>Количество ключей:</b> {key_count}\n"
+            builder.row(InlineKeyboardButton(text=ADD_SUB, callback_data="create_key"))
+        else:
+            builder.row(InlineKeyboardButton(text=MY_SUBS, callback_data="view_keys"))
+        builder.row(InlineKeyboardButton(text=BALANCE, callback_data="balance"))
+        builder.row(
+            InlineKeyboardButton(text=INVITE, callback_data="invite"),
+            InlineKeyboardButton(text=GIFTS, callback_data="gifts"),
         )
-        
+        if INSTRUCTIONS_BUTTON:
-        # Кнопки для действий в профиле с добавленными смайликами
+            builder.row(InlineKeyboardButton(text=INSTRUCTIONS, callback_data="instructions"))
-        button_create_key = InlineKeyboardButton(text='🔑 Создать ключ', callback_data='create_key')
+        if admin:
-        button_view_keys = InlineKeyboardButton(text='🔐 Мои ключи', callback_data='view_keys')
+            builder.row(
-        button_replenish_balance = InlineKeyboardButton(text='💳 Пополнить баланс', callback_data='replenish_balance')
+                InlineKeyboardButton(text="🔧 Администратор", callback_data=AdminPanelCallback(action="admin").pack())
-        button_back = InlineKeyboardButton(text='⬅️ Назад', callback_data='back_to_menu')  # Добавляем кнопку "Назад"
+            )
-        
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [button_create_key],
-            [button_view_keys],
-            [button_replenish_balance],
-            [button_back]
-        ])
 
-    except Exception as e:
+        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="start"))
-        profile_message = f"❗️ Ошибка при получении данных профиля: {e}"
+
-        keyboard = None
+        await edit_or_send_message(
-    
+            target_message=target_message,
-    # Удаляем текущее сообщение
+            text=profile_message,
-    await callback_query.message.delete()
+            reply_markup=builder.as_markup(),
-    
+            media_path=image_path,
-    # Отправляем новое сообщение с профилем через bot
+            disable_web_page_preview=False,
-    await bot.send_message(
+            force_text=True,
-        chat_id=tg_id,  # ID чата, куда отправляем сообщение
+        )
-        text=profile_message,
+    finally:
-        parse_mode='HTML',
+        await conn.close()
-        reply_markup=keyboard
+
+
+@router.callback_query(F.data == "balance")
+async def balance_handler(callback_query: CallbackQuery, session: Any):
+    result = await session.fetchrow(
+        "SELECT balance FROM connections WHERE tg_id = $1",
+        callback_query.from_user.id,
     )
-    
+    balance = result["balance"] if result else 0.0
-    await callback_query.answer()
+    balance = int(balance)
 
-@router.callback_query(lambda c: c.data == 'view_profile')
+    builder = InlineKeyboardBuilder()
-async def view_profile_handler(callback_query: types.CallbackQuery, state: FSMContext):
+    builder.row(InlineKeyboardButton(text=PAYMENT, callback_data="pay"))
-    await process_callback_view_profile(callback_query, state)
+    builder.row(InlineKeyboardButton(text=BALANCE_HISTORY, callback_data="balance_history"))
+    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
 
+    text = f"<b>Управление вашим балансом 💰</b>\n\nВаш баланс: {balance}"
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=text,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+        disable_web_page_preview=False,
+    )
+
+
+@router.callback_query(F.data == "balance_history")
+async def balance_history_handler(callback_query: CallbackQuery, session: Any):
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text=PAYMENT, callback_data="pay"))
+    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+    records = await get_last_payments(callback_query.from_user.id, session)
+
+    if records:
+        history_text = "📊 <b>Последние 3 операции с балансом:</b>\n\n"
+        for record in records:
+            amount = record["amount"]
+            payment_system = record["payment_system"]
+            status = record["status"]
+            date = record["created_at"].strftime("%Y-%m-%d %H:%M:%S")
+            history_text += (
+                f"<b>Сумма:</b> {amount}₽\n"
+                f"<b>Способ оплаты:</b> {payment_system}\n"
+                f"<b>Статус:</b> {status}\n"
+                f"<b>Дата:</b> {date}\n\n"
+            )
+    else:
+        history_text = "❌ У вас пока нет операций с балансом."
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=history_text,
+        reply_markup=builder.as_markup(),
+        media_path=None,
+        disable_web_page_preview=False,
+    )
+
+
+@router.message(F.text == "/tariffs")
+@router.callback_query(F.data == "view_tariffs")
+async def view_tariffs_handler(callback_query: CallbackQuery):
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    image_path = os.path.join("img", "tariffs.jpg")
+    tariffs_message = "<b>🚀 Доступные тарифы VPN:</b>\n\n" + "\n".join(
+        [
+            f"{months} {'месяц' if months == '1' else 'месяца' if int(months) in [2, 3, 4] else 'месяцев'}: "
+            f"{RENEWAL_PLANS[months]['price']} "
+            f"{'💳' if months == '1' else '🌟' if months == '3' else '🔥' if months == '6' else '🚀'} рублей"
+            for months in sorted(RENEWAL_PLANS.keys(), key=int)
+        ]
+    )
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=tariffs_message,
+        reply_markup=builder.as_markup(),
+        media_path=image_path,
+        disable_web_page_preview=False,
+    )
+
+
+@router.callback_query(F.data == "invite")
+@router.message(F.text == "/invite")
+async def invite_handler(callback_query_or_message: Message | CallbackQuery):
+    chat_id = None
+    if isinstance(callback_query_or_message, CallbackQuery):
+        chat_id = callback_query_or_message.message.chat.id
+        target_message = callback_query_or_message.message
+    else:
+        chat_id = callback_query_or_message.chat.id
+        target_message = callback_query_or_message
+
+    referral_link = get_referral_link(chat_id)
+    referral_stats = await get_referral_stats(chat_id)
+    invite_message = invite_message_send(referral_link, referral_stats)
+    image_path = os.path.join("img", "pic_invite.jpg")
+
+    builder = InlineKeyboardBuilder()
+    if INLINE_MODE:
+        builder.button(text="👥 Пригласить друга", switch_inline_query="invite")
+    else:
+        invite_text = f"\nПриглашаю тебя пользоваться действительно быстрым VPN вместе:\n\n{referral_link}"
+        builder.button(text="👥 Пригласить друга", switch_inline_query=invite_text)
+    builder.button(text="👤 Личный кабинет", callback_data="profile")
+    builder.adjust(1)
+
+    await edit_or_send_message(
+        target_message=target_message,
+        text=invite_message,
+        reply_markup=builder.as_markup(),
+        media_path=image_path,
+        disable_web_page_preview=False,
+    )
+
+
+@router.inline_query(F.query.in_(["referral", "ref", "invite"]))
+async def inline_referral_handler(inline_query: InlineQuery):
+    referral_link = f"https://t.me/{USERNAME_BOT}?start=referral_{inline_query.from_user.id}"
+
+    results: list[InlineQueryResultArticle] = []
+
+    for index, offer in enumerate(REFERRAL_OFFERS):
+        description = offer["description"][:64]
+        message_text = offer["message"].format(trial_time=TRIAL_TIME)[:4096]
+
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=offer["title"], url=referral_link))
+
+        results.append(
+            InlineQueryResultArticle(
+                id=str(index),
+                title=offer["title"],
+                description=description,
+                input_message_content=InputTextMessageContent(message_text=message_text, parse_mode=ParseMode.HTML),
+                reply_markup=builder.as_markup(),
+            )
+        )
+
+    await inline_query.answer(results=results, cache_time=86400, is_personal=True)

handlers/start.py

@@ -1,124 +1,372 @@
 import os
+from typing import Any
 
-from aiogram import Router, types
+from aiogram import F, Router
 from aiogram.filters import Command
 from aiogram.fsm.context import FSMContext
-from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import (
-from aiogram.types import (BufferedInputFile, CallbackQuery,
+    CallbackQuery,
-                           InlineKeyboardButton, InlineKeyboardMarkup, Message)
+    InlineKeyboardButton,
+    Message,
+)
+from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from bot import bot
-from config import ADMIN_ID, CHANNEL_URL
+from config import (
+    CAPTCHA_ENABLE,
+    CHANNEL_EXISTS,
+    CHANNEL_ID,
+    CHANNEL_REQUIRED,
+    CHANNEL_URL,
+    DONATIONS_ENABLE,
+    SUPPORT_CHAT_URL,
+)
+from database import (
+    add_connection,
+    add_referral,
+    check_connection_exists,
+    get_referral_by_referred_id,
+    get_trial,
+    update_balance,
+)
+from handlers.captcha import generate_captcha
+from handlers.keys.key_management import create_key
+from handlers.texts import WELCOME_TEXT, get_about_vpn
+from keyboards.admin.panel_kb import AdminPanelCallback
+from logger import logger
+
+from .utils import edit_or_send_message
 
 router = Router()
 
-class FeedbackState(StatesGroup):
-    waiting_for_feedback = State()
 
-async def send_welcome_message(chat_id: int):
+@router.callback_query(F.data == "start")
-    # Новый текст приветствия
+async def handle_start_callback_query(
-    welcome_text = (
+    callback_query: CallbackQuery, state: FSMContext, session: Any, admin: bool, captcha: bool = False
-        "*SoloNet — ваш провайдер в бесцензурный интернет!*\n\n"
+):
-        "Получите высокую скорость и самый безопасный протокол VPN, "
+    await start_command(callback_query.message, state, session, admin, captcha)
-        "который работает даже в Китае."
-    )
 
-    # Путь к изображению
-    image_path = os.path.join(os.path.dirname(__file__), 'pic.jpg')
 
-    # Проверка существования файла
+@router.message(Command("start"))
-    if not os.path.isfile(image_path):
+async def start_command(message: Message, state: FSMContext, session: Any, admin: bool, captcha: bool = True):
-        await bot.send_message(chat_id, "Файл изображения не найден.")
+    """Обрабатывает команду /start, включая логику проверки подписки, рефералов и подарков."""
+    logger.info(f"Вызвана функция start_command для пользователя {message.chat.id}")
+
+    if CAPTCHA_ENABLE and captcha:
+        captcha_data = await generate_captcha(message, state)
+        await edit_or_send_message(
+            target_message=message,
+            text=captcha_data["text"],
+            reply_markup=captcha_data["markup"],
+        )
         return
 
-    # Создаем inline-клавиатуру
+    state_data = await state.get_data()
-    inline_keyboard = InlineKeyboardMarkup(inline_keyboard=[
+    text_to_process = state_data.get("original_text", message.text)
-        [InlineKeyboardButton(text='👤 Мой профиль', callback_data='view_profile')],
-        [InlineKeyboardButton(text='🔒 О VPN', callback_data='about_vpn')],
-        [InlineKeyboardButton(text='📝 Обратная связь', callback_data='feedback')],
-        [InlineKeyboardButton(text='📢 Наш канал', url=CHANNEL_URL)]
-    ])
 
-    # Отправляем изображение с инлайн-клавиатурой
+    if CHANNEL_EXISTS and CHANNEL_REQUIRED:
-    with open(image_path, 'rb') as image_from_buffer:
+        try:
-        await bot.send_photo(
+            member = await bot.get_chat_member(CHANNEL_ID, message.chat.id)
-            chat_id,
+            if member.status not in ["member", "administrator", "creator"]:
-            BufferedInputFile(image_from_buffer.read(), filename="solo_pic.png"),
+                await state.update_data(original_text=text_to_process)
-            caption=welcome_text,
+                builder = InlineKeyboardBuilder()
-            parse_mode='Markdown',
+                builder.row(InlineKeyboardButton(text="✅ Я подписался", callback_data="check_subscription"))
-            reply_markup=inline_keyboard  # Inline-клавиатура
+                await edit_or_send_message(
+                    target_message=message,
+                    text=f"Для использования бота, пожалуйста, подпишитесь на наш канал: {CHANNEL_URL}",
+                    reply_markup=builder.as_markup(),
+                )
+                return
+            else:
+                logger.info(f"Пользователь {message.chat.id} подписан на канал (статус: {member.status}). Продолжаем работу.")
+        except Exception as e:
+            logger.error(f"Ошибка проверки подписки пользователя {message.chat.id}: {e}")
+            await state.update_data(start_text=text_to_process)
+            builder = InlineKeyboardBuilder()
+            builder.row(InlineKeyboardButton(text="✅ Я подписался", callback_data="check_subscription"))
+            await edit_or_send_message(
+                target_message=message,
+                text=f"Пожалуйста, подпишитесь на наш канал: {CHANNEL_URL}",
+                reply_markup=builder.as_markup(),
+            )
+            return
+    await process_start_logic(message, state, session, admin, text_to_process)
+
+
+async def process_start_logic(
+    message: Message, state: FSMContext, session: Any, admin: bool, text_to_process: str = None
+):
+    text = text_to_process if text_to_process is not None else message.text
+    if text:
+        try:
+            connection_exists = await check_connection_exists(message.chat.id)
+            logger.info(f"Проверка существования подключения: {connection_exists}")
+
+            if not connection_exists:
+                await add_connection(tg_id=message.chat.id, session=session)
+                logger.info(f"Пользователь {message.chat.id} успешно добавлен в базу данных.")
+
+            if "coupons_" in text:
+                logger.info(f"Обнаружена ссылка на купон: {text}")
+                coupon_code = text.split("coupons_")[1].strip()
+                logger.info(f"Пользователь {message.chat.id} ввёл купон: {coupon_code}")
+
+                coupon = await session.fetchrow(
+                    "SELECT id, code, amount, usage_limit, usage_count, is_used FROM coupons WHERE code = $1",
+                    coupon_code,
+                )
+                if coupon is None:
+                    logger.warning(f"Купон {coupon_code} не найден.")
+                    await message.answer("❌ Купон не найден!")
+                    return await show_start_menu(message, admin, session)
+
+                usage_exists = await session.fetchval(
+                    "SELECT 1 FROM coupon_usages WHERE coupon_id = $1 AND user_id = $2",
+                    coupon["id"],
+                    message.chat.id,
+                )
+                if usage_exists:
+                    logger.info(f"Пользователь {message.chat.id} уже активировал купон {coupon_code}.")
+                    await message.answer("❌ Вы уже использовали этот купон!")
+                    return await show_start_menu(message, admin, session)
+
+                if coupon["is_used"] or coupon["usage_count"] >= coupon["usage_limit"]:
+                    logger.info(f"Купон {coupon_code} уже использован или исчерпан.")
+                    await message.answer("❌ Этот купон уже использован!")
+                    return await show_start_menu(message, admin, session)
+
+                await update_balance(message.chat.id, coupon["amount"])
+                logger.info(f"Начислено {coupon['amount']} единиц для пользователя {message.chat.id}")
+
+                new_usage_count = coupon["usage_count"] + 1
+                is_used = new_usage_count >= coupon["usage_limit"]
+
+                await session.execute(
+                    "UPDATE coupons SET usage_count = $1, is_used = $2 WHERE code = $3",
+                    new_usage_count,
+                    is_used,
+                    coupon_code,
+                )
+
+                await session.execute(
+                    "INSERT INTO coupon_usages (coupon_id, user_id, used_at) VALUES ($1, $2, NOW())",
+                    coupon["id"],
+                    message.chat.id,
+                )
+
+                logger.info(
+                    f"Купон {coupon_code} успешно использован пользователем {message.chat.id}, начислено {coupon['amount']} RUB."
+                )
+                await message.answer(f"🎉 Ваш баланс пополнен на {coupon['amount']} RUB по купону!")
+                return await show_start_menu(message, admin, session)
+
+            if "gift_" in text:
+                logger.info(f"Обнаружена ссылка на подарок: {text}")
+                parts = text.split("gift_")[1].split("_")
+                if len(parts) < 2:
+                    logger.error("Неверный формат ссылки на подарок: недостаточно частей после 'gift_'")
+                    await message.answer("❌ Неверный формат ссылки на подарок.")
+                    return await show_start_menu(message, admin, session)
+                gift_id = parts[0]
+                recipient_tg_id = message.chat.id
+
+                gift_info = await session.fetchrow(
+                    """
+                    SELECT sender_tg_id, selected_months, expiry_time, is_used, recipient_tg_id 
+                    FROM gifts WHERE gift_id = $1
+                    """,
+                    gift_id,
+                )
+
+                if gift_info is None:
+                    logger.warning(f"Подарок с ID {gift_id} уже был использован или не существует.")
+                    await message.answer("Этот подарок уже был использован или не существует.")
+                    return await show_start_menu(message, admin, session)
+
+                if gift_info["is_used"]:
+                    logger.warning(f"Подарок с ID {gift_id} уже был активирован ранее.")
+                    await message.answer("Этот подарок уже был использован.")
+                    return await show_start_menu(message, admin, session)
+
+                if gift_info["sender_tg_id"] == recipient_tg_id:
+                    logger.warning(f"Пользователь {recipient_tg_id} попытался активировать свой же подарок.")
+                    await message.answer("❌ Вы не можете получить подарок от самого себя.")
+                    return await show_start_menu(message, admin, session)
+
+                if gift_info["recipient_tg_id"] is not None:
+                    logger.warning(
+                        f"Подарок {gift_id} уже привязан к другому пользователю ({gift_info['recipient_tg_id']})."
+                    )
+                    await message.answer("❌ Этот подарок уже был активирован другим пользователем.")
+                    return await show_start_menu(message, admin, session)
+
+                if not connection_exists:
+                    await add_referral(recipient_tg_id, gift_info["sender_tg_id"], session)
+                    logger.info(
+                        f"Пользователь {recipient_tg_id} теперь является рефералом отправителя {gift_info['sender_tg_id']}."
+                    )
+
+                await session.execute(
+                    """
+                    UPDATE connections SET trial = 1 WHERE tg_id = $1
+                    """,
+                    recipient_tg_id,
+                )
+
+                selected_months = gift_info["selected_months"]
+                expiry_time = gift_info["expiry_time"].replace(tzinfo=None)
+
+                logger.info(f"Подарок с ID {gift_id} успешно найден для пользователя {recipient_tg_id}.")
+
+                await create_key(recipient_tg_id, expiry_time, state, session, message)
+                logger.info(f"Ключ создан для пользователя {recipient_tg_id} на срок {selected_months} месяцев.")
+
+                await session.execute(
+                    """
+                    UPDATE gifts SET is_used = TRUE, recipient_tg_id = $1 
+                    WHERE gift_id = $2
+                    """,
+                    recipient_tg_id,
+                    gift_id,
+                )
+
+                await message.answer(
+                    f"🎉 Ваш подарок на {selected_months} "
+                    f"{'месяц' if selected_months == 1 else 'месяца' if selected_months in [2, 3, 4] else 'месяцев'} активирован!"
+                )
+                logger.info(f"Подарок на {selected_months} месяцев активирован для пользователя {recipient_tg_id}.")
+                return
+
+            elif "referral_" in text:
+                try:
+                    referrer_tg_id = int(text.split("referral_")[1])
+                    if connection_exists:
+                        logger.info(f"Пользователь {message.chat.id} уже зарегистрирован и не может стать рефералом.")
+                        await message.answer("❌ Вы уже зарегистрированы и не можете использовать реферальную ссылку.")
+                        return await show_start_menu(message, admin, session)
+
+                    if referrer_tg_id == message.chat.id:
+                        logger.warning(f"Пользователь {message.chat.id} попытался стать рефералом самого себя.")
+                        await message.answer("❌ Вы не можете быть рефералом самого себя.")
+                        return await show_start_menu(message, admin, session)
+
+                    existing_referral = await get_referral_by_referred_id(message.chat.id, session)
+                    if existing_referral:
+                        logger.info(f"Реферал с ID {message.chat.id} уже существует.")
+                        return await show_start_menu(message, admin, session)
+
+                    await add_referral(message.chat.id, referrer_tg_id, session)
+                    logger.info(f"Реферал {message.chat.id} использовал ссылку от пользователя {referrer_tg_id}")
+                    await message.answer(f"Вы стали рефералом пользователя с ID {referrer_tg_id}")
+                    try:
+                        await bot.send_message(referrer_tg_id, f"🎉 Ваш реферал {message.chat.id} успешно зарегистрировался!")
+                        logger.info(f"Уведомление отправлено пользователю {referrer_tg_id} о новом реферале {message.chat.id}")
+                    except Exception as e:
+                        logger.error(f"Не удалось отправить уведомление пригласившему ({referrer_tg_id}): {e}")
+
+                    return await show_start_menu(message, admin, session)
+
+                except (ValueError, IndexError) as e:
+                    logger.error(f"Ошибка при обработке реферальной ссылки: {e}")
+                return
+
+            else:
+                logger.info(f"Пользователь {message.chat.id} зашел без реферальной ссылки, подарка или купона.")
+
+            await show_start_menu(message, admin, session)
+
+        except (ValueError, IndexError) as e:
+            logger.error(f"Ошибка при обработке сообщения пользователя {message.chat.id}: {e}")
+            await message.answer("❌ Произошла ошибка. Пожалуйста, попробуйте снова.")
+    else:
+        await show_start_menu(message, admin, session)
+
+
+@router.callback_query(F.data == "check_subscription")
+async def check_subscription_callback(callback_query: CallbackQuery, state: FSMContext, session: Any, admin: bool):
+    user_id = callback_query.from_user.id
+    logger.info(f"[CALLBACK] Получен callback 'check_subscription' от пользователя {user_id}")
+    try:
+        member = await bot.get_chat_member(CHANNEL_ID, user_id)
+        logger.info(f"[CALLBACK] Статус подписки пользователя {user_id}: {member.status}")
+
+        if member.status not in ["member", "administrator", "creator"]:
+            await callback_query.answer("Вы еще не подписаны на канал!", show_alert=True)
+            builder = InlineKeyboardBuilder()
+            builder.row(InlineKeyboardButton(text="✅ Я подписался", callback_data="check_subscription"))
+            await callback_query.message.edit_text(
+                f"Для использования бота, пожалуйста, подпишитесь на наш канал: {CHANNEL_URL}",
+                reply_markup=builder.as_markup(),
+            )
+        else:
+            await callback_query.answer("Подписка подтверждена!")
+            data = await state.get_data()
+            original_text = data.get("original_text")
+            if not original_text:
+                original_text = callback_query.message.text
+            await process_start_logic(callback_query.message, state, session, admin, text_to_process=original_text)
+            logger.info(f"[CALLBACK] Завершен вызов process_start_logic для пользователя {user_id}")
+    except Exception as e:
+        logger.error(f"[CALLBACK] Ошибка проверки подписки для пользователя {user_id}: {e}", exc_info=True)
+        await callback_query.answer("Ошибка проверки подписки, повторите попытку", show_alert=True)
+
+
+async def show_start_menu(message: Message, admin: bool, session: Any):
+    """Функция для отображения стандартного меню через редактирование сообщения.
+    Если редактирование не удалось, отправляем новое сообщение."""
+    logger.info(f"Показываю главное меню для пользователя {message.chat.id}")
+
+    image_path = os.path.join("img", "pic.jpg")
+    builder = InlineKeyboardBuilder()
+
+    if session is not None:
+        trial_status = await get_trial(message.chat.id, session)
+        logger.info(f"Trial status для {message.chat.id}: {trial_status}")
+        if trial_status == 0:
+            builder.row(InlineKeyboardButton(text="🔗 Подключить VPN", callback_data="create_key"))
+    else:
+        logger.warning(f"Сессия базы данных отсутствует, пропускаем проверку триала для {message.chat.id}")
+
+    builder.row(InlineKeyboardButton(text="👤 Личный кабинет", callback_data="profile"))
+
+    if CHANNEL_EXISTS:
+        builder.row(
+            InlineKeyboardButton(text="📞 Поддержка", url=SUPPORT_CHAT_URL),
+            InlineKeyboardButton(text="📢 Канал", url=CHANNEL_URL),
+        )
+    else:
+        builder.row(InlineKeyboardButton(text="📞 Поддержка", url=SUPPORT_CHAT_URL))
+
+    if admin:
+        builder.row(
+            InlineKeyboardButton(text="🔧 Администратор", callback_data=AdminPanelCallback(action="admin").pack())
         )
 
-@router.message(Command('start'))
+    builder.row(InlineKeyboardButton(text="🌐 О VPN", callback_data="about_vpn"))
-async def start_command(message: Message):
-    await send_welcome_message(message.chat.id)
 
-@router.callback_query(lambda c: c.data == 'about_vpn')
+    await edit_or_send_message(
+        target_message=message,
+        text=WELCOME_TEXT,
+        reply_markup=builder.as_markup(),
+        media_path=image_path,
+    )
+
+
+@router.callback_query(F.data == "about_vpn")
 async def handle_about_vpn(callback_query: CallbackQuery):
-    # Удаляем сообщение главного меню
+    builder = InlineKeyboardBuilder()
-    await callback_query.message.delete()
+    if DONATIONS_ENABLE:
+        builder.row(InlineKeyboardButton(text="💰 Поддержать проект", callback_data="donate"))
+    builder.row(InlineKeyboardButton(text="📞 Техническая поддержка", url=SUPPORT_CHAT_URL))
+    if CHANNEL_EXISTS:
+        builder.row(InlineKeyboardButton(text="📢 Канал", url=CHANNEL_URL))
+    builder.row(InlineKeyboardButton(text="⬅️ Назад", callback_data="start"))
+    text = get_about_vpn("3.2.3-minor")
 
-    info_message = (
+    await edit_or_send_message(
-        "*О VPN*\n\n"
+        target_message=callback_query.message,
-        "Мы используем VLESS для обеспечения безопасного и надежного подключения к интернету. "
+        text=text,
-        "Каждому пользователю предоставляется индивидуальный ключ для подключения. "
+        reply_markup=builder.as_markup(),
-        "Этот ключ необходим для использования нашего VPN-сервиса."
+        media_path=None,
+        force_text=False,
     )
-    
-    button_back = InlineKeyboardButton(text='⬅️ Назад', callback_data='back_to_menu')
-    inline_keyboard_back = InlineKeyboardMarkup(inline_keyboard=[[button_back]])
-
-    await callback_query.message.answer(
-        info_message,
-        parse_mode='Markdown',
-        reply_markup=inline_keyboard_back
-    )
-    await callback_query.answer()
-
-@router.callback_query(lambda c: c.data == 'back_to_menu')
-async def handle_back_to_menu(callback_query: CallbackQuery):
-    # Удаляем текущее сообщение
-    await callback_query.message.delete()
-    
-    # Отправляем приветственное сообщение
-    await send_welcome_message(callback_query.from_user.id)
-    await callback_query.answer()
-
-@router.callback_query(lambda c: c.data == 'feedback')
-async def handle_feedback(callback_query: CallbackQuery, state: FSMContext):
-    # Удаляем сообщение главного меню
-    await callback_query.message.delete()
-
-    feedback_text = "Напишите нам, если у вас возникли трудности с подключением, есть отзыв или предложение. @pocomacho"
-
-    button_back = InlineKeyboardButton(text='⬅️ Назад', callback_data='back_to_menu')
-    inline_keyboard_back = InlineKeyboardMarkup(inline_keyboard=[[button_back]])
-
-    await callback_query.message.answer(
-        feedback_text,
-        parse_mode='Markdown',
-        reply_markup=inline_keyboard_back
-    )
-
-    await state.set_state(FeedbackState.waiting_for_feedback)
-    await state.update_data(user_id=callback_query.from_user.id)
-    await callback_query.answer()
-
-@router.message(FeedbackState.waiting_for_feedback)
-async def receive_feedback(message: types.Message, state: FSMContext):
-    user_data = await state.get_data()
-    user_id = user_data.get('user_id')
-
-    feedback_message = (
-        f"Обратная связь от пользователя {user_id}:\n\n"
-        f"{message.text}"
-    )
-
-    try:
-        await bot.send_message(ADMIN_ID, feedback_message)
-        await message.answer("Спасибо за ваше сообщение! Мы свяжемся с вами, если это будет необходимо.")
-    except Exception as e:
-        await message.answer("Произошла ошибка при отправке вашего сообщения.")
-        print(f"Ошибка при отправке обратной связи: {e}")  # Логирование ошибок
-
-    await state.clear()

handlers/utils.py

@@ -0,0 +1,224 @@
+import json
+import os
+import re
+import secrets
+import string
+
+import aiofiles
+import aiohttp
+import asyncpg
+from aiogram.types import BufferedInputFile, InlineKeyboardMarkup, InputMediaPhoto, Message
+
+from bot import bot
+from config import DATABASE_URL
+from database import get_all_keys, get_servers
+from logger import logger
+
+
+async def get_usd_rate():
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get("https://www.cbr-xml-daily.ru/daily_json.js") as response:
+                if response.status == 200:
+                    data = await response.text()
+                    usd = float(json.loads(data)["Valute"]["USD"]["Value"])
+                else:
+                    usd = float(100)
+    except Exception as e:
+        logger.exception(f"Error fetching USD rate: {e}")
+        usd = float(100)
+    return usd
+
+
+def sanitize_key_name(key_name: str) -> str:
+    """
+    Очищает название ключа, оставляя только допустимые символы.
+
+    Args:
+        key_name (str): Исходное название ключа.
+
+    Returns:
+        str: Очищенное название ключа в нижнем регистре.
+    """
+    return re.sub(r"[^a-z0-9@._-]", "", key_name.lower())
+
+
+def generate_random_email(length: int = 6) -> str:
+    """
+    Генерирует случайный email с заданной длиной.
+
+    Args:
+        length (int, optional): Длина случайной строки. По умолчанию 6.
+
+    Returns:
+        str: Сгенерированная случайная строка.
+    """
+    return "".join(secrets.choice(string.ascii_lowercase + string.digits) for _ in range(length)) if length > 0 else ""
+
+
+async def get_least_loaded_cluster() -> str:
+    """
+    Определяет кластер с наименьшей загрузкой.
+
+    Returns:
+        str: Идентификатор наименее загруженного кластера.
+    """
+    servers = await get_servers()
+
+    cluster_loads: dict[str, int] = {cluster_id: 0 for cluster_id in servers.keys()}
+
+    async with asyncpg.create_pool(DATABASE_URL) as pool:
+        async with pool.acquire() as conn:
+            keys = await get_all_keys(conn)
+            for key in keys:
+                cluster_id = key["server_id"]
+                if cluster_id in cluster_loads:
+                    cluster_loads[cluster_id] += 1
+
+    logger.info(f"Cluster loads after database query: {cluster_loads}")
+
+    if not cluster_loads:
+        logger.warning("No clusters found in database or configuration.")
+        return "cluster1"
+
+    least_loaded_cluster = min(cluster_loads, key=lambda k: (cluster_loads[k], k))
+
+    logger.info(f"Least loaded cluster selected: {least_loaded_cluster}")
+
+    return least_loaded_cluster
+
+
+async def handle_error(tg_id: int, callback_query: object | None = None, message: str = "") -> None:
+    """
+    Обрабатывает ошибку, отправляя сообщение пользователю.
+
+    Args:
+        tg_id (int): Идентификатор пользователя в Telegram.
+        callback_query (Optional[object], optional): Объект запроса обратного вызова. По умолчанию None.
+        message (str, optional): Текст сообщения об ошибке. По умолчанию пустая строка.
+    """
+    try:
+        if callback_query and hasattr(callback_query, "message"):
+            try:
+                await bot.delete_message(chat_id=tg_id, message_id=callback_query.message.message_id)
+            except Exception as delete_error:
+                logger.warning(f"Не удалось удалить сообщение: {delete_error}")
+
+        await bot.send_message(tg_id, message)
+
+    except Exception as e:
+        logger.error(f"Ошибка при обработке ошибки: {e}")
+
+
+def format_time_until_deletion(seconds: int) -> str:
+    if seconds <= 0:
+        return "0 минут"
+
+    days = seconds // (3600 * 24)
+    hours = (seconds % (3600 * 24)) // 3600
+    minutes = (seconds % 3600 + 59) // 60
+
+    parts = []
+
+    if days > 0:
+        if days == 1:
+            parts.append(f"{days} день")
+        elif 2 <= days <= 4:
+            parts.append(f"{days} дня")
+        else:
+            parts.append(f"{days} дней")
+
+    if hours > 0:
+        if hours == 1:
+            parts.append(f"{hours} час")
+        elif 2 <= hours <= 4:
+            parts.append(f"{hours} часа")
+        else:
+            parts.append(f"{hours} часов")
+
+    if minutes > 0 and days == 0:
+        if minutes == 1:
+            parts.append("1 минута")
+        elif 2 <= minutes <= 4:
+            parts.append(f"{minutes} минуты")
+        else:
+            parts.append(f"{minutes} минут")
+
+    return " и ".join(parts) if parts else "менее минуты"
+
+
+async def edit_or_send_message(
+    target_message: Message,
+    text: str,
+    reply_markup: InlineKeyboardMarkup,
+    media_path: str = None,
+    disable_web_page_preview: bool = False,
+    force_text: bool = False,
+):
+    """
+    Универсальная функция для редактирования исходного сообщения target_message.
+
+    - Если media_path указан и существует, считается, что сообщение содержит фото, и используется редактирование медиа
+      (замена фото и подписи) через edit_media. Если редактирование не удаётся, отправляется новое сообщение с фото.
+
+    - Если media_path не указан:
+        - Если force_text=False и target_message уже имеет caption, пытаемся отредактировать подпись (edit_caption).
+        - Иначе (или если редактирование caption не удалось) — редактируем текст (edit_text).
+
+    В случае неудачи fallback – отправка нового сообщения.
+    """
+    if media_path and os.path.isfile(media_path):
+        async with aiofiles.open(media_path, "rb") as f:
+            image_data = await f.read()
+        media = InputMediaPhoto(
+            media=BufferedInputFile(image_data, filename=os.path.basename(media_path)),
+            caption=text,
+        )
+        try:
+            await target_message.edit_media(media=media, reply_markup=reply_markup)
+            return
+        except Exception:
+            await target_message.answer_photo(
+                photo=BufferedInputFile(image_data, filename=os.path.basename(media_path)),
+                caption=text,
+                reply_markup=reply_markup,
+                disable_web_page_preview=disable_web_page_preview,
+            )
+            return
+    else:
+        if not force_text and target_message.caption is not None:
+            try:
+                await target_message.edit_caption(caption=text, reply_markup=reply_markup)
+                return
+            except Exception as e:
+                logger.error(f"Ошибка редактирования подписи: {e}")
+        try:
+            await target_message.edit_text(
+                text=text,
+                reply_markup=reply_markup,
+                disable_web_page_preview=disable_web_page_preview,
+            )
+            return
+        except Exception as e:
+            await target_message.answer(
+                text=text,
+                reply_markup=reply_markup,
+                disable_web_page_preview=disable_web_page_preview,
+            )
+
+
+def convert_to_bytes(value: float, unit: str) -> int:
+    """
+    Конвертирует значение с указанной единицей измерения в байты.
+    Args:
+        value (float): Числовое значение.
+        unit (str): Единица измерения ('KB', 'MB', 'GB', 'TB').
+    Returns:
+        int: Количество байт.
+    """
+    KB = 1024
+    MB = KB * 1024
+    GB = MB * 1024
+    TB = GB * 1024
+    units = {"KB": KB, "MB": MB, "GB": GB, "TB": TB}
+    return int(value * units.get(unit.upper(), 1))

key_management.py

@@ -1,228 +0,0 @@
-import asyncio
-import re
-import uuid
-from datetime import datetime, timedelta
-
-import asyncpg
-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,
-                           InlineKeyboardMarkup, Message)
-
-from auth import link, login_with_credentials
-from bot import bot, dp
-from client import add_client
-from config import (ADMIN_ID, ADMIN_PASSWORD, ADMIN_USERNAME, API_TOKEN,
-                    DATABASE_URL)
-from database import (add_connection, get_balance, has_active_key, store_key,
-                      update_balance)
-from handlers.instructions import send_instructions
-from handlers.profile import process_callback_view_profile
-from handlers.start import start_command
-
-router = Router()
-
-# Удаляем специальные символы из имени ключа
-def sanitize_key_name(key_name: str) -> str:
-    return re.sub(r'[^a-z0-9@._-]', '', key_name.lower())
-
-class Form(StatesGroup):
-    waiting_for_key_name = State()
-    viewing_profile = State()
-
-@dp.callback_query(F.data == 'create_key')
-async def process_callback_create_key(callback_query: CallbackQuery, state: FSMContext):
-    tg_id = callback_query.from_user.id
-
-    # Получаем данные о trial из базы данных
-    conn = await asyncpg.connect(DATABASE_URL)
-    try:
-        existing_connection = await conn.fetchrow('SELECT trial FROM connections WHERE tg_id = $1', tg_id)
-    finally:
-        await conn.close()
-
-    trial_status = existing_connection['trial'] if existing_connection else 0
-
-    if trial_status == 1:
-        await callback_query.message.edit_text(
-            "<b>⚠️ У вас уже был пробный ключ.</b>\n\n"
-            "Новый ключ будет выдан на <b>один месяц</b> и стоит <b>100 рублей</b>.\n\n"
-            "<i>Хотите продолжить?</i>",
-            parse_mode="HTML",  # Добавляем параметр parse_mode
-            reply_markup=InlineKeyboardMarkup(inline_keyboard=[
-                [InlineKeyboardButton(text='✅ Да, создать новый ключ', callback_data='confirm_create_new_key')],
-                [InlineKeyboardButton(text='↩️ Назад', callback_data='cancel_create_key')]
-            ])
-        )
-        await state.update_data(creating_new_key=True)
-    else:
-        await callback_query.message.edit_text(
-            "<b>🎉 Вам будет выдан пробный ключ на 24 часа!</b>\n\n"
-            "<i>Пожалуйста, введите название для вашего пробного ключа:</i>",
-            parse_mode="HTML"
-        )
-        await state.set_state(Form.waiting_for_key_name)
-
-    await callback_query.answer()
-
-@dp.callback_query(F.data == 'confirm_create_new_key')
-async def confirm_create_new_key(callback_query: CallbackQuery, state: FSMContext):
-    tg_id = callback_query.from_user.id
-
-    # Проверяем баланс перед созданием нового ключа
-    balance = await get_balance(tg_id)
-    if balance < 100:
-        replenish_button = InlineKeyboardButton(text='Перейти в профиль', callback_data='view_profile')
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[[replenish_button]])
-        await callback_query.message.edit_text(
-            "❗️ Недостаточно средств на балансе для создания нового ключа. "
-            "Пожалуйста, пополните баланс.", 
-            reply_markup=keyboard
-        )
-        await state.clear()
-        return
-
-    await callback_query.message.edit_text("🔑 Пожалуйста, введите имя нового ключа:")
-    await state.set_state(Form.waiting_for_key_name)
-    await state.update_data(creating_new_key=True)
-
-    await callback_query.answer()
-
-@dp.callback_query(F.data == 'cancel_create_key')
-async def cancel_create_key(callback_query: CallbackQuery, state: FSMContext):
-    await process_callback_view_profile(callback_query, state)
-    await callback_query.answer()
-
-# Обработка текстовых сообщений
-@dp.message()
-async def handle_text(message: Message, state: FSMContext):
-    current_state = await state.get_state()
-    
-    if message.text == "Мой профиль":
-        callback_query = types.CallbackQuery(
-            id="1",
-            from_user=message.from_user,
-            chat_instance='',
-            data='view_profile',
-            message=message
-        )
-        await process_callback_view_profile(callback_query, state)
-        return
-
-    if message.text in ["/start", "/menu"]:
-        await start_command(message)
-        return
-    
-    if current_state == Form.waiting_for_key_name.state:
-        await handle_key_name_input(message, state)
-
-async def handle_key_name_input(message: Message, state: FSMContext):
-    tg_id = message.from_user.id
-    key_name = sanitize_key_name(message.text)
-
-    if not key_name:
-        await message.bot.send_message(tg_id, "📝 Пожалуйста, назовите профиль на английском языке.")
-        return
-
-    data = await state.get_data()
-    creating_new_key = data.get('creating_new_key', False)
-
-    session = login_with_credentials(ADMIN_USERNAME, ADMIN_PASSWORD)
-    client_id = str(uuid.uuid4())
-    email = key_name.lower()
-    current_time = datetime.utcnow()
-    expiry_time = None
-
-    # Получаем статус пробного ключа из базы данных
-    conn = await asyncpg.connect(DATABASE_URL)
-    try:
-        existing_connection = await conn.fetchrow('SELECT trial FROM connections WHERE tg_id = $1', tg_id)
-    finally:
-        await conn.close()
-
-    trial_status = existing_connection['trial'] if existing_connection else 0
-
-    if trial_status == 0:
-        # Создаем пробный ключ на 1 день
-        expiry_time = current_time + timedelta(days=1, hours=3)
-    else:
-        # Проверяем баланс перед созданием нового ключа
-        balance = await get_balance(tg_id)
-        if balance < 100:
-            replenish_button = InlineKeyboardButton(text='Перейти в профиль', callback_data='view_profile')
-            keyboard = InlineKeyboardMarkup(inline_keyboard=[[replenish_button]])
-            await message.bot.send_message(tg_id, "❗️ Недостаточно средств на балансе для создания нового ключа.", reply_markup=keyboard)
-            await state.clear()
-            return
-
-        await update_balance(tg_id, -100)
-        expiry_time = current_time + timedelta(days=30, hours=3)
-
-    expiry_timestamp = int(expiry_time.timestamp() * 1000)
-
-    try:
-        # Попробуем добавить клиента
-        response = add_client(session, client_id, email, tg_id, limit_ip=1, total_gb=0, expiry_time=expiry_timestamp, enable=True, flow="xtls-rprx-vision")
-        
-        if not response.get("success", True):
-            error_msg = response.get("msg", "Неизвестная ошибка.")
-            if "Duplicate email" in error_msg:
-                await message.bot.send_message(tg_id, "❌ Этот email уже используется. Пожалуйста, выберите другое имя для ключа.")
-                await state.set_state(Form.waiting_for_key_name)
-                return
-            else:
-                raise Exception(error_msg)
-
-        connection_link = link(session, client_id, email)
-
-        conn = await asyncpg.connect(DATABASE_URL)
-        try:
-            existing_connection = await conn.fetchrow('SELECT * FROM connections WHERE tg_id = $1', tg_id)
-
-            if existing_connection:
-                await conn.execute('UPDATE connections SET trial = 1 WHERE tg_id = $1', tg_id)
-            else:
-                await add_connection(tg_id, 0, 1)
-        finally:
-            await conn.close()
-
-        await store_key(tg_id, client_id, email, expiry_timestamp, connection_link)
-
-        # Рассчитываем оставшееся время до окончания действия ключа
-        remaining_time = expiry_time - current_time
-        days = remaining_time.days
-        hours, remainder = divmod(remaining_time.seconds, 3600)
-        minutes, _ = divmod(remainder, 60)
-
-        # Формируем сообщение с информацией о ключе
-        remaining_time_message = (
-            f"Оставшееся время ключа: {days} день"
-        )
-
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text='📖 Инструкции по использованию', callback_data='instructions')],
-            [InlineKeyboardButton(text='🔙 Перейти в профиль', callback_data='view_profile')]
-        ])
-
-        key_message = (
-            "✅ Ключ успешно создан:\n"
-            f"<pre>{connection_link}</pre>\n\n"
-            f"{remaining_time_message}"
-        )
-
-        await message.bot.send_message(tg_id, key_message, parse_mode="HTML", reply_markup=keyboard)
-
-    except Exception as e:
-        await message.bot.send_message(tg_id, f"❌ Ошибка при создании ключа: {e}")
-
-    await state.clear()
-
-@dp.callback_query(F.data == 'instructions')
-async def handle_instructions(callback_query: CallbackQuery):
-    await send_instructions(callback_query) 
-
-@dp.callback_query(F.data == 'back_to_main')
-async def handle_back_to_main(callback_query: CallbackQuery, state: FSMContext):
-    await process_callback_view_profile(callback_query, state)
-    await callback_query.answer()

keyboards/admin/bans_kb.py

@@ -0,0 +1,13 @@
+from aiogram.types import InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_btn
+
+
+def build_bans_kb() -> InlineKeyboardMarkup:
+    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.adjust(1)
+    return builder.as_markup()

keyboards/admin/coupons_kb.py

@@ -0,0 +1,50 @@
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_btn
+
+
+class AdminCouponDeleteCallback(CallbackData, prefix="admin_coupon_delete"):
+    coupon_code: str
+
+
+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(build_admin_back_btn())
+    return builder.as_markup()
+
+
+def build_coupons_list_kb(coupons: list, current_page: int, total_pages: int) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    for coupon in coupons:
+        coupon_code = coupon["code"]
+        builder.button(
+            text=f"❌{coupon_code}",
+            callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code).pack(),
+        )
+
+    pagination_buttons = []
+    if current_page > 1:
+        pagination_buttons.append(
+            InlineKeyboardButton(
+                text="⬅️ Назад",
+                callback_data=AdminPanelCallback(action="coupons_list", page=current_page - 1).pack(),
+            )
+        )
+    if current_page < total_pages:
+        pagination_buttons.append(
+            InlineKeyboardButton(
+                text="Вперед ➡️",
+                callback_data=AdminPanelCallback(action="coupons_list", page=current_page + 1).pack(),
+            )
+        )
+    if pagination_buttons:
+        builder.row(*pagination_buttons)
+
+    builder.row(build_admin_back_btn("coupons"))
+    builder.adjust(2)
+    return builder.as_markup()

keyboards/admin/panel_kb.py

@@ -0,0 +1,68 @@
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+
+class AdminPanelCallback(CallbackData, prefix="admin_panel"):
+    action: str
+    page: int
+
+    def __init__(self, *args, **kwargs):
+        if "page" not in kwargs or kwargs["page"] is None:
+            kwargs["page"] = 1
+        super().__init__(*args, **kwargs)
+
+
+def build_panel_kb() -> 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="servers").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()),
+    )
+    builder.button(text="Личный кабинет", callback_data="profile")
+    builder.adjust(1, 1, 2, 1, 2, 1)
+    return builder.as_markup()
+
+
+def build_management_kb() -> 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.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_restart_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(text="✅ Да, перезагрузить", callback_data=AdminPanelCallback(action="restart_confirm").pack())
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_admin_back_kb(action: str = "admin") -> InlineKeyboardMarkup:
+    return build_admin_singleton_kb("🔙 Назад", action)
+
+
+def build_admin_singleton_kb(text: str, action: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.row(build_admin_btn(text, action))
+    return builder.as_markup()
+
+
+def build_admin_back_btn(action: str = "admin") -> InlineKeyboardButton:
+    return build_admin_btn("🔙 Назад", action)
+
+
+def build_admin_btn(text: str, action: str) -> InlineKeyboardButton:
+    return InlineKeyboardButton(text=text, callback_data=AdminPanelCallback(action=action).pack())

keyboards/admin/sender_kb.py

@@ -0,0 +1,32 @@
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from keyboards.admin.panel_kb import build_admin_back_btn
+
+
+class AdminSenderCallback(CallbackData, prefix="admin_sender"):
+    type: str
+    data: str | None = None
+
+
+def build_sender_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(text="👥 Все пользователи", callback_data=AdminSenderCallback(type="all").pack())
+    builder.button(text="✅ Пользователи с подпиской", callback_data=AdminSenderCallback(type="subscribed").pack())
+    builder.button(text="❌ Пользователи без подписки", callback_data=AdminSenderCallback(type="unsubscribed").pack())
+    builder.button(text="📢 Пользователи кластера", callback_data=AdminSenderCallback(type="cluster-select").pack())
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_clusters_kb(clusters: list) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    for cluster in clusters:
+        name = cluster["cluster_name"]
+        builder.button(text=f"🌐 {name}", callback_data=AdminSenderCallback(type="cluster", data=name).pack())
+
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()

keyboards/admin/servers_kb.py

@@ -0,0 +1,81 @@
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_btn
+
+
+class AdminServerEditorCallback(CallbackData, prefix="admin_servers"):
+    action: str
+    data: str
+
+
+def build_clusters_editor_kb(servers: dict) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    for cluster_name in servers:
+        builder.button(
+            text=f"⚙️ {cluster_name}",
+            callback_data=AdminServerEditorCallback(action="clusters_manage", data=cluster_name).pack(),
+        )
+
+    builder.button(text="➕ Добавить кластер", callback_data=AdminPanelCallback(action="clusters_add").pack())
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_manage_cluster_kb(cluster_servers, cluster_name) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+
+    for server in cluster_servers:
+        builder.button(
+            text=f"🌍 {server['server_name']}",
+            callback_data=AdminServerEditorCallback(action="servers_manage", data=server["server_name"]).pack(),
+        )
+
+    builder.button(
+        text="➕ Добавить сервер",
+        callback_data=AdminServerEditorCallback(action="servers_add", data=cluster_name).pack(),
+    )
+    builder.row(
+        InlineKeyboardButton(
+            text="🌐 Доступность",
+            callback_data=AdminServerEditorCallback(action="servers_availability", data=cluster_name).pack(),
+        ),
+        InlineKeyboardButton(
+            text="🔄 Синхронизация",
+            callback_data=AdminServerEditorCallback(action="clusters_sync", data=cluster_name).pack(),
+        ),
+    )
+    builder.button(
+        text="💾 Создать бэкап кластера",
+        callback_data=AdminServerEditorCallback(action="clusters_backup", data=cluster_name).pack(),
+    )
+    builder.row(build_admin_back_btn("servers"))
+    builder.adjust(1, 1, 1, 1, 1, 2, 1)
+    return builder.as_markup()
+
+
+def build_manage_server_kb(server_name: str, cluster_name: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(
+        text="🗑️ Удалить", callback_data=AdminServerEditorCallback(action="servers_delete", data=server_name).pack()
+    )
+    builder.button(
+        text="🔙 Назад", callback_data=AdminServerEditorCallback(action="clusters_manage", data=cluster_name).pack()
+    )
+    builder.adjust(1)
+    return builder.as_markup()
+
+
+def build_delete_server_kb(server_name: str) -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(
+        text="✅ Да", callback_data=AdminServerEditorCallback(action="servers_delete_confirm", data=server_name).pack()
+    )
+    builder.button(
+        text="🔙 Назад", callback_data=AdminServerEditorCallback(action="servers_manage", data=server_name).pack()
+    )
+    builder.adjust(1)
+    return builder.as_markup()

keyboards/admin/stats_kb.py

@@ -0,0 +1,19 @@
+from aiogram.types import InlineKeyboardMarkup
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from keyboards.admin.panel_kb import AdminPanelCallback, build_admin_back_btn
+
+
+def build_stats_kb() -> InlineKeyboardMarkup:
+    builder = InlineKeyboardBuilder()
+    builder.button(text="🔄 Обновить", callback_data=AdminPanelCallback(action="stats").pack())
+    builder.button(
+        text="📥 Выгрузить пользователей в CSV",
+        callback_data=AdminPanelCallback(action="stats_export_users_csv").pack(),
+    )
+    builder.button(
+        text="📥 Выгрузить оплаты в CSV", callback_data=AdminPanelCallback(action="stats_export_payments_csv").pack()
+    )
+    builder.row(build_admin_back_btn())
+    builder.adjust(1)
+    return builder.as_markup()