Merge pull request #194 from Vladless/dev

v4.2

README.md

@@ -1,6 +1,6 @@
 # 🚀 SoloBot
 
-**SoloBot** — ваш идеальный помощник для управления API 3x-UI VPN на протоколе VLESS.
+**SoloBot** — ваш идеальный помощник для управления 3x-UI или Remnawave на протоколе VLESS.
 
 <img src=".github/images/preview.gif" alt="SoloBot" width="1600">
 

assets/schema.sql

@@ -1,3 +1,4 @@
+
 CREATE TABLE IF NOT EXISTS users
 (
     tg_id         BIGINT PRIMARY KEY NOT NULL,
@@ -7,15 +8,28 @@ CREATE TABLE IF NOT EXISTS users
     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
+    updated_at    TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    balance       REAL                    NOT NULL DEFAULT 0.0,
+    trial         INTEGER                 NOT NULL DEFAULT 0
 );
 
-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
-);
+DO $$
+BEGIN
+    IF NOT EXISTS (
+        SELECT 1 FROM information_schema.columns 
+        WHERE table_name = 'users' AND column_name = 'balance'
+    ) THEN
+        ALTER TABLE users ADD COLUMN balance REAL NOT NULL DEFAULT 0.0;
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM information_schema.columns 
+        WHERE table_name = 'users' AND column_name = 'trial'
+    ) THEN
+        ALTER TABLE users ADD COLUMN trial INTEGER NOT NULL DEFAULT 0;
+    END IF;
+END$$;
+
 
 CREATE TABLE IF NOT EXISTS payments
 (
@@ -74,7 +88,6 @@ BEGIN
     END IF;
 END$$;
 
-
 CREATE TABLE IF NOT EXISTS referrals
 (
     referred_tg_id BIGINT PRIMARY KEY NOT NULL,
@@ -125,38 +138,76 @@ CREATE TABLE IF NOT EXISTS servers
     cluster_name     TEXT NOT NULL,
     server_name      TEXT NOT NULL,
     api_url          TEXT NOT NULL,
-    subscription_url TEXT NOT NULL,
+    subscription_url TEXT,
     inbound_id       TEXT NOT NULL,
+    panel_type       TEXT NOT NULL DEFAULT '3x-ui',
+    enabled          BOOLEAN NOT NULL DEFAULT TRUE,
+    max_keys         INTEGER,
     UNIQUE (cluster_name, server_name) 
 );
 
 ALTER TABLE servers ADD COLUMN IF NOT EXISTS panel_type TEXT NOT NULL DEFAULT '3x-ui';
-ALTER TABLE servers
-    ALTER COLUMN subscription_url DROP NOT NULL;
-
+ ALTER TABLE servers
+     ALTER COLUMN subscription_url DROP NOT NULL;
+ ALTER TABLE servers
+ ADD COLUMN IF NOT EXISTS enabled BOOLEAN NOT NULL DEFAULT TRUE;
+ ALTER TABLE servers ADD COLUMN IF NOT EXISTS max_keys INTEGER;
 
 CREATE TABLE IF NOT EXISTS gifts
 (
-    gift_id        TEXT PRIMARY KEY NOT NULL,      
-    sender_tg_id   BIGINT NOT NULL,            
+    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,  
+    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,
+    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()
+    tg_id       BIGINT PRIMARY KEY,
+    blocked_at  TIMESTAMP DEFAULT NOW()
 );
+
+
+CREATE TABLE IF NOT EXISTS tracking_sources (
+    id            SERIAL PRIMARY KEY,
+    code          TEXT UNIQUE NOT NULL,                
+    type          TEXT NOT NULL,                       
+    name          TEXT NOT NULL,                       
+    created_at    TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    created_by    BIGINT,                              
+    is_active     BOOLEAN DEFAULT TRUE
+);
+
+
+ALTER TABLE users ADD COLUMN IF NOT EXISTS source_code TEXT REFERENCES tracking_sources (code);
+
+
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = 'public' AND table_name = 'connections'
+    ) THEN
+        EXECUTE $upd$
+            UPDATE users
+            SET balance = c.balance,
+                trial = c.trial
+            FROM connections c
+            WHERE users.tg_id = c.tg_id;
+        $upd$;
+
+        EXECUTE 'DROP TABLE connections';
+    END IF;
+END$$;

bot.py

@@ -19,7 +19,7 @@ bot = Bot(token=API_TOKEN, default=DefaultBotProperties(parse_mode=ParseMode.HTM
 storage = MemoryStorage()
 dp = Dispatcher(bot=bot, storage=storage)
 
-version = "4.2-a140499"
+version = "4.2-preRelease260426"
 
 register_middleware(dp)
 

cli_launcher.py

@@ -1,18 +1,21 @@
 import os
-import sys
+import re
 import subprocess
+import sys
+
 import requests
+
 from rich.console import Console
-from rich.prompt import Prompt, Confirm
+from rich.prompt import Confirm, Prompt
 from rich.table import Table
 from rich.text import Text
-import re
 
 from config import BOT_SERVICE
 
+
 try:
-    sys.stdin.reconfigure(encoding='utf-8')
-    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stdin.reconfigure(encoding="utf-8")
+    sys.stdout.reconfigure(encoding="utf-8")
 except Exception:
     pass
 
@@ -20,24 +23,41 @@ if not os.environ.get("LC_ALL", "").endswith("UTF-8"):
     os.environ["LC_ALL"] = "en_US.UTF-8"
     os.environ["LANG"] = "en_US.UTF-8"
 
+console = Console()
+
 BACK_DIR = os.path.expanduser("~/.solobot_backup")
 TEMP_DIR = os.path.expanduser("~/.solobot_tmp")
 PROJECT_DIR = os.path.abspath(os.path.dirname(__file__))
+IS_ROOT_DIR = PROJECT_DIR == '/root'
+
+if IS_ROOT_DIR:
+    console.print("[bold red]⛔ КРИТИЧЕСКАЯ ОШИБКА:[/bold red]")
+    console.print("[red]Обнаружена установка бота прямо в корневой папке (/root).[/red]")
+    console.print("[red]Это крайне опасно и может привести к потере данных![/red]")
+    console.print("[yellow]Рекомендуется перенести бота в отдельную папку, например /root/solobot[/yellow]")
+    console.print("[red]Обновление заблокировано в целях безопасности.[/red]")
+    sys.exit(1)
 GITHUB_REPO = "https://github.com/Vladless/Solo_bot"
 SERVICE_NAME = BOT_SERVICE
 
-console = Console()
+
+def is_service_exists(service_name):
+    result = subprocess.run(["systemctl", "list-unit-files", service_name], capture_output=True, text=True)
+    return service_name in result.stdout
 
 
 def print_logo():
-    logo = Text("""
+    logo = Text(
+        """
 ███████╗ ██████╗ ██╗      ██████╗ ██████╗  ██████╗ ████████╗
 ██╔════╝██╔═══██╗██║     ██╔═══██╗██╔══██╗██╔═══██╗╚══██╔══╝
 ███████╗██║   ██║██║     ██║   ██║██████╔╝██║   ██║   ██║   
 ╚════██║██║   ██║██║     ██║   ██║██╔══██╗██║   ██║   ██║   
 ███████║╚██████╔╝███████╗╚██████╔╝██████╔╝╚██████╔╝   ██║   
 ╚══════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝  ╚═════╝    ╚═╝   
-""", style="bold cyan")
+""",
+        style="bold cyan",
+    )
     console.print(logo)
 
 
@@ -49,12 +69,61 @@ def backup_project():
     console.print(f"[green]✅ Бэкап сохранён в: {BACK_DIR}[/green]")
 
 
+def fix_permissions():
+    """Устанавливает корректные права на файлы проекта"""
+    console.print("[yellow]🔧 Устанавливаю права на файлы...[/yellow]")
+    try:
+        user = os.getenv('SUDO_USER') or os.getenv('USER')
+        if user:
+            subprocess.run(["sudo", "chown", "-R", f"{user}:{user}", PROJECT_DIR], check=True)
+        
+        subprocess.run(["sudo", "chmod", "-R", "u=rwX,go=rX", PROJECT_DIR], check=True)
+        
+        console.print("[green]✅ Права успешно установлены[/green]")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]❌ Ошибка при установке прав: {e}[/red]")
+
+
 def install_rsync_if_needed():
     if subprocess.run(["which", "rsync"], capture_output=True).returncode != 0:
         console.print("[blue]📦 Установка rsync...[/blue]")
         os.system("sudo apt update && sudo apt install -y rsync")
 
 
+def clean_project_dir_safe(update_buttons=False):
+    console.print("[yellow]🧹 Очистка проекта перед обновлением...[/yellow]")
+    preserved_paths = {
+        os.path.join(PROJECT_DIR, "config.py"),
+        os.path.join(PROJECT_DIR, "handlers", "buttons.py"),
+        os.path.join(PROJECT_DIR, "handlers", "texts.py"),
+        os.path.join(PROJECT_DIR, "img"),
+    }
+
+    if not update_buttons:
+        preserved_paths.add(os.path.join(PROJECT_DIR, "handlers", "buttons.py"))
+
+    for root, dirs, files in os.walk(PROJECT_DIR, topdown=False):
+        for file in files:
+            path = os.path.join(root, file)
+            if path in preserved_paths:
+                continue
+            try:
+                os.remove(path)
+            except PermissionError:
+                subprocess.run(["sudo", "rm", "-f", path])
+            except Exception as e:
+                console.print(f"[red]Не удалось удалить файл: {path}: {e}[/red]")
+
+        for dir in dirs:
+            dir_path = os.path.join(root, dir)
+            if os.path.abspath(dir_path) == os.path.join(PROJECT_DIR, "handlers"):
+                continue
+            try:
+                os.rmdir(dir_path)
+            except Exception:
+                subprocess.run(["sudo", "rm", "-rf", dir_path])
+
+
 def install_git_if_needed():
     if subprocess.run(["which", "git"], capture_output=True).returncode != 0:
         console.print("[blue]Установка Git...[/blue]")
@@ -69,22 +138,27 @@ def install_dependencies():
                 console.print("[yellow]⚠️ Виртуальное окружение не найдено. Создаю...[/yellow]")
                 subprocess.run("python3 -m venv venv", shell=True, check=True)
 
-            subprocess.run("bash -c 'source venv/bin/activate && pip install -r requirements.txt'", shell=True, check=True)
+            subprocess.run(
+                "bash -c 'source venv/bin/activate && pip install -r requirements.txt'", shell=True, check=True
+            )
         except subprocess.CalledProcessError:
             console.print("[red]❌ Ошибка при установке зависимостей.[/red]")
 
 
 def restart_service():
-    console.print("[blue]🚀 Перезапуск службы...[/blue]")
-    with console.status("[bold yellow]Перезапуск...[/bold yellow]"):
-        subprocess.run(f"sudo systemctl restart {SERVICE_NAME}", shell=True)
+    if is_service_exists(SERVICE_NAME):
+        console.print("[blue]🚀 Перезапуск службы...[/blue]")
+        with console.status("[bold yellow]Перезапуск...[/bold yellow]"):
+            subprocess.run(f"sudo systemctl restart {SERVICE_NAME}", shell=True)
+    else:
+        console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
 
 
 def get_local_version():
     path = os.path.join(PROJECT_DIR, "bot.py")
     if not os.path.isfile(path):
         return None
-    with open(path, "r", encoding="utf-8") as f:
+    with open(path, encoding="utf-8") as f:
         for line in f:
             match = re.search(r'version\s*=\s*["\'](.+?)["\']', line)
             if match:
@@ -107,6 +181,7 @@ def get_remote_version(branch="main"):
 
 
 def update_from_beta():
+    update_cli_launcher()
     local_version = get_local_version()
     remote_version = get_remote_version(branch="dev")
 
@@ -120,39 +195,58 @@ def update_from_beta():
 
     if not Confirm.ask("[yellow]🔁 Подтвердите обновление Solobot с ветки DEV[/yellow]"):
         return
+        
+    console.print("[red]⚠️ ВНИМАНИЕ! Папка бота будет перезаписана![/red]")
+    if not Confirm.ask("[red]❓ Продолжить обновление?[/red]"):
+        return
+
+    update_buttons = Confirm.ask("[yellow]🔄 Обновлять файл buttons.py?[/yellow]", default=False)
 
     backup_project()
     install_git_if_needed()
     install_rsync_if_needed()
 
     os.chdir(PROJECT_DIR)
-
-    console.print("[cyan]📥 Клонируем репозиторий dev во временную папку...[/cyan]")
+    console.print("[cyan]📅 Клонируем временный репозиторий...[/cyan]")
     subprocess.run(["rm", "-rf", TEMP_DIR])
     if os.system(f"git clone -b dev {GITHUB_REPO} {TEMP_DIR}") != 0:
         console.print("[red]❌ Ошибка при клонировании. Обновление отменено.[/red]")
         return
 
-    subprocess.run(f'rsync -a --exclude=img --exclude=handlers/buttons.py {TEMP_DIR}/ {PROJECT_DIR}/', shell=True)
+    subprocess.run(["sudo", "rm", "-rf", os.path.join(PROJECT_DIR, "venv")])
+    clean_project_dir_safe(update_buttons=update_buttons)
+    
+    exclude_options = "--exclude=img"
+    if not update_buttons:
+        exclude_options += " --exclude=handlers/buttons.py"
+    
+    subprocess.run(f"rsync -a {exclude_options} {TEMP_DIR}/ {PROJECT_DIR}/", shell=True)
     subprocess.run(["rm", "-rf", TEMP_DIR])
 
+    fix_permissions()
     install_dependencies()
     restart_service()
     console.print("[green]✅ Обновление с ветки dev завершено.[/green]")
 
 
 def update_from_release():
+    update_cli_launcher()
     if not Confirm.ask("[yellow]🔁 Подтвердите обновление Solobot до одного из последних релизов[/yellow]"):
         return
 
+    console.print("[red]⚠️ ВНИМАНИЕ! Папка бота будет полностью перезаписана![/red]")
+    console.print("[red]  Исключения: папка img и файл handlers/buttons.py[/red]")
+    if not Confirm.ask("[red]❓ Вы точно хотите продолжить?[/red]"):
+        return
+
+    update_buttons = Confirm.ask("[yellow]🔄 Обновлять файл buttons.py?[/yellow]", default=False)
+
     backup_project()
     install_git_if_needed()
     install_rsync_if_needed()
 
     try:
-        response = requests.get(
-            "https://api.github.com/repos/Vladless/Solo_bot/releases", timeout=10
-        )
+        response = requests.get("https://api.github.com/repos/Vladless/Solo_bot/releases", timeout=10)
         releases = response.json()[:3]
         tag_choices = [r["tag_name"] for r in releases]
 
@@ -164,18 +258,30 @@ def update_from_release():
             console.print(f"[cyan]{idx}.[/cyan] {tag}")
 
         selected = Prompt.ask(
-            "[bold blue]Выберите номер релиза[/bold blue]",
+            "[bold blue]Выберите номер релиза[/bold blue]", 
             choices=[str(i) for i in range(1, len(tag_choices) + 1)]
         )
         tag_name = tag_choices[int(selected) - 1]
 
+        if not Confirm.ask(f"[yellow]🔁 Подтвердите установку релиза {tag_name}[/yellow]"):
+            return
+
         console.print(f"[cyan]📥 Клонируем релиз {tag_name} во временную папку...[/cyan]")
         subprocess.run(["rm", "-rf", TEMP_DIR])
         subprocess.run(f"git clone --depth 1 --branch {tag_name} {GITHUB_REPO} {TEMP_DIR}", shell=True, check=True)
 
-        subprocess.run(f'rsync -a --exclude=img --exclude=handlers/buttons.py {TEMP_DIR}/ {PROJECT_DIR}/', shell=True)
+        console.print("[red]⚠️ Начинается перезапись файлов бота![/red]")
+        subprocess.run(["sudo", "rm", "-rf", os.path.join(PROJECT_DIR, "venv")])
+        clean_project_dir_safe(update_buttons=update_buttons)
+
+        exclude_options = "--exclude=img"
+        if not update_buttons:
+            exclude_options += " --exclude=handlers/buttons.py"
+        
+        subprocess.run(f"rsync -a {exclude_options} {TEMP_DIR}/ {PROJECT_DIR}/", shell=True)
         subprocess.run(["rm", "-rf", TEMP_DIR])
 
+        fix_permissions()
         install_dependencies()
         restart_service()
         console.print(f"[green]✅ Обновление до релиза {tag_name} завершено.[/green]")
@@ -185,6 +291,12 @@ def update_from_release():
 
 
 def show_update_menu():
+
+    if IS_ROOT_DIR:
+        console.print("[red]⛔ Обновление невозможно: бот находится в /root[/red]")
+        console.print("[yellow]Перенесите бота в отдельную папку и повторите попытку[/yellow]")
+        return
+
     table = Table(title="Выберите способ обновления", title_style="bold green")
     table.add_column("№", justify="center", style="cyan", no_wrap=True)
     table.add_column("Источник", style="white")
@@ -202,11 +314,9 @@ def show_update_menu():
 
 
 def show_menu():
-    table = Table(title="Solobot CLI", title_style="bold magenta", header_style="bold blue")
-
+    table = Table(title="Solobot CLI v0.1.7", title_style="bold magenta", header_style="bold blue")
     table.add_column("№", justify="center", style="cyan", no_wrap=True)
     table.add_column("Операция", style="white")
-
     table.add_row("1", "Запустить бота (systemd)")
     table.add_row("2", "Запустить напрямую: venv/bin/python main.py")
     table.add_row("3", "Перезапустить бота (systemd)")
@@ -214,43 +324,75 @@ def show_menu():
     table.add_row("5", "Показать логи (80 строк)")
     table.add_row("6", "Показать статус")
     table.add_row("7", "Обновить Solobot")
-    table.add_row("8", "Выход")
-
+    table.add_row("8", "Обновить CLI лаунчер")
+    table.add_row("9", "Выход")
     console.print(table)
 
 
-def main():
-    if os.geteuid() != 0:
-        console.print("[bold red]⛔ Требуется запуск от имени root или через sudo.[/bold red]")
-        sys.exit(1)
-    
-    os.chdir(PROJECT_DIR) 
-    print_logo()
+def update_cli_launcher():
+    """Обновляет CLI лаунчер с dev ветки"""
+    console.print("[yellow]🔄 Обновление CLI лаунчера...[/yellow]")
+    try:
+        url = "https://raw.githubusercontent.com/Vladless/Solo_bot/dev/cli_launcher.py"
+        response = requests.get(url, timeout=10)
+        
+        if response.status_code == 200:
+            with open(os.path.join(PROJECT_DIR, "cli_launcher.py"), 'w', encoding='utf-8') as f:
+                f.write(response.text)
+            console.print("[green]✅ CLI лаунчер успешно обновлён[/green]")
+            os.chmod(os.path.join(PROJECT_DIR, "cli_launcher.py"), 0o755)
+        else:
+            console.print("[red]❌ Не удалось загрузить новый CLI[/red]")
+    except Exception as e:
+        console.print(f"[red]❌ Ошибка при обновлении CLI: {e}[/red]")
 
+
+def main():
+    os.chdir(PROJECT_DIR)
+    print_logo()
     try:
         while True:
             show_menu()
-            choice = Prompt.ask("[bold blue]Введите номер действия[/bold blue]", choices=[str(i) for i in range(1, 9)])
-
+            choice = Prompt.ask("[bold blue]Введите номер действия[/bold blue]", choices=[str(i) for i in range(1, 10)])
             if choice == "1":
-                os.system(f"sudo systemctl start {SERVICE_NAME}")
+                if is_service_exists(SERVICE_NAME):
+                    subprocess.run(["sudo", "systemctl", "start", SERVICE_NAME])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
             elif choice == "2":
                 if Confirm.ask("[green]Вы действительно хотите запустить main.py вручную?[/green]"):
-                    os.system("sudo venv/bin/python main.py")
+                    subprocess.run(["venv/bin/python", "main.py"])
             elif choice == "3":
-                if Confirm.ask("[yellow]Вы действительно хотите перезапустить бота?[/yellow]"):
-                    os.system(f"sudo systemctl restart {SERVICE_NAME}")
+                if is_service_exists(SERVICE_NAME):
+                    if Confirm.ask("[yellow]Вы действительно хотите перезапустить бота?[/yellow]"):
+                        subprocess.run(["sudo", "systemctl", "restart", SERVICE_NAME])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
             elif choice == "4":
-                if Confirm.ask("[red]Вы уверены, что хотите остановить бота?[/red]"):
-                    os.system(f"sudo systemctl stop {SERVICE_NAME}")
+                if is_service_exists(SERVICE_NAME):
+                    if Confirm.ask("[red]Вы уверены, что хотите остановить бота?[/red]"):
+                        subprocess.run(["sudo", "systemctl", "stop", SERVICE_NAME])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
             elif choice == "5":
-                os.system(f"sudo journalctl -u {SERVICE_NAME} -n 80 --no-pager")
+                if is_service_exists(SERVICE_NAME):
+                    subprocess.run(["sudo", "journalctl", "-u", SERVICE_NAME, "-n", "80", "--no-pager"])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
             elif choice == "6":
-                os.system(f"sudo systemctl status {SERVICE_NAME}")
+                if is_service_exists(SERVICE_NAME):
+                    subprocess.run(["sudo", "systemctl", "status", SERVICE_NAME])
+                else:
+                    console.print(f"[red]❌ Служба {SERVICE_NAME} не найдена.[/red]")
             elif choice == "7":
                 show_update_menu()
             elif choice == "8":
-                console.print("[bold cyan] Выход из CLI. Удачного дня![/bold cyan]")
+                if Confirm.ask("[yellow]Обновить CLI лаунчер с dev ветки?[/yellow]"):
+                    update_cli_launcher()
+            elif choice == "9":
+                if Confirm.ask("[yellow]Хотите обновить CLI перед выходом?[/yellow]"):
+                    update_cli_launcher()
+                console.print("[bold cyan]Выход из CLI. Удачного дня![/bold cyan]")
                 break
     except KeyboardInterrupt:
         console.print("\n[bold red]⏹ Прерывание. Выход из CLI.[/bold red]")

handlers/__init__.py

@@ -12,6 +12,7 @@ from .notifications import router as notifications_router
 from .pay import router as pay_router
 from .payments import router as payments_router
 from .profile import router as profile_router
+from .refferal import router as refferal_router
 from .start import router as start_router
 
 
@@ -29,4 +30,5 @@ router.include_routers(
     keys_router,
     instructions_router,
     admin_router,
+    refferal_router,
 )

handlers/admin/__init__.py

@@ -2,6 +2,7 @@ __all__ = ("router",)
 
 from aiogram import Router
 
+from .ads import router as ads_router
 from .backups import router as backups_router
 from .bans import router as bans_router
 from .clusters import router as clusters_router
@@ -29,4 +30,5 @@ router.include_routers(
     coupons_router,
     restart_router,
     bans_router,
+    ads_router,
 )

handlers/admin/ads/__init__.py

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

handlers/admin/ads/ads_handler.py

@@ -0,0 +1,155 @@
+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 CallbackQuery, Message
+
+from config import USERNAME_BOT
+from database import (
+    create_tracking_source,
+    get_all_tracking_sources,
+    get_tracking_source_stats,
+)
+from filters.admin import IsAdminFilter
+from logger import logger
+
+from ..panel.keyboard import AdminPanelCallback
+from .keyboard import (
+    AdminAdsCallback,
+    build_ads_delete_confirm_kb,
+    build_ads_kb,
+    build_ads_list_kb,
+    build_ads_stats_kb,
+    build_cancel_input_kb,
+)
+
+
+router = Router()
+
+
+class AdminAdsState(StatesGroup):
+    waiting_for_new_name = State()
+    waiting_for_new_code = State()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "ads"), IsAdminFilter())
+async def handle_ads_menu(callback_query: CallbackQuery):
+    await callback_query.message.edit_text(text="📊 <b>Аналитика рекламы:</b>", reply_markup=build_ads_kb())
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "create"), IsAdminFilter())
+async def handle_ads_create(callback_query: CallbackQuery, state: FSMContext):
+    await state.set_state(AdminAdsState.waiting_for_new_name)
+    await callback_query.message.edit_text(
+        "📝 Введите <b>название</b> новой ссылки:", reply_markup=build_cancel_input_kb()
+    )
+
+
+@router.message(AdminAdsState.waiting_for_new_name, IsAdminFilter())
+async def handle_ads_name_input(message: Message, state: FSMContext):
+    name = message.text.strip()
+    await state.update_data(name=name)
+    await state.set_state(AdminAdsState.waiting_for_new_code)
+    await message.answer(
+        f"🔗 Введите <b>код ссылки</b> для: <code>{name}</code>.", reply_markup=build_cancel_input_kb()
+    )
+
+
+@router.message(AdminAdsState.waiting_for_new_code, IsAdminFilter())
+async def handle_ads_code_input(message: Message, state: FSMContext, session):
+    code = message.text.strip()
+    data = await state.get_data()
+    name = data["name"]
+    code_with_prefix = f"utm_{code}"
+
+    try:
+        await create_tracking_source(
+            name=name, code=code_with_prefix, type_="utm", created_by=message.from_user.id, session=session
+        )
+        stats = await get_tracking_source_stats(code_with_prefix, session)
+        if not stats:
+            await message.answer("❌ Источник не найден или не содержит данных.")
+            return
+        msg = format_ads_stats(stats, USERNAME_BOT)
+        await message.answer(
+            text=msg,
+            reply_markup=build_ads_stats_kb(code_with_prefix),
+        )
+
+    except Exception as e:
+        logger.error(f"Ошибка при создании ссылки: {e}")
+        await message.answer("❌ Произошла ошибка при создании ссылки.")
+    finally:
+        await state.clear()
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "list"), IsAdminFilter())
+async def handle_ads_list(callback_query: CallbackQuery, session):
+    try:
+        ads = await get_all_tracking_sources(session)
+        reply_markup = build_ads_list_kb(ads, current_page=1, total_pages=1)
+        await callback_query.message.edit_text(
+            "📋 Выберите ссылку для просмотра статистики:", reply_markup=reply_markup
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при получении списка UTM: {e}")
+        await callback_query.message.edit_text("Произошла ошибка при получении списка.")
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "view"), IsAdminFilter())
+async def handle_ads_view(callback_query: CallbackQuery, callback_data: AdminAdsCallback, session):
+    code = callback_data.code
+    try:
+        stats = await get_tracking_source_stats(code, session)
+        if not stats:
+            await callback_query.message.edit_text("❌ Источник не найден или не содержит данных.")
+            return
+        msg = format_ads_stats(stats, USERNAME_BOT)
+        await callback_query.message.edit_text(
+            text=msg, reply_markup=build_ads_stats_kb(code), parse_mode=ParseMode.HTML
+        )
+    except Exception as e:
+        logger.error(f"Ошибка при просмотре статистики: {e}")
+        await callback_query.message.edit_text("❌ Ошибка при получении статистики.")
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "delete_confirm"), IsAdminFilter())
+async def handle_ads_delete_confirm(callback_query: CallbackQuery, callback_data: AdminAdsCallback):
+    code = callback_data.code
+    await callback_query.message.edit_text(
+        text=f"Вы уверены, что хотите удалить ссылку <code>{code}</code>?",
+        reply_markup=build_ads_delete_confirm_kb(code),
+    )
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "delete"), IsAdminFilter())
+async def handle_ads_delete(callback_query: CallbackQuery, callback_data: AdminAdsCallback, session):
+    code = callback_data.code
+    try:
+        await session.execute("UPDATE users SET source_code = NULL WHERE source_code = $1", code)
+        await session.execute("DELETE FROM tracking_sources WHERE code = $1", code)
+        await callback_query.message.edit_text(f"🗑️ Ссылка <code>{code}</code> удалена.", reply_markup=build_ads_kb())
+    except Exception as e:
+        logger.error(f"Ошибка при удалении метки {code}: {e}", exc_info=True)
+        await callback_query.message.edit_text("❌ Не удалось удалить ссылку.")
+
+
+def format_ads_stats(stats: dict, username_bot: str) -> str:
+    return (
+        f"<b>📊 <u>Статистика по рекламной ссылке</u></b>\n\n"
+        f"📌 <b>Название:</b> {stats['name']}\n"
+        f"🔗 <b>Ссылка:</b> <code>https://t.me/{username_bot}?start={stats['code']}</code>\n"
+        f"🕓 <b>Создана:</b> {stats['created_at'].strftime('%d.%m.%Y %H:%M')}\n\n"
+        f"💡 <b>Активность:</b>\n"
+        f"└ 🆕 <b>Регистраций:</b> <b>{stats.get('registrations', 0)}</b>\n"
+        f"└ 🧪 <b>Триалов:</b> <b>{stats.get('trials', 0)}</b>\n"
+        f"\n💰 <b>Финансовая информация:</b>\n"
+        f"└ 💳 <b>Покупок:</b> <b>{stats.get('payments', 0)}</b>\n\n"
+        f"<i>Просмотр статистики и управление рекламными ссылками</i>."
+    )
+
+
+@router.callback_query(AdminAdsCallback.filter(F.action == "cancel_input"), IsAdminFilter())
+async def handle_ads_cancel_input(callback_query: CallbackQuery, state: FSMContext):
+    await state.clear()
+    await callback_query.message.edit_text(text="📊 <b>Аналитика рекламы:</b>", reply_markup=build_ads_kb())

handlers/admin/ads/keyboard.py

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

handlers/admin/clusters/clusters_handler.py

@@ -10,14 +10,27 @@ from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
 from aiogram.types import CallbackQuery, Message
 from py3xui import AsyncApi
-from datetime import datetime, timedelta
 
 from backup import create_backup_and_send_to_admins
-from config import ADMIN_PASSWORD, ADMIN_USERNAME, DATABASE_URL, TOTAL_GB, USE_COUNTRY_SELECTION, REMNAWAVE_PASSWORD, REMNAWAVE_LOGIN
+from config import (
+    ADMIN_PASSWORD,
+    ADMIN_USERNAME,
+    DATABASE_URL,
+    REMNAWAVE_LOGIN,
+    REMNAWAVE_PASSWORD,
+    TOTAL_GB,
+    USE_COUNTRY_SELECTION,
+)
 from database import check_unique_server_name, get_servers, update_key_expiry
 from filters.admin import IsAdminFilter
-from handlers.keys.key_utils import create_client_on_server, create_key_on_cluster, renew_key_in_cluster, delete_key_from_cluster
+from handlers.keys.key_utils import (
+    create_client_on_server,
+    create_key_on_cluster,
+    delete_key_from_cluster,
+    renew_key_in_cluster,
+)
 from logger import logger
+from panels.remnawave import RemnawaveAPI
 
 from ..panel.keyboard import AdminPanelCallback, build_admin_back_kb
 from .keyboard import (
@@ -26,10 +39,9 @@ from .keyboard import (
     build_cluster_management_kb,
     build_clusters_editor_kb,
     build_manage_cluster_kb,
+    build_panel_type_kb,
     build_sync_cluster_kb,
-    build_panel_type_kb
 )
-from panels.remnawave import RemnawaveAPI
 
 
 router = Router()
@@ -57,9 +69,10 @@ async def handle_servers(callback_query: CallbackQuery):
 
     text = (
         "<b>🔧 Управление кластерами</b>\n\n"
-        "<i>📌 Здесь вы можете добавить новый кластер.</i>\n\n"
-        "<i>🌐 <b>Кластеры</b> — это пространство серверов, в пределах которого создается подписка.</i>\n"
-        "💡 Если вы хотите выдавать по 1 серверу, то добавьте всего 1 сервер в кластер.\n\n"
+        "<blockquote>"
+        "🌐 <b>Кластеры</b> — это пространство серверов, в пределах которого создается подписка.\n"
+        "💡 Если вы хотите выдавать по 1 серверу, то добавьте всего 1 сервер в кластер."
+        "</blockquote>\n\n"
         "<i>⚠️ <b>Важно:</b> Кластеры удаляются автоматически, если удалить все серверы внутри них.</i>\n\n"
     )
 
@@ -194,7 +207,7 @@ async def handle_subscription_url_input(message: Message, state: FSMContext):
 
     await message.answer(
         text=f"<b>Введите inbound_id для сервера {server_name} в кластере {cluster_name}:</b>\n\n"
-             f"Для Remnawave это UUID Инбаунда, для 3x-ui — просто ID (например, <code>1</code>).",
+        f"Для Remnawave это UUID Инбаунда, для 3x-ui — просто ID (например, <code>1</code>).",
         reply_markup=build_admin_back_kb("clusters"),
     )
     await state.set_state(AdminClusterStates.waiting_for_inbound_id)
@@ -216,7 +229,9 @@ async def handle_inbound_id_input(message: Message, state: FSMContext):
 
 
 @router.callback_query(AdminClusterCallback.filter(F.action.in_(["panel_3xui", "panel_remnawave"])), IsAdminFilter())
-async def handle_panel_type_selection(callback_query: CallbackQuery, callback_data: AdminClusterCallback, state: FSMContext):
+async def handle_panel_type_selection(
+    callback_query: CallbackQuery, callback_data: AdminClusterCallback, state: FSMContext
+):
     panel_type = "3x-ui" if callback_data.action == "panel_3xui" else "remnawave"
 
     user_data = await state.get_data()
@@ -254,11 +269,20 @@ async def handle_clusters_manage(
 ):
     cluster_name = callback_data.data
 
-    servers = await get_servers(session)
-    cluster_servers = servers.get(cluster_name, [])
-
     await callback_query.message.edit_text(
         text=f"<b>🔧 Управление кластером {cluster_name}</b>",
+        reply_markup=build_cluster_management_kb(cluster_name),
+    )
+
+
+@router.callback_query(F.data.startswith("cluster_servers|"), IsAdminFilter())
+async def handle_cluster_servers(callback: CallbackQuery):
+    cluster_name = callback.data.split("|", 1)[1]
+    servers = await get_servers()
+    cluster_servers = servers.get(cluster_name, [])
+
+    await callback.message.edit_text(
+        text=f"<b>📡 Серверы в кластере {cluster_name}</b>",
         reply_markup=build_manage_cluster_kb(cluster_servers, cluster_name),
     )
 
@@ -285,11 +309,6 @@ async def handle_cluster_availability(
     total_online_users = 0
     result_text = f"<b>🖥️ Проверка доступности серверов</b>\n\n⚙️ Кластер: <b>{cluster_name}</b>\n\n"
 
-    now = datetime.utcnow()
-    start_time = now - timedelta(minutes=5)
-    start_iso = start_time.strftime("%Y-%m-%dT%H:%M:%SZ")
-    end_iso = now.strftime("%Y-%m-%dT%H:%M:%SZ")
-
     for server in cluster_servers:
         server_name = server["server_name"]
         panel_type = server.get("panel_type", "3x-ui").lower()
@@ -316,12 +335,25 @@ async def handle_cluster_availability(
                 if not await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
                     raise Exception("Не удалось авторизоваться")
 
-                node_uuid = server.get("inbound_id")
-                if not node_uuid:
-                    raise Exception("Не указан UUID ноды (inbound_id)")
+                server_inbound_id = server.get("inbound_id")
+                if not server_inbound_id:
+                    raise Exception("Не указан inbound_id сервера")
 
-                data = await remna.get_node_users_usage(node_uuid, start=start_iso, end=end_iso)
-                online_remna_users = len(data) if data else 0
+                all_nodes = await remna.get_all_nodes()
+                if not all_nodes:
+                    raise Exception("Не удалось получить список нод")
+
+                matching_node = None
+                for node in all_nodes:
+                    excluded_inbounds = node.get("excludedInbounds", [])
+                    if server_inbound_id not in excluded_inbounds:
+                        matching_node = node
+                        break
+
+                if not matching_node:
+                    raise Exception("Нода, обслуживающая этот inbound_id, не найдена")
+
+                online_remna_users = matching_node.get("usersOnline", 0)
                 total_online_users += online_remna_users
                 result_text += f"🌍 <b>{prefix} {server_name}</b> - {online_remna_users} онлайн\n"
 
@@ -437,7 +469,7 @@ async def handle_sync_cluster(callback_query: types.CallbackQuery, callback_data
 
     try:
         query_keys = """
-            SELECT tg_id, client_id, email, expiry_time
+            SELECT tg_id, client_id, email, expiry_time, remnawave_link
             FROM keys
             WHERE server_id = $1
         """
@@ -458,18 +490,17 @@ async def handle_sync_cluster(callback_query: types.CallbackQuery, callback_data
                 await delete_key_from_cluster(cluster_name, key["email"], key["client_id"])
 
                 await session.execute(
-                    "DELETE FROM keys WHERE tg_id = $1 AND client_id = $2",
-                    key["tg_id"],
-                    key["client_id"]
+                    "DELETE FROM keys WHERE tg_id = $1 AND client_id = $2", key["tg_id"], key["client_id"]
                 )
 
-                result = await create_key_on_cluster(
+                await create_key_on_cluster(
                     cluster_name,
                     key["tg_id"],
                     key["client_id"],
                     key["email"],
                     key["expiry_time"],
                     session=session,
+                    remnawave_link=key.get("remnawave_link"),
                 )
 
                 await asyncio.sleep(0.5)
@@ -477,7 +508,6 @@ async def handle_sync_cluster(callback_query: types.CallbackQuery, callback_data
             except Exception as e:
                 logger.error(f"Ошибка при синхронизации ключа {key['client_id']} в {cluster_name}: {e}")
 
-
         await callback_query.message.edit_text(
             text=f"✅ Ключи успешно синхронизированы для кластера {cluster_name}",
             reply_markup=build_admin_back_kb("clusters"),
@@ -511,16 +541,6 @@ async def handle_add_server(callback_query: CallbackQuery, callback_data: AdminS
     await state.set_state(AdminClusterStates.waiting_for_server_name)
 
 
-@router.callback_query(AdminClusterCallback.filter(F.action == "manage_cluster"), IsAdminFilter())
-async def handle_manage_cluster_menu(callback_query: CallbackQuery, callback_data: AdminClusterCallback):
-    cluster_name = callback_data.data
-
-    await callback_query.message.edit_text(
-        text=f"<b>🛠 Управление кластером {cluster_name}</b>\nВыберите действие:",
-        reply_markup=build_cluster_management_kb(cluster_name),
-    )
-
-
 @router.callback_query(AdminClusterCallback.filter(F.action == "add_time"), IsAdminFilter())
 async def handle_add_time(callback_query: CallbackQuery, callback_data: AdminClusterCallback, state: FSMContext):
     cluster_name = callback_data.data
@@ -545,6 +565,7 @@ async def handle_days_input(message: Message, state: FSMContext, session: Any):
 
         now = int(time.time() * 1000)
         add_ms = days * 86400 * 1000
+        total_gb = int((days / 30) * TOTAL_GB * 1024**3)
 
         keys = await session.fetch(
             "SELECT tg_id, client_id, email, expiry_time FROM keys WHERE server_id = $1",
@@ -563,7 +584,7 @@ async def handle_days_input(message: Message, state: FSMContext, session: Any):
                 email=key["email"],
                 client_id=key["client_id"],
                 new_expiry_time=new_expiry,
-                total_gb=TOTAL_GB,
+                total_gb=total_gb,
             )
             await update_key_expiry(key["client_id"], new_expiry, session)
 
@@ -622,8 +643,7 @@ async def handle_new_cluster_name_input(message: Message, state: FSMContext, ses
     conn = await asyncpg.connect(DATABASE_URL)
     try:
         existing_cluster = await conn.fetchval(
-            "SELECT cluster_name FROM servers WHERE cluster_name = $1 LIMIT 1",
-            new_cluster_name
+            "SELECT cluster_name FROM servers WHERE cluster_name = $1 LIMIT 1", new_cluster_name
         )
         if existing_cluster:
             await message.answer(
@@ -632,23 +652,16 @@ async def handle_new_cluster_name_input(message: Message, state: FSMContext, ses
             )
             return
 
-        keys_count = await conn.fetchval(
-            "SELECT COUNT(*) FROM keys WHERE server_id = $1",
-            old_cluster_name
-        )
+        keys_count = await conn.fetchval("SELECT COUNT(*) FROM keys WHERE server_id = $1", old_cluster_name)
 
         async with conn.transaction():
             await conn.execute(
-                "UPDATE servers SET cluster_name = $1 WHERE cluster_name = $2",
-                new_cluster_name,
-                old_cluster_name
+                "UPDATE servers SET cluster_name = $1 WHERE cluster_name = $2", new_cluster_name, old_cluster_name
             )
 
             if keys_count > 0:
                 await conn.execute(
-                    "UPDATE keys SET server_id = $1 WHERE server_id = $2",
-                    new_cluster_name,
-                    old_cluster_name
+                    "UPDATE keys SET server_id = $1 WHERE server_id = $2", new_cluster_name, old_cluster_name
                 )
 
         await message.answer(
@@ -729,7 +742,7 @@ async def handle_new_server_name_input(message: Message, state: FSMContext, sess
         existing_server = await conn.fetchval(
             "SELECT server_name FROM servers WHERE cluster_name = $1 AND server_name = $2 LIMIT 1",
             cluster_name,
-            new_server_name
+            new_server_name,
         )
         if existing_server:
             await message.answer(
@@ -738,24 +751,19 @@ async def handle_new_server_name_input(message: Message, state: FSMContext, sess
             )
             return
 
-        keys_count = await conn.fetchval(
-            "SELECT COUNT(*) FROM keys WHERE server_id = $1",
-            old_server_name
-        )
+        keys_count = await conn.fetchval("SELECT COUNT(*) FROM keys WHERE server_id = $1", old_server_name)
 
         async with conn.transaction():
             await conn.execute(
                 "UPDATE servers SET server_name = $1 WHERE cluster_name = $2 AND server_name = $3",
                 new_server_name,
                 cluster_name,
-                old_server_name
+                old_server_name,
             )
 
             if keys_count > 0:
                 await conn.execute(
-                    "UPDATE keys SET server_id = $1 WHERE server_id = $2",
-                    new_server_name,
-                    old_server_name
+                    "UPDATE keys SET server_id = $1 WHERE server_id = $2", new_server_name, old_server_name
                 )
 
         final_text = f"✅ Название сервера успешно изменено с '{old_server_name}' на '{new_server_name}' в кластере '{cluster_name}'!"
@@ -787,20 +795,14 @@ async def handle_server_transfer(callback_query: CallbackQuery, state: FSMContex
     conn = await asyncpg.connect(DATABASE_URL)
     try:
         async with conn.transaction():
-            await conn.execute(
-                "UPDATE keys SET server_id = $1 WHERE server_id = $2",
-                new_server_name,
-                old_server_name
-            )
+            await conn.execute("UPDATE keys SET server_id = $1 WHERE server_id = $2", new_server_name, old_server_name)
 
             await conn.execute(
-                "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2",
-                cluster_name,
-                old_server_name
+                "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2", cluster_name, old_server_name
             )
 
         base_text = f"✅ Ключи успешно перенесены на сервер '{new_server_name}', сервер '{old_server_name}' удален!"
-        sync_reminder = "\n\n⚠️ Не забудьте сделать \"Синхронизацию\"."
+        sync_reminder = '\n\n⚠️ Не забудьте сделать "Синхронизацию".'
         final_text = base_text + (sync_reminder if USE_COUNTRY_SELECTION else "")
 
         await callback_query.message.edit_text(
@@ -831,21 +833,13 @@ async def handle_cluster_transfer(callback_query: CallbackQuery, state: FSMConte
     conn = await asyncpg.connect(DATABASE_URL)
     try:
         async with conn.transaction():
+            await conn.execute("UPDATE keys SET server_id = $1 WHERE server_id = $2", new_cluster_name, old_server_name)
             await conn.execute(
-                "UPDATE keys SET server_id = $1 WHERE server_id = $2",
-                new_cluster_name,
-                old_server_name
-            )
-            await conn.execute(
-                "UPDATE keys SET server_id = $1 WHERE server_id = $2",
-                new_cluster_name,
-                old_cluster_name
+                "UPDATE keys SET server_id = $1 WHERE server_id = $2", new_cluster_name, old_cluster_name
             )
 
             await conn.execute(
-                "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2",
-                cluster_name,
-                old_server_name
+                "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2", cluster_name, old_server_name
             )
 
         await callback_query.message.edit_text(

handlers/admin/clusters/keyboard.py

@@ -1,12 +1,10 @@
-from typing import Optional
-
 from aiogram.filters.callback_data import CallbackData
 from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from handlers.buttons import BACK
 
-from ..panel.keyboard import build_admin_back_btn
+from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
 from ..servers.keyboard import AdminServerCallback
 
 
@@ -55,13 +53,6 @@ def build_manage_cluster_kb(cluster_servers: list, cluster_name: str) -> InlineK
         )
     )
 
-    builder.row(
-        InlineKeyboardButton(
-            text="🛠 Управление",
-            callback_data=AdminClusterCallback(action="manage_cluster", data=cluster_name).pack(),
-        )
-    )
-
     builder.row(build_admin_back_btn("clusters"))
     return builder.as_markup()
 
@@ -69,6 +60,12 @@ def build_manage_cluster_kb(cluster_servers: list, cluster_name: str) -> InlineK
 def build_cluster_management_kb(cluster_name: str) -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
 
+    builder.row(
+        InlineKeyboardButton(
+            text="📡 Серверы",
+            callback_data=f"cluster_servers|{cluster_name}",
+        )
+    )
     builder.row(
         InlineKeyboardButton(
             text="🌐 Доступность",
@@ -99,12 +96,7 @@ def build_cluster_management_kb(cluster_name: str) -> InlineKeyboardMarkup:
             callback_data=AdminClusterCallback(action="rename", data=cluster_name).pack(),
         )
     )
-    builder.row(
-        InlineKeyboardButton(
-            text="🔙 Назад",
-            callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack(),
-        )
-    )
+    builder.row(InlineKeyboardButton(text="🔙 Назад", callback_data=AdminPanelCallback(action="clusters").pack()))
 
     return builder.as_markup()
 
@@ -134,13 +126,7 @@ def build_sync_cluster_kb(cluster_servers: list, cluster_name: str) -> InlineKey
 
 def build_panel_type_kb() -> InlineKeyboardMarkup:
     builder = InlineKeyboardBuilder()
-    builder.button(
-        text="🌐 3X-UI",
-        callback_data=AdminClusterCallback(action="panel_3xui").pack()
-    )
-    builder.button(
-        text="🌀 Remnawave",
-        callback_data=AdminClusterCallback(action="panel_remnawave").pack()
-    )
+    builder.button(text="🌐 3X-UI", callback_data=AdminClusterCallback(action="panel_3xui").pack())
+    builder.button(text="🌀 Remnawave", callback_data=AdminClusterCallback(action="panel_remnawave").pack())
     builder.row(build_admin_back_btn("clusters"))
     return builder.as_markup()

handlers/admin/coupons/coupons_handler.py

@@ -1,8 +1,10 @@
-from datetime import datetime
 import html
-import pytz
+
+from datetime import datetime
 from typing import Any
 
+import pytz
+
 from aiogram import F, Router
 from aiogram.enums import ParseMode
 from aiogram.fsm.context import FSMContext
@@ -217,18 +219,15 @@ async def handle_coupon_delete(callback_query: CallbackQuery, callback_data: Adm
     coupon_code = callback_data.coupon_code
     kb = InlineKeyboardBuilder()
     kb.button(
-        text="✅ Да, удалить",
-        callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=True).pack()
+        text="✅ Да, удалить", callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=True).pack()
     )
     kb.button(
-        text="❌ Нет, отменить",
-        callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=False).pack()
+        text="❌ Нет, отменить", callback_data=AdminCouponDeleteCallback(coupon_code=coupon_code, confirm=False).pack()
     )
     kb.adjust(1)
 
     await callback_query.message.edit_text(
-        f"Вы уверены, что хотите удалить купон <b>{coupon_code}</b>?",
-        reply_markup=kb.as_markup()
+        f"Вы уверены, что хотите удалить купон <b>{coupon_code}</b>?", reply_markup=kb.as_markup()
     )
 
 
@@ -242,15 +241,13 @@ async def confirm_coupon_delete(callback_query: CallbackQuery, callback_data: Ad
             result = await delete_coupon(coupon_code, session)
             if not result:
                 await callback_query.message.edit_text(
-                    f"❌ Купон с кодом {coupon_code} не найден.",
-                    reply_markup=build_admin_back_kb("coupons")
+                    f"❌ Купон с кодом {coupon_code} не найден.", reply_markup=build_admin_back_kb("coupons")
                 )
                 return
         except Exception as e:
             logger.error(f"Ошибка при удалении купона: {e}")
             await callback_query.message.edit_text(
-                "Произошла ошибка при удалении купона.",
-                reply_markup=build_admin_back_kb("coupons")
+                "Произошла ошибка при удалении купона.", reply_markup=build_admin_back_kb("coupons")
             )
             return
 
@@ -295,7 +292,11 @@ async def inline_coupon_handler(inline_query: InlineQuery, session: Any):
         return
 
     title = f"Купон {coupon['code']}"
-    description = f"Получи {coupon['amount']} рублей!" if coupon["amount"] > 0 else f"Продли подписку на {format_days(coupon['days'])}!"
+    description = (
+        f"Получи {coupon['amount']} рублей!"
+        if coupon["amount"] > 0
+        else f"Продли подписку на {format_days(coupon['days'])}!"
+    )
     message_text = (
         f"🎫 <b>Купон:</b> {coupon['code']}\n"
         f"{'💰 <b>Бонус:</b> ' + str(coupon['amount']) + ' рублей' if coupon['amount'] > 0 else '⏳ <b>Продление:</b> ' + format_days(coupon['days'])}\n"
@@ -309,15 +310,8 @@ async def inline_coupon_handler(inline_query: InlineQuery, session: Any):
         id=coupon_code,
         title=title,
         description=description,
-        input_message_content=InputTextMessageContent(
-            message_text=message_text,
-            parse_mode=ParseMode.HTML
-        ),
+        input_message_content=InputTextMessageContent(message_text=message_text, parse_mode=ParseMode.HTML),
         reply_markup=builder.as_markup(),
     )
 
-    await inline_query.answer(
-        results=[result],
-        cache_time=86400,
-        is_personal=True
-    )
+    await inline_query.answer(results=[result], cache_time=86400, is_personal=True)

handlers/admin/coupons/keyboard.py

@@ -12,7 +12,7 @@ from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
 
 class AdminCouponDeleteCallback(CallbackData, prefix="admin_coupon_delete"):
     coupon_code: str
-    confirm: Optional[bool] = None
+    confirm: bool | None = None
 
 
 def build_coupons_kb() -> InlineKeyboardMarkup:
@@ -59,7 +59,11 @@ def build_coupons_list_kb(coupons: list, current_page: int, total_pages: int) ->
 def format_coupons_list(coupons: list, username_bot: str) -> str:
     coupon_list = "📜 Список всех купонов:\n\n"
     for coupon in coupons:
-        value_text = f"💰 <b>Сумма:</b> {coupon['amount']} рублей" if coupon["amount"] > 0 else f"⏳ <b>{format_days(coupon['days'])}</b>"
+        value_text = (
+            f"💰 <b>Сумма:</b> {coupon['amount']} рублей"
+            if coupon["amount"] > 0
+            else f"⏳ <b>{format_days(coupon['days'])}</b>"
+        )
         coupon_list += (
             f"🏷️ <b>Код:</b> {coupon['code']}\n"
             f"{value_text}\n"

handlers/admin/management/keyboard.py

@@ -1,6 +1,8 @@
 from aiogram.types import InlineKeyboardMarkup
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
+from middlewares import maintenance
+
 from ..panel.keyboard import AdminPanelCallback, build_admin_back_btn
 
 
@@ -11,6 +13,9 @@ def build_management_kb() -> InlineKeyboardMarkup:
     builder.button(text="🔄 Перезагрузить бота", callback_data=AdminPanelCallback(action="restart").pack())
     builder.button(text="🌐 Сменить домен", callback_data=AdminPanelCallback(action="change_domain").pack())
     builder.button(text="🔑 Восстановить пробники", callback_data=AdminPanelCallback(action="restore_trials").pack())
+    maintenance_text = "🛠️ Выключить тех. работы" if maintenance.maintenance_mode else "🛠️ Включить тех. работы"
+    builder.button(text=maintenance_text, callback_data=AdminPanelCallback(action="toggle_maintenance").pack())
+
     builder.row(build_admin_back_btn())
     builder.adjust(1)
     return builder.as_markup()

handlers/admin/management/management_handler.py

@@ -9,6 +9,7 @@ from logger import logger
 
 from ..panel.keyboard import build_admin_back_kb
 from .keyboard import AdminPanelCallback, build_management_kb
+from middlewares import maintenance
 
 
 router = Router()
@@ -73,3 +74,14 @@ async def process_new_domain(message: Message, state: FSMContext, session: Conne
 
     await message.answer(f"✅ Домен успешно изменен на {new_domain}!", reply_markup=build_admin_back_kb("admin"))
     await state.clear()
+
+
+@router.callback_query(AdminPanelCallback.filter(F.action == "toggle_maintenance"))
+async def toggle_maintenance_mode(callback: CallbackQuery):
+
+    maintenance.maintenance_mode = not maintenance.maintenance_mode
+
+    new_status = "включён" if maintenance.maintenance_mode else "выключен"
+    await callback.answer(f"🛠️ Режим обслуживания {new_status}.", show_alert=True)
+    
+    await callback.message.edit_reply_markup(reply_markup=build_management_kb())

handlers/admin/panel/keyboard.py

@@ -23,15 +23,18 @@ def build_panel_kb() -> InlineKeyboardMarkup:
     builder.button(text="🔑 Поиск по названию ключа", callback_data=AdminPanelCallback(action="search_key").pack())
     builder.row(
         InlineKeyboardButton(text="🖥️ Серверы", callback_data=AdminPanelCallback(action="clusters").pack()),
-        InlineKeyboardButton(text="🎟️ Купоны", callback_data=AdminPanelCallback(action="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.row(
+        InlineKeyboardButton(text="📢 Рассылка", callback_data=AdminPanelCallback(action="sender").pack()),
+        InlineKeyboardButton(text="🎟️ Купоны", callback_data=AdminPanelCallback(action="coupons").pack()),
+    )
+    builder.row(
+        InlineKeyboardButton(text="📊 Статистика", callback_data=AdminPanelCallback(action="stats").pack()),
+        InlineKeyboardButton(text="📈 Аналитика", callback_data=AdminPanelCallback(action="ads").pack()),
+    )
     builder.button(text=MAIN_MENU, callback_data="profile")
-    builder.adjust(1, 1, 2, 1, 2, 1)
+    builder.adjust(1, 1, 2, 2, 2, 1)
     return builder.as_markup()
 
 

handlers/admin/panel/panel_handler.py

@@ -1,16 +1,15 @@
 from aiogram import F, Router
+from aiogram.exceptions import TelegramBadRequest
 from aiogram.filters import Command
 from aiogram.fsm.context import FSMContext
 from aiogram.types import CallbackQuery, Message
-from aiogram.exceptions import TelegramBadRequest
 
 from bot import version
 from filters.admin import IsAdminFilter
+from logger import logger
 
 from .keyboard import AdminPanelCallback, build_panel_kb
 
-from logger import logger
-
 
 router = Router()
 

handlers/admin/sender/keyboard.py

@@ -23,6 +23,7 @@ def build_sender_kb() -> InlineKeyboardMarkup:
             text="📍 Не использовавшие триал", callback_data=AdminSenderCallback(type="untrial").pack()
         )
     )
+    builder.row(InlineKeyboardButton(text="🔥 Горячие лиды", callback_data=AdminSenderCallback(type="hotleads").pack()))
     builder.row(
         InlineKeyboardButton(text="📢 Кластер", callback_data=AdminSenderCallback(type="cluster-select").pack())
     )

handlers/admin/sender/sender_handler.py

@@ -77,43 +77,56 @@ async def handle_message_input(message: Message, state: FSMContext, session: Any
     state_data = await state.get_data()
     send_to = state_data.get("type", "all")
 
+    now = int(datetime.utcnow().timestamp() * 1000)
+
     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
+            SELECT DISTINCT u.tg_id
+            FROM users u
+            JOIN keys k ON u.tg_id = k.tg_id
             WHERE k.expiry_time > $1
             """,
-            int(datetime.utcnow().timestamp() * 1000),
+            now,
         )
     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
+            SELECT u.tg_id
+            FROM users u
+            LEFT JOIN keys k ON u.tg_id = k.tg_id
+            GROUP BY u.tg_id
             HAVING COUNT(k.tg_id) = 0 OR MAX(k.expiry_time) <= $1
             """,
-            int(datetime.utcnow().timestamp() * 1000),
+            now,
         )
     elif send_to == "untrial":
-        tg_ids = await session.fetch("SELECT DISTINCT tg_id FROM connections WHERE trial = 0")
+        tg_ids = await session.fetch("SELECT DISTINCT tg_id FROM users WHERE tg_id NOT IN (SELECT tg_id FROM keys)")
     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
+            SELECT DISTINCT u.tg_id
+            FROM users u
+            JOIN keys k ON u.tg_id = k.tg_id
             JOIN servers s ON k.server_id = s.cluster_name
             WHERE s.cluster_name = $1
             """,
             cluster_name,
         )
+    elif send_to == "hotleads":
+        tg_ids = await session.fetch(
+            """
+            SELECT DISTINCT u.tg_id
+            FROM users u
+            JOIN payments p ON u.tg_id = p.tg_id
+            LEFT JOIN keys k ON u.tg_id = k.tg_id
+            WHERE p.status = 'success'
+            AND k.tg_id IS NULL
+            """
+        )
     else:
-        tg_ids = await session.fetch("SELECT DISTINCT tg_id FROM connections")
+        tg_ids = await session.fetch("SELECT DISTINCT tg_id FROM users")
 
     total_users = len(tg_ids)
     success_count = 0

handlers/admin/servers/keyboard.py

@@ -10,12 +10,27 @@ class AdminServerCallback(CallbackData, prefix="admin_server"):
     data: str
 
 
-def build_manage_server_kb(server_name: str, cluster_name: str) -> InlineKeyboardMarkup:
+def build_manage_server_kb(server_name: str, cluster_name: str, enabled: bool) -> InlineKeyboardMarkup:
     from ..clusters.keyboard import AdminClusterCallback
 
     builder = InlineKeyboardBuilder()
+
+    toggle_text = "🔴 Отключить" if enabled else "🟢 Включить"
+    toggle_action = "disable" if enabled else "enable"
+
+    builder.button(text=toggle_text, callback_data=AdminServerCallback(action=toggle_action, data=server_name).pack())
+
+    builder.button(
+        text="📈 Задать лимит", callback_data=AdminServerCallback(action="set_limit", data=server_name).pack()
+    )
+
     builder.button(text="🗑️ Удалить", callback_data=AdminServerCallback(action="delete", data=server_name).pack())
-    builder.button(text="✏️ Сменить название", callback_data=AdminServerCallback(action="rename", data=server_name).pack())
+
+    builder.button(
+        text="✏️ Сменить название", callback_data=AdminServerCallback(action="rename", data=server_name).pack()
+    )
+
     builder.button(text=BACK, callback_data=AdminClusterCallback(action="manage", data=cluster_name).pack())
+
     builder.adjust(1)
     return builder.as_markup()

handlers/admin/servers/servers_handler.py

@@ -2,12 +2,13 @@ from typing import Any
 
 from aiogram import F, Router, types
 from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
 from aiogram.types import CallbackQuery, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
-from handlers.buttons import BACK
 
-from database import delete_server, get_servers
+from database import get_servers
 from filters.admin import IsAdminFilter
+from handlers.buttons import BACK
 
 from ..panel.keyboard import build_admin_back_kb
 from .keyboard import (
@@ -19,10 +20,14 @@ from .keyboard import (
 router = Router()
 
 
+class ServerLimitState(StatesGroup):
+    waiting_for_limit = State()
+
+
 @router.callback_query(AdminServerCallback.filter(F.action == "manage"), IsAdminFilter())
 async def handle_server_manage(callback_query: CallbackQuery, callback_data: AdminServerCallback):
     server_name = callback_data.data
-    servers = await get_servers()
+    servers = await get_servers(include_enabled=True)
 
     cluster_name, server = next(
         ((c, s) for c, cs in servers.items() for s in cs if s["server_name"] == server_name), (None, None)
@@ -32,17 +37,20 @@ async def handle_server_manage(callback_query: CallbackQuery, callback_data: Adm
         api_url = server["api_url"]
         subscription_url = server["subscription_url"]
         inbound_id = server["inbound_id"]
+        max_keys = server.get("max_keys")
+        limit_display = f"{max_keys}" if max_keys else "не задан"
 
         text = (
             f"<b>🔧 Информация о сервере {server_name}:</b>\n\n"
             f"<b>📡 API URL:</b> {api_url}\n"
             f"<b>🌐 Subscription URL:</b> {subscription_url}\n"
-            f"<b>🔑 Inbound ID:</b> {inbound_id}"
+            f"<b>🔑 Inbound ID:</b> {inbound_id}\n"
+            f"<b>📈 Лимит ключей:</b> {limit_display}"
         )
 
         await callback_query.message.edit_text(
             text=text,
-            reply_markup=build_manage_server_kb(server_name, cluster_name),
+            reply_markup=build_manage_server_kb(server_name, cluster_name, enabled=server.get("enabled", True)),
         )
     else:
         await callback_query.message.edit_text(text="❌ Сервер не найден.")
@@ -73,10 +81,7 @@ async def process_callback_delete_server(
         )
         return
 
-    keys_count = await session.fetchval(
-        "SELECT COUNT(*) FROM keys WHERE server_id = $1",
-        server_name
-    )
+    keys_count = await session.fetchval("SELECT COUNT(*) FROM keys WHERE server_id = $1", server_name)
 
     if keys_count > 0:
         await state.update_data(server_name=server_name, cluster_name=cluster_name)
@@ -87,7 +92,7 @@ async def process_callback_delete_server(
             FROM servers
             WHERE server_name != $1
             """,
-            server_name
+            server_name,
         )
 
         if all_servers:
@@ -96,13 +101,12 @@ async def process_callback_delete_server(
                 builder.row(
                     InlineKeyboardButton(
                         text=f"{server['server_name']} ({server['key_count']})",
-                        callback_data=f"transfer_to_server|{server['server_name']}|{server_name}"
+                        callback_data=f"transfer_to_server|{server['server_name']}|{server_name}",
                     )
                 )
             builder.row(
                 InlineKeyboardButton(
-                    text=BACK,
-                    callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+                    text=BACK, callback_data=AdminServerCallback(action="manage", data=server_name).pack()
                 )
             )
 
@@ -114,22 +118,16 @@ async def process_callback_delete_server(
             return
 
     remaining_servers = await session.fetchval(
-        "SELECT COUNT(*) FROM servers WHERE cluster_name = $1 AND server_name != $2",
-        cluster_name,
-        server_name
+        "SELECT COUNT(*) FROM servers WHERE cluster_name = $1 AND server_name != $2", cluster_name, server_name
     )
 
     if remaining_servers == 0:
         other_clusters = await session.fetch(
-            "SELECT DISTINCT cluster_name FROM servers WHERE cluster_name != $1",
-            cluster_name
+            "SELECT DISTINCT cluster_name FROM servers WHERE cluster_name != $1", cluster_name
         )
 
         if other_clusters:
-            cluster_keys_count = await session.fetchval(
-                "SELECT COUNT(*) FROM keys WHERE server_id = $1",
-                cluster_name
-            )
+            cluster_keys_count = await session.fetchval("SELECT COUNT(*) FROM keys WHERE server_id = $1", cluster_name)
 
             if cluster_keys_count > 0:
                 await state.update_data(server_name=server_name, cluster_name=cluster_name)
@@ -141,7 +139,7 @@ async def process_callback_delete_server(
                     WHERE cluster_name != $1
                     GROUP BY cluster_name
                     """,
-                    cluster_name
+                    cluster_name,
                 )
 
                 builder = InlineKeyboardBuilder()
@@ -149,13 +147,12 @@ async def process_callback_delete_server(
                     builder.row(
                         InlineKeyboardButton(
                             text=f"{cluster['cluster_name']} ({cluster['key_count']})",
-                            callback_data=f"transfer_to_cluster|{cluster['cluster_name']}|{cluster_name}|{server_name}"
+                            callback_data=f"transfer_to_cluster|{cluster['cluster_name']}|{cluster_name}|{server_name}",
                         )
                     )
                 builder.row(
                     InlineKeyboardButton(
-                        text=BACK,
-                        callback_data=AdminServerCallback(action="manage", data=server_name).pack()
+                        text=BACK, callback_data=AdminServerCallback(action="manage", data=server_name).pack()
                     )
                 )
 
@@ -167,9 +164,7 @@ async def process_callback_delete_server(
                 return
 
         await session.execute(
-            "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2",
-            cluster_name,
-            server_name
+            "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2", cluster_name, server_name
         )
         await callback_query.message.edit_text(
             text=f"✅ Сервер '{server_name}' удален. Кластер '{cluster_name}' также удален, так как в нем не осталось серверов.",
@@ -177,11 +172,98 @@ async def process_callback_delete_server(
         )
     else:
         await session.execute(
-            "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2",
-            cluster_name,
-            server_name
+            "DELETE FROM servers WHERE cluster_name = $1 AND server_name = $2", cluster_name, server_name
         )
         await callback_query.message.edit_text(
             text=f"✅ Сервер '{server_name}' удален.",
             reply_markup=build_admin_back_kb("clusters"),
         )
+
+
+@router.callback_query(AdminServerCallback.filter(F.action.in_(["enable", "disable"])), IsAdminFilter())
+async def toggle_server_enabled(callback_query: CallbackQuery, callback_data: AdminServerCallback, session: Any):
+    server_name = callback_data.data
+    action = callback_data.action
+
+    new_status = action == "enable"
+
+    await session.execute("UPDATE servers SET enabled = $1 WHERE server_name = $2", new_status, server_name)
+
+    servers = await get_servers(include_enabled=True)
+
+    cluster_name, server = next(
+        ((c, s) for c, cs in servers.items() for s in cs if s["server_name"] == server_name), (None, None)
+    )
+
+    if not server:
+        await callback_query.message.edit_text("❌ Сервер не найден.")
+        return
+
+    max_keys = server.get("max_keys")
+    limit_display = f"{max_keys}" if max_keys else "не задан"
+
+    text = (
+        f"<b>🔧 Информация о сервере {server_name}:</b>\n\n"
+        f"<b>📡 API URL:</b> {server['api_url']}\n"
+        f"<b>🌐 Subscription URL:</b> {server['subscription_url']}\n"
+        f"<b>🔑 Inbound ID:</b> {server['inbound_id']}\n"
+        f"<b>📈 Лимит ключей:</b> {limit_display}"
+    )
+
+    await callback_query.message.edit_text(
+        text=text,
+        reply_markup=build_manage_server_kb(server_name, cluster_name, enabled=new_status),
+    )
+
+
+@router.callback_query(AdminServerCallback.filter(F.action == "set_limit"), IsAdminFilter())
+async def ask_server_limit(callback: CallbackQuery, callback_data: AdminServerCallback, state: FSMContext):
+    server_name = callback_data.data
+    await state.set_state(ServerLimitState.waiting_for_limit)
+    await state.update_data(server_name=server_name)
+    await callback.message.edit_text(
+        f"Введите лимит ключей для сервера <b>{server_name}</b> (целое число, 0 — без лимита):",
+    )
+
+
+@router.message(ServerLimitState.waiting_for_limit, IsAdminFilter())
+async def save_server_limit(message: types.Message, state: FSMContext, session: Any):
+    try:
+        limit = int(message.text.strip())
+        if limit < 0:
+            raise ValueError
+
+        data = await state.get_data()
+        server_name = data["server_name"]
+
+        new_value = limit if limit > 0 else None
+        await session.execute("UPDATE servers SET max_keys = $1 WHERE server_name = $2", new_value, server_name)
+
+        servers = await get_servers(include_enabled=True)
+        cluster_name, server = next(
+            ((c, s) for c, cs in servers.items() for s in cs if s["server_name"] == server_name), (None, None)
+        )
+
+        if not server:
+            await message.answer("❌ Сервер не найден.")
+            await state.clear()
+            return
+
+        max_keys = server.get("max_keys")
+        limit_display = f"{max_keys}" if max_keys is not None else "не задан"
+
+        text = (
+            f"<b>🔧 Информация о сервере {server_name}:</b>\n\n"
+            f"<b>📡 API URL:</b> {server['api_url']}\n"
+            f"<b>🌐 Subscription URL:</b> {server['subscription_url']}\n"
+            f"<b>🔑 Inbound ID:</b> {server['inbound_id']}\n"
+            f"<b>📈 Лимит ключей:</b> {limit_display}"
+        )
+
+        await message.answer(
+            text, reply_markup=build_manage_server_kb(server_name, cluster_name, enabled=server.get("enabled", True))
+        )
+        await state.clear()
+
+    except ValueError:
+        await message.answer("❌ Введите корректное целое число (0 = без лимита)")

handlers/admin/users/users_handler.py

@@ -1,4 +1,5 @@
 import asyncio
+import time
 import uuid
 
 from datetime import datetime, timedelta, timezone
@@ -19,7 +20,9 @@ from database import (
     delete_user_data,
     get_balance,
     get_client_id_by_email,
+    get_key_details,
     get_servers,
+    set_user_balance,
     update_balance,
     update_key_expiry,
     update_trial,
@@ -60,10 +63,8 @@ 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()
@@ -98,41 +99,6 @@ async def handle_search_key(callback_query: CallbackQuery, state: FSMContext):
     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()
@@ -151,6 +117,39 @@ async def handle_key_name_input(message: Message, state: FSMContext, session: An
     await process_user_search(message, state, session, key_details["tg_id"])
 
 
+@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.callback_query(
     AdminUserEditorCallback.filter(F.action == "users_send_message"),
     IsAdminFilter(),
@@ -614,24 +613,24 @@ async def process_user_search(
 ) -> None:
     await state.clear()
 
-    balance = await session.fetchval("SELECT balance FROM connections WHERE tg_id = $1", tg_id)
-
-    if balance is None:
+    user_data = await session.fetchrow(
+        "SELECT username, balance, created_at, updated_at FROM users WHERE tg_id = $1", tg_id
+    )
+    if not user_data:
         await message.answer(
             text="🚫 Пользователь с указанным ID не найден!",
             reply_markup=build_admin_back_kb(),
         )
         return
 
-    balance = int(balance)
-
-    user_data = await session.fetchrow("SELECT username, created_at, updated_at FROM users WHERE tg_id = $1", tg_id)
-    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)
+    balance = int(user_data["balance"] or 0)
+    username = user_data["username"]
     created_at = user_data["created_at"].astimezone(MOSCOW_TZ).strftime("%H:%M:%S %d.%m.%Y")
     updated_at = user_data["updated_at"].astimezone(MOSCOW_TZ).strftime("%H:%M:%S %d.%m.%Y")
 
+    referral_count = await session.fetchval("SELECT COUNT(*) FROM referrals WHERE referrer_tg_id = $1", tg_id)
+    key_records = await session.fetch("SELECT email, expiry_time FROM keys WHERE tg_id = $1", tg_id)
+
     text = (
         f"<b>📊 Информация о пользователе</b>"
         f"\n\n🆔 ID: <b>{tg_id}</b>"
@@ -653,35 +652,6 @@ async def process_user_search(
         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.remnawave_link, 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"],
-        "remnawave_link": record["remnawave_link"],
-        "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)
 
@@ -694,6 +664,8 @@ async def change_expiry_time(expiry_time: int, email: str, session: Any) -> Exce
         return ValueError(f"User with client_id {server_id} was not found")
 
     clusters = await get_servers()
+    added_days = max((expiry_time - int(time.time() * 1000)) / (1000 * 86400), 1)
+    total_gb = int((added_days / 30) * TOTAL_GB * 1024**3)
 
     async def update_key_on_all_servers():
         tasks = [
@@ -703,7 +675,7 @@ async def change_expiry_time(expiry_time: int, email: str, session: Any) -> Exce
                     email,
                     client_id,
                     expiry_time,
-                    total_gb=TOTAL_GB,
+                    total_gb=total_gb,
                 )
             )
             for cluster_name in clusters
@@ -715,17 +687,6 @@ async def change_expiry_time(expiry_time: int, email: str, session: Any) -> Exce
     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
@@ -783,13 +744,17 @@ async def restore_trials(callback_query: types.CallbackQuery, session: Any):
     Восстанавливает пробники для пользователей, у которых нет активной подписки.
     """
     query = """
-        UPDATE connections
+        UPDATE users
         SET trial = 0
         WHERE tg_id IN (
-            SELECT DISTINCT c.tg_id
-            FROM connections c
-            LEFT JOIN keys k ON c.tg_id = k.tg_id
-            WHERE k.tg_id IS NULL AND c.trial != 0
+            SELECT u.tg_id
+            FROM users u
+            LEFT JOIN (
+                SELECT tg_id
+                FROM keys
+                WHERE expiry_time > EXTRACT(EPOCH FROM NOW()) * 1000
+            ) k ON u.tg_id = k.tg_id
+            WHERE k.tg_id IS NULL AND u.trial != 0
         )
     """
     await session.execute(query)
@@ -798,7 +763,7 @@ async def restore_trials(callback_query: types.CallbackQuery, session: Any):
     builder.row(build_admin_back_btn())
 
     await callback_query.message.edit_text(
-        text="✅ Пробники успешно восстановлены для пользователей, у которых нет активных подписок.",
+        text="✅ Пробники успешно восстановлены для пользователей без активных подписок.",
         reply_markup=builder.as_markup(),
     )
 
@@ -826,7 +791,9 @@ async def handle_users_export_referrals(
 
 
 @router.callback_query(AdminUserEditorCallback.filter(F.action == "users_create_key"), IsAdminFilter())
-async def handle_create_key_start(callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, state: FSMContext, session: Any):
+async def handle_create_key_start(
+    callback_query: CallbackQuery, callback_data: AdminUserEditorCallback, state: FSMContext, session: Any
+):
     tg_id = callback_data.tg_id
     await state.update_data(tg_id=tg_id)
 
@@ -838,8 +805,7 @@ async def handle_create_key_start(callback_query: CallbackQuery, callback_data:
 
         if not countries:
             await callback_query.message.edit_text(
-                "❌ Нет доступных стран для создания ключа.",
-                reply_markup=build_editor_kb(tg_id)
+                "❌ Нет доступных стран для создания ключа.", reply_markup=build_editor_kb(tg_id)
             )
             return
 
@@ -850,8 +816,7 @@ async def handle_create_key_start(callback_query: CallbackQuery, callback_data:
         builder.row(build_admin_back_btn())
 
         await callback_query.message.edit_text(
-            "🌍 <b>Выберите страну для создания ключа:</b>",
-            reply_markup=builder.as_markup()
+            "🌍 <b>Выберите страну для создания ключа:</b>", reply_markup=builder.as_markup()
         )
         return
 
@@ -862,8 +827,7 @@ async def handle_create_key_start(callback_query: CallbackQuery, callback_data:
 
     if not cluster_names:
         await callback_query.message.edit_text(
-            "❌ Нет доступных кластеров для создания ключа.",
-            reply_markup=build_editor_kb(tg_id)
+            "❌ Нет доступных кластеров для создания ключа.", reply_markup=build_editor_kb(tg_id)
         )
         return
 
@@ -873,8 +837,7 @@ async def handle_create_key_start(callback_query: CallbackQuery, callback_data:
     builder.row(build_admin_back_btn())
 
     await callback_query.message.edit_text(
-        "🌐 <b>Выберите кластер для создания ключа:</b>",
-        reply_markup=builder.as_markup()
+        "🌐 <b>Выберите кластер для создания ключа:</b>", reply_markup=builder.as_markup()
     )
 
 
@@ -891,8 +854,7 @@ async def handle_create_key_country(callback_query: CallbackQuery, state: FSMCon
     builder.row(build_admin_back_btn())
 
     await callback_query.message.edit_text(
-        text=f"🕒 <b>Выберите срок действия ключа для страны {country}:</b>",
-        reply_markup=builder.as_markup()
+        text=f"🕒 <b>Выберите срок действия ключа для страны {country}:</b>", reply_markup=builder.as_markup()
     )
 
 
@@ -928,15 +890,7 @@ async def handle_create_key_duration(callback_query: CallbackQuery, state: FSMCo
 
         if USE_COUNTRY_SELECTION and "country" in data:
             country = data["country"]
-            await create_key_on_cluster(
-                country, 
-                tg_id,
-                client_id,
-                email,
-                expiry_ms,
-                plan=months,
-                session=session
-            )
+            await create_key_on_cluster(country, tg_id, client_id, email, expiry_ms, plan=months, session=session)
 
             await state.clear()
             await callback_query.message.edit_text(
@@ -946,15 +900,7 @@ async def handle_create_key_duration(callback_query: CallbackQuery, state: FSMCo
 
         elif "cluster_name" in data:
             cluster_name = data["cluster_name"]
-            await create_key_on_cluster(
-                cluster_name,
-                tg_id,
-                client_id,
-                email,
-                expiry_ms,
-                plan=months,
-                session=session
-            )
+            await create_key_on_cluster(cluster_name, tg_id, client_id, email, expiry_ms, plan=months, session=session)
 
             await state.clear()
             await callback_query.message.edit_text(
@@ -968,8 +914,7 @@ async def handle_create_key_duration(callback_query: CallbackQuery, state: FSMCo
     except Exception as e:
         logger.error(f"Ошибка при создании ключа: {e}")
         await callback_query.message.edit_text(
-            "❌ Не удалось создать ключ. Попробуйте позже.",
-            reply_markup=build_editor_kb(data.get("tg_id", 0))
+            "❌ Не удалось создать ключ. Попробуйте позже.", reply_markup=build_editor_kb(data.get("tg_id", 0))
         )
 
 

handlers/buttons.py

@@ -38,6 +38,7 @@ GIFT = "🎁 Подарить подписку"
 MY_GIFTS = "🎁 Мои подарки"
 GIFTS_MENU = "В меню подарков"
 SHARE_GIFT = "🎁 Поделиться подарком"
+GET_GIFT = "🎁 Получить подарок"
 
 # Создание и подключение ключей
 

handlers/captcha.py

@@ -8,8 +8,7 @@ from aiogram.fsm.context import FSMContext
 from aiogram.types import CallbackQuery, Message
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
-from config import CAPTCHA_EMOJIS
-from handlers.texts import CAPTCHA_PROMPT_MSG
+from handlers.texts import CAPTCHA_EMOJIS, CAPTCHA_PROMPT_MSG
 from logger import logger
 
 from .utils import edit_or_send_message

handlers/coupons.py

@@ -1,35 +1,37 @@
+import html
+
+from datetime import datetime
 from typing import Any
 
+import pytz
+
 from aiogram import F, Router
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
 from aiogram.types import CallbackQuery, InlineKeyboardButton, Message
 from aiogram.utils.keyboard import InlineKeyboardBuilder
-import pytz
-import html
-from datetime import datetime
 
 from config import ADMIN_ID
 from database import (
+    add_user,
     check_coupon_usage,
+    check_user_exists,
     create_coupon_usage,
     get_coupon_by_code,
     get_keys,
     update_balance,
     update_coupon_usage_count,
     update_key_expiry,
-    check_connection_exists,
-    add_connection,
 )
 from handlers.buttons import MAIN_MENU
 from handlers.keys.key_utils import renew_key_in_cluster
+from handlers.profile import process_callback_view_profile
 from handlers.texts import (
     COUPON_ALREADY_USED_MSG,
     COUPON_INPUT_PROMPT,
     COUPON_NOT_FOUND_MSG,
 )
 from handlers.utils import edit_or_send_message, format_days
-from handlers.profile import process_callback_view_profile
 from logger import logger
 
 
@@ -67,15 +69,14 @@ async def process_coupon_code(message: Message, state: FSMContext, session: Any)
     await activate_coupon(message, state, session, coupon_code=coupon_code)
 
 
-async def activate_coupon(
-    message: Message, state: FSMContext, session: Any, coupon_code: str, admin: bool = False
-):
+async def activate_coupon(message: Message, state: FSMContext, session: Any, coupon_code: str, admin: bool = False):
     logger.info(f"Активация купона: {coupon_code}")
     coupon_record = await get_coupon_by_code(coupon_code, session)
 
     if not coupon_record:
-        await message.answer(COUPON_NOT_FOUND_MSG)
-        await state.clear()
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="exit_coupon_input"))
+        await message.answer(COUPON_NOT_FOUND_MSG, reply_markup=builder.as_markup())
         return
 
     if coupon_record["usage_count"] >= coupon_record["usage_limit"] or coupon_record["is_used"]:
@@ -91,9 +92,18 @@ async def activate_coupon(
         await state.clear()
         return
 
-    connection_exists = await check_connection_exists(user_id)
-    if not connection_exists:
-        await add_connection(tg_id=user_id, session=session)
+    user_exists = await check_user_exists(user_id)
+    if not user_exists:
+        from_user = message.from_user
+        await add_user(
+            tg_id=from_user.id,
+            username=from_user.username,
+            first_name=from_user.first_name,
+            last_name=from_user.last_name,
+            language_code=from_user.language_code,
+            is_bot=from_user.is_bot,
+            session=session,
+        )
 
     if coupon_record["amount"] > 0:
         try:
@@ -101,8 +111,6 @@ async def activate_coupon(
             await update_coupon_usage_count(coupon_record["id"], session)
             await create_coupon_usage(coupon_record["id"], user_id, session)
             await message.answer(f"✅ Купон активирован, на баланс начислено {coupon_record['amount']} рублей.")
-            is_admin = message.from_user.id in ADMIN_ID
-            await process_callback_view_profile(message, state, admin=is_admin)
             await state.clear()
         except Exception as e:
             logger.error(f"Ошибка при активации купона на баланс: {e}")
@@ -172,9 +180,7 @@ async def handle_key_extension(callback_query: CallbackQuery, state: FSMContext,
             return
 
         key = await session.fetchrow(
-            "SELECT * FROM keys WHERE tg_id = $1 AND client_id = $2",
-            callback_query.from_user.id,
-            client_id
+            "SELECT * FROM keys WHERE tg_id = $1 AND client_id = $2", callback_query.from_user.id, client_id
         )
         if not key or key["is_frozen"]:
             await callback_query.message.edit_text("❌ Выбранная подписка не найдена или заморожена.")
@@ -186,11 +192,7 @@ async def handle_key_extension(callback_query: CallbackQuery, state: FSMContext,
         new_expiry = max(now_ms, current_expiry) + (coupon["days"] * 86400 * 1000)
 
         await renew_key_in_cluster(
-            cluster_id=key["server_id"],
-            email=key["email"],
-            client_id=client_id,
-            new_expiry_time=new_expiry,
-            total_gb=0
+            cluster_id=key["server_id"], email=key["email"], client_id=client_id, new_expiry_time=new_expiry, total_gb=0
         )
         await update_key_expiry(client_id, new_expiry, session)
 
@@ -198,7 +200,9 @@ async def handle_key_extension(callback_query: CallbackQuery, state: FSMContext,
         await create_coupon_usage(coupon["id"], callback_query.from_user.id, session)
 
         alias = key.get("alias") or key["email"]
-        expiry_date = datetime.fromtimestamp(new_expiry / 1000, tz=pytz.timezone("Europe/Moscow")).strftime("%d.%m.%y, %H:%M")
+        expiry_date = datetime.fromtimestamp(new_expiry / 1000, tz=pytz.timezone("Europe/Moscow")).strftime(
+            "%d.%m.%y, %H:%M"
+        )
         await callback_query.message.answer(
             f"✅ Купон активирован, подписка <b>{alias}</b> продлена на {format_days(coupon['days'])}⏳ до {expiry_date}📆."
         )
@@ -215,3 +219,10 @@ async def cancel_coupon_activation(callback_query: CallbackQuery, state: FSMCont
     await callback_query.message.edit_text("⚠️ Активация купона отменена.")
     await process_callback_view_profile(callback_query.message, state, admin)
     await state.clear()
+
+
+@router.callback_query(F.data == "exit_coupon_input")
+async def handle_exit_coupon_input(callback_query: CallbackQuery, state: FSMContext):
+    await state.clear()
+    is_admin = callback_query.from_user.id in ADMIN_ID
+    await process_callback_view_profile(callback_query.message, state, admin=is_admin)

handlers/instructions/instructions.py

@@ -1,4 +1,5 @@
 import os
+
 from typing import Any
 
 from aiogram import F, Router

handlers/keys/__init__.py

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

handlers/keys/key_connect.py

@@ -1,4 +1,5 @@
 import os
+
 from io import BytesIO
 from typing import Any
 
@@ -6,19 +7,10 @@ import asyncpg
 import qrcode
 
 from aiogram import F, Router, types
-
 from aiogram.types import CallbackQuery, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
-from config import (
-    CONNECT_ANDROID,
-    CONNECT_IOS,
-    DATABASE_URL,
-    DOWNLOAD_ANDROID,
-    DOWNLOAD_IOS,
-    INSTRUCTIONS_BUTTON
-)
-
+from config import CONNECT_ANDROID, CONNECT_IOS, DATABASE_URL, DOWNLOAD_ANDROID, DOWNLOAD_IOS, INSTRUCTIONS_BUTTON
 from handlers.buttons import (
     ANDROID,
     BACK,
@@ -108,7 +100,7 @@ async def process_callback_connect_phone(callback_query: CallbackQuery):
         InlineKeyboardButton(text=IMPORT_ANDROID, url=f"{CONNECT_ANDROID}{key_link}"),
     )
     if INSTRUCTIONS_BUTTON:
-       builder.row(InlineKeyboardButton(text=MANUAL_INSTRUCTIONS, callback_data="instructions"))
+        builder.row(InlineKeyboardButton(text=MANUAL_INSTRUCTIONS, callback_data="instructions"))
     builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{email}"))
 
     await edit_or_send_message(
@@ -234,4 +226,4 @@ async def show_qr_code(callback_query: types.CallbackQuery, session: Any):
 
     except Exception as e:
         logger.error(f"Ошибка при генерации QR: {e}", exc_info=True)
-        await callback_query.message.answer("❌ Произошла ошибка при создании QR-кода.")
+        await callback_query.message.answer("❌ Произошла ошибка при создании QR-кода.")

handlers/keys/key_freeze.py

@@ -3,7 +3,6 @@ import time
 from typing import Any
 
 from aiogram import F, Router
-
 from aiogram.types import CallbackQuery, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
@@ -96,13 +95,15 @@ async def process_callback_unfreeze_subscription_confirm(callback_query: Callbac
                 record["tg_id"],
                 client_id,
             )
+            added_days = max(leftover / (1000 * 86400), 0.01)
+            total_gb = int((added_days / 30) * TOTAL_GB * 1024**3)
 
             await renew_key_in_cluster(
                 cluster_id=cluster_id,
                 email=email,
                 client_id=client_id,
                 new_expiry_time=new_expiry_time,
-                total_gb=TOTAL_GB,
+                total_gb=total_gb,
             )
             text_ok = SUBSCRIPTION_UNFROZEN_MSG
             builder = InlineKeyboardBuilder()
@@ -216,4 +217,4 @@ async def process_callback_freeze_subscription_confirm(callback_query: CallbackQ
             )
 
     except Exception as e:
-        await handle_error(tg_id, callback_query, f"Ошибка при заморозке подписки: {e}")
+        await handle_error(tg_id, callback_query, f"Ошибка при заморозке подписки: {e}")

handlers/keys/key_mode/__init__.py

@@ -2,9 +2,10 @@ __all__ = ("router",)
 
 from aiogram import Router
 
-from .key_create import router as create_router
 from .key_cluster_mode import router as cluster_router
 from .key_country_mode import router as country_router
+from .key_create import router as create_router
+
 
 router = Router(name="key_mode_router")
 

handlers/keys/key_mode/key_cluster_mode.py

@@ -5,7 +5,7 @@ from datetime import datetime
 import pytz
 
 from aiogram import Router
-from aiogram.types import CallbackQuery, InlineKeyboardButton, Message, FSInputFile, WebAppInfo
+from aiogram.types import CallbackQuery, FSInputFile, InlineKeyboardButton, Message, WebAppInfo
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from bot import bot
@@ -20,19 +20,17 @@ from database import (
     update_balance,
     update_trial,
 )
-from handlers.buttons import (
-    CONNECT_DEVICE,
-    CONNECT_PHONE,
-    MAIN_MENU,
-    PC_BUTTON,
-    TV_BUTTON,
-    SUPPORT
-)
+from handlers.buttons import CONNECT_DEVICE, CONNECT_PHONE, MAIN_MENU, PC_BUTTON, SUPPORT, TV_BUTTON
 from handlers.keys.key_utils import create_key_on_cluster
 from handlers.texts import (
     key_message_success,
 )
-from handlers.utils import edit_or_send_message, generate_random_email, get_least_loaded_cluster, is_full_remnawave_cluster
+from handlers.utils import (
+    edit_or_send_message,
+    generate_random_email,
+    get_least_loaded_cluster,
+    is_full_remnawave_cluster,
+)
 from logger import logger
 
 
@@ -63,9 +61,7 @@ async def key_cluster_mode(
 
     try:
         least_loaded_cluster = await get_least_loaded_cluster()
-        await create_key_on_cluster(
-            least_loaded_cluster, tg_id, client_id, email, expiry_timestamp, plan, session
-        )
+        await create_key_on_cluster(least_loaded_cluster, tg_id, client_id, email, expiry_timestamp, plan, session)
         logger.info(f"[Key Creation] Ключ создан на кластере {least_loaded_cluster} для пользователя {tg_id}")
 
         key_record = await get_key_details(email, session)
@@ -150,4 +146,4 @@ async def key_cluster_mode(
         )
 
     if state:
-        await state.clear()
+        await state.clear()

handlers/keys/key_mode/key_country_mode.py

@@ -3,6 +3,7 @@ import uuid
 
 from datetime import datetime
 from typing import Any
+import asyncpg
 
 import pytz
 
@@ -13,34 +14,26 @@ from aiogram.utils.keyboard import InlineKeyboardBuilder
 from py3xui import AsyncApi
 
 from config import (
+    DATABASE_URL,
     ADMIN_PASSWORD,
     ADMIN_USERNAME,
     CONNECT_PHONE_BUTTON,
     PUBLIC_LINK,
+    REMNAWAVE_LOGIN,
+    REMNAWAVE_PASSWORD,
     RENEWAL_PRICES,
     SUPPORT_CHAT_URL,
-    REMNAWAVE_LOGIN,
-    REMNAWAVE_PASSWORD
 )
 from database import (
-    add_connection,
-    check_connection_exists,
+    add_user,
+    check_server_name_by_cluster,
+    check_user_exists,
     get_key_details,
     get_trial,
     update_balance,
     update_trial,
-    check_server_name_by_cluster,
-)
-from handlers.buttons import (
-    BACK,
-    CONNECT_DEVICE,
-    CONNECT_PHONE,
-    MAIN_MENU,
-    PC_BUTTON,
-    SUPPORT,
-    TV_BUTTON,
-    SUPPORT
 )
+from handlers.buttons import BACK, CONNECT_DEVICE, CONNECT_PHONE, MAIN_MENU, PC_BUTTON, SUPPORT, TV_BUTTON
 from handlers.keys.key_utils import create_client_on_server
 from handlers.texts import (
     SELECT_COUNTRY_MSG,
@@ -48,8 +41,8 @@ from handlers.texts import (
 )
 from handlers.utils import edit_or_send_message, generate_random_email, get_least_loaded_cluster
 from logger import logger
-from panels.three_xui import delete_client
 from panels.remnawave import RemnawaveAPI
+from panels.three_xui import delete_client, get_xui_instance
 
 
 router = Router()
@@ -73,7 +66,6 @@ async def key_country_mode(
         least_loaded_cluster,
     )
 
-
     if not servers:
         logger.error(f"Нет серверов в кластере {least_loaded_cluster}")
         error_message = "❌ Нет доступных серверов для создания ключа."
@@ -88,7 +80,7 @@ async def key_country_mode(
     tasks = [asyncio.create_task(check_server_availability(server)) for server in servers]
     results = await asyncio.gather(*tasks, return_exceptions=True)
 
-    for server, result in zip(servers, results):
+    for server, result in zip(servers, results, strict=False):
         if result is True:
             available_servers.append(server["server_name"])
 
@@ -151,7 +143,7 @@ async def change_location_callback(callback_query: CallbackQuery, session: Any):
         cluster_name = cluster_info["cluster_name"]
 
         servers = await session.fetch(
-            "SELECT server_name, api_url, panel_type FROM servers WHERE cluster_name = $1 AND server_name != $2",
+            "SELECT server_name, api_url, panel_type, enabled, max_keys FROM servers WHERE cluster_name = $1 AND server_name != $2",
             cluster_name,
             current_server,
         )
@@ -167,13 +159,15 @@ async def change_location_callback(callback_query: CallbackQuery, session: Any):
                 "server_name": server["server_name"],
                 "api_url": server["api_url"],
                 "panel_type": server["panel_type"],
+                "enabled": server.get("enabled", True),
+                "max_keys": server.get("max_keys"),
             }
             task = asyncio.create_task(check_server_availability(server_info))
             tasks.append(task)
 
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
-        for server, result in zip(servers, results):
+        for server, result in zip(servers, results, strict=False):
             if result is True:
                 available_servers.append(server["server_name"])
 
@@ -240,9 +234,22 @@ async def finalize_key_creation(
     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}")
+    if not await check_user_exists(tg_id):
+        if isinstance(callback_query, CallbackQuery):
+            from_user = callback_query.from_user
+        else:
+            from_user = callback_query.from_user
+
+        await add_user(
+            tg_id=from_user.id,
+            username=from_user.username,
+            first_name=from_user.first_name,
+            last_name=from_user.last_name,
+            language_code=from_user.language_code,
+            is_bot=from_user.is_bot,
+            session=session,
+        )
+        logger.info(f"[User] Новый пользователь {tg_id} добавлен")
 
     expiry_time = expiry_time.astimezone(moscow_tz)
 
@@ -266,6 +273,8 @@ async def finalize_key_creation(
         email = key_name.lower()
         expiry_timestamp = int(expiry_time.timestamp() * 1000)
 
+    remna = None
+
     try:
         server_info = await session.fetchrow(
             "SELECT api_url, inbound_id, server_name, panel_type FROM servers WHERE server_name = $1",
@@ -280,31 +289,49 @@ async def finalize_key_creation(
         remnawave_link = None
         created_at = int(datetime.now(moscow_tz).timestamp() * 1000)
 
-        if old_key_name and panel_type == "3x-ui":
+        if old_key_name:
             old_server_id = old_key_details.get("server_id")
             if old_server_id:
                 old_server_info = await session.fetchrow(
-                    "SELECT api_url, inbound_id, server_name FROM servers WHERE server_name = $1",
+                    "SELECT api_url, inbound_id, server_name, panel_type FROM servers WHERE server_name = $1",
                     old_server_id,
                 )
                 if old_server_info:
-                    xui = AsyncApi(
-                        old_server_info["api_url"],
-                        username=ADMIN_USERNAME,
-                        password=ADMIN_PASSWORD,
-                        logger=logger,
-                    )
-                    await delete_client(
-                        xui,
-                        old_server_info["inbound_id"],
-                        email,
-                        client_id,
-                    )
+                    old_panel_type = old_server_info["panel_type"].lower()
+                    try:
+                        if old_panel_type == "3x-ui":
+                            xui = await get_xui_instance(old_server_info["api_url"])
+
+                            await delete_client(
+                                xui,
+                                old_server_info["inbound_id"],
+                                email,
+                                client_id,
+                            )
+                            await session.execute(
+                                "UPDATE keys SET key = NULL WHERE tg_id = $1 AND email = $2",
+                                tg_id,
+                                email,
+                            )
+                            logger.info(f"[Delete] Удалён клиент {email} с 3x-ui сервера {old_server_id}")
+                        elif old_panel_type == "remnawave":
+                            remna = RemnawaveAPI(old_server_info["api_url"])
+                            if await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
+                                await remna.delete_user(client_id)
+                                await session.execute(
+                                    "UPDATE keys SET remnawave_link = NULL WHERE tg_id = $1 AND email = $2",
+                                    tg_id,
+                                    email,
+                                )
+                                logger.info(f"[Delete] Удалён клиент {client_id} с Remnawave сервера {old_server_id}")
+                            else:
+                                logger.warning(f"[Delete] Не удалось авторизоваться в Remnawave ({old_server_id})")
+                    except Exception as e:
+                        logger.warning(f"[Delete] Ошибка при удалении клиента с сервера {old_server_id}: {e}")
 
         if panel_type == "remnawave":
             remna = RemnawaveAPI(server_info["api_url"])
-            logged_in = await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD)
-            if not logged_in:
+            if not await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
                 raise ValueError(f"❌ Не удалось авторизоваться в Remnawave ({selected_country})")
 
             expire_at = datetime.utcfromtimestamp(expiry_timestamp / 1000).isoformat() + "Z"
@@ -323,6 +350,14 @@ async def finalize_key_creation(
             remnawave_link = result.get("subscriptionUrl")
             logger.info(f"[Key Creation] Remnawave пользователь создан: {result}")
 
+            if old_key_name:
+                await session.execute(
+                    "UPDATE keys SET client_id = $1 WHERE tg_id = $2 AND email = $3",
+                    client_id,
+                    tg_id,
+                    email,
+                )
+
         if panel_type == "3x-ui":
             semaphore = asyncio.Semaphore(2)
             await create_client_on_server(
@@ -344,6 +379,21 @@ async def finalize_key_creation(
                 tg_id,
                 old_key_name,
             )
+            if panel_type == "3x-ui":
+                await session.execute(
+                    "UPDATE keys SET key = $1 WHERE tg_id = $2 AND email = $3",
+                    public_link,
+                    tg_id,
+                    email,
+                )
+            elif panel_type == "remnawave":
+                await session.execute(
+                    "UPDATE keys SET remnawave_link = $1 WHERE tg_id = $2 AND email = $3",
+                    remnawave_link,
+                    tg_id,
+                    email,
+                )
+
         else:
             await session.execute(
                 """
@@ -403,12 +453,37 @@ async def finalize_key_creation(
         await state.clear()
 
 
-async def check_server_availability(server_info: dict) -> bool:
-    """
-    Проверяет доступность сервера (3x-ui или Remnawave).
-    """
-    panel_type = server_info.get("panel_type", "3x-ui").lower()
+async def check_server_availability(server_info: dict, session: Any = None) -> bool:
     server_name = server_info.get("server_name", "unknown")
+    panel_type = server_info.get("panel_type", "3x-ui").lower()
+    enabled = server_info.get("enabled", True)
+    max_keys = server_info.get("max_keys")
+
+    if not enabled:
+        logger.info(f"[Ping] Сервер {server_name} выключен (enabled = FALSE).")
+        return False
+
+    connection = None
+    external_session = session is not None
+
+    try:
+        if not external_session:
+            connection = await asyncpg.connect(DATABASE_URL)
+            session = connection
+
+        if max_keys is not None:
+            count_query = "SELECT COUNT(*) FROM keys WHERE server_id = $1"
+            key_count = await session.fetchval(count_query, server_name)
+            if key_count >= max_keys:
+                logger.info(f"[Ping] Сервер {server_name} достиг лимита ключей: {key_count}/{max_keys}.")
+                return False
+
+    except Exception as e:
+        logger.warning(f"[Ping] Ошибка при проверке лимита ключей на сервере {server_name}: {e}")
+        return False
+    finally:
+        if connection:
+            await connection.close()
 
     try:
         if panel_type == "remnawave":
@@ -428,10 +503,9 @@ async def check_server_availability(server_info: dict) -> bool:
             logger.info(f"[Ping] 3x-ui сервер {server_name} доступен.")
             return True
 
-    except asyncio.TimeoutError:
+    except TimeoutError:
         logger.warning(f"[Ping] Сервер {server_name} не ответил вовремя.")
         return False
     except Exception as e:
         logger.warning(f"[Ping] Ошибка при проверке сервера {server_name}: {e}")
         return False
-

handlers/keys/key_mode/key_create.py

@@ -7,8 +7,6 @@ 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 .key_cluster_mode import key_cluster_mode
-from .key_country_mode import key_country_mode
 
 from config import (
     NOTIFY_EXTRA_DAYS,
@@ -19,8 +17,8 @@ from config import (
     USE_NEW_PAYMENT_FLOW,
 )
 from database import (
-    add_connection,
-    check_connection_exists,
+    add_user,
+    check_user_exists,
     create_temporary_data,
     get_balance,
     get_trial,
@@ -40,6 +38,9 @@ from handlers.texts import (
 from handlers.utils import edit_or_send_message
 from logger import logger
 
+from .key_cluster_mode import key_cluster_mode
+from .key_country_mode import key_country_mode
+
 
 router = Router()
 
@@ -178,9 +179,19 @@ async def create_key(
     Делегирует выполнение в зависимости от выбранного режима (страна или кластер).
     Также отвечает за первичное подключение пользователя.
     """
-    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 not await check_user_exists(tg_id):
+        from_user = message_or_query.from_user if isinstance(message_or_query, CallbackQuery | Message) else None
+        if from_user:
+            await add_user(
+                tg_id=from_user.id,
+                username=from_user.username,
+                first_name=from_user.first_name,
+                last_name=from_user.last_name,
+                language_code=from_user.language_code,
+                is_bot=from_user.is_bot,
+                session=session,
+            )
+            logger.info(f"[User] Новый пользователь {tg_id} добавлен")
 
     if USE_COUNTRY_SELECTION:
         await key_country_mode(
@@ -199,4 +210,4 @@ async def create_key(
             session=session,
             message_or_query=message_or_query,
             plan=plan,
-        )
+        )

handlers/keys/key_renew.py

@@ -4,14 +4,13 @@ from typing import Any
 import asyncpg
 
 from aiogram import F, Router
-
 from aiogram.types import CallbackQuery, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from bot import bot
 from config import (
     DATABASE_URL,
-    RENEWAL_PLANS,
+    RENEWAL_PRICES,
     TOTAL_GB,
     USE_COUNTRY_SELECTION,
     USE_NEW_PAYMENT_FLOW,
@@ -42,7 +41,7 @@ from handlers.texts import (
     PLAN_SELECTION_MSG,
     SUCCESS_RENEWAL_MSG,
 )
-from handlers.utils import edit_or_send_message
+from handlers.utils import edit_or_send_message, format_months
 from logger import logger
 
 
@@ -61,13 +60,12 @@ async def process_callback_renew_key(callback_query: CallbackQuery, session: Any
 
             builder = InlineKeyboardBuilder()
 
-            for plan_id, plan_details in RENEWAL_PLANS.items():
-                months = plan_details["months"]
-                price = plan_details["price"]
+            for plan_id, price in RENEWAL_PRICES.items():
+                months = int(plan_id)
 
                 discount = DISCOUNTS.get(plan_id, 0) if isinstance(DISCOUNTS, dict) else 0
 
-                button_text = f"📅 {months} месяц{'а' if months > 1 else ''} ({price} руб.)"
+                button_text = f"📅 {format_months(months)} ({price} руб.)"
                 if discount > 0:
                     button_text += f" {discount}% скидка"
 
@@ -78,7 +76,7 @@ async def process_callback_renew_key(callback_query: CallbackQuery, session: Any
                     )
                 )
 
-            builder.row(InlineKeyboardButton(text=BACK, callback_data="view_keys"))
+            builder.row(InlineKeyboardButton(text=BACK, callback_data=f"view_key|{record['email']}"))
 
             balance = await get_balance(tg_id)
 
@@ -121,7 +119,11 @@ async def process_callback_renew_plan(callback_query: CallbackQuery, session: An
             else:
                 new_expiry_time = int(expiry_time + timedelta(days=days_to_extend).total_seconds() * 1000)
 
-            cost = RENEWAL_PLANS[plan]["price"]
+            cost = RENEWAL_PRICES.get(plan)
+            if cost is None:
+                await callback_query.message.answer("❌ Неверный тарифный план.")
+                return
+
             balance = await get_balance(tg_id)
 
             if balance < cost:
@@ -181,7 +183,7 @@ async def complete_key_renewal(tg_id, client_id, email, new_expiry_time, total_g
 
     builder = InlineKeyboardBuilder()
     builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-    response_message = SUCCESS_RENEWAL_MSG.format(months=plan)
+    response_message = SUCCESS_RENEWAL_MSG.format(months_formatted=format_months(int(plan)))
 
     if callback_query:
         try:

handlers/keys/key_utils.py

@@ -1,14 +1,22 @@
 import asyncio
 
+from datetime import datetime, timezone
 from typing import Any
 
 import asyncpg
 
-from py3xui import AsyncApi
-
-from config import ADMIN_PASSWORD, ADMIN_USERNAME, DATABASE_URL, LIMIT_IP, PUBLIC_LINK, SUPERNODE, TOTAL_GB, REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD
-from database import get_servers, store_key, delete_notification
-from handlers.utils import get_least_loaded_cluster
+from bot import bot
+from config import (
+    DATABASE_URL,
+    LIMIT_IP,
+    PUBLIC_LINK,
+    REMNAWAVE_LOGIN,
+    REMNAWAVE_PASSWORD,
+    SUPERNODE,
+    TOTAL_GB,
+)
+from database import delete_notification, get_servers, store_key
+from handlers.utils import check_server_key_limit, get_least_loaded_cluster
 from logger import logger
 from panels.remnawave import RemnawaveAPI
 from panels.three_xui import (
@@ -17,11 +25,10 @@ from panels.three_xui import (
     delete_client,
     extend_client_key,
     get_client_traffic,
+    get_xui_instance,
     toggle_client,
 )
 
-from datetime import datetime, timezone
-
 
 async def create_key_on_cluster(
     cluster_id: str,
@@ -31,9 +38,10 @@ async def create_key_on_cluster(
     expiry_timestamp: int,
     plan: int = None,
     session=None,
+    remnawave_link: str = None,
 ):
     try:
-        servers = await get_servers()
+        servers = await get_servers(include_enabled=True)
         cluster = servers.get(cluster_id)
         server_id_to_store = cluster_id
 
@@ -49,10 +57,29 @@ async def create_key_on_cluster(
             else:
                 raise ValueError(f"Кластер или сервер с ID/именем {cluster_id} не найден.")
 
-        semaphore = asyncio.Semaphore(2)
+        enabled_servers = [s for s in cluster if s.get("enabled", True)]
+        if not enabled_servers:
+            logger.warning(f"[Key Creation] Нет доступных серверов в кластере {cluster_id}")
+            return
 
-        remnawave_servers = [s for s in cluster if s.get("panel_type", "3x-ui").lower() == "remnawave"]
-        xui_servers = [s for s in cluster if s.get("panel_type", "3x-ui").lower() == "3x-ui"]
+        async with asyncpg.create_pool(DATABASE_URL) as pool:
+            async with pool.acquire() as conn:
+                remnawave_servers = [
+                    s
+                    for s in enabled_servers
+                    if s.get("panel_type", "3x-ui").lower() == "remnawave" and await check_server_key_limit(s, conn)
+                ]
+                xui_servers = [
+                    s
+                    for s in enabled_servers
+                    if s.get("panel_type", "3x-ui").lower() == "3x-ui" and await check_server_key_limit(s, conn)
+                ]
+
+        if not remnawave_servers and not xui_servers:
+            logger.warning(f"[Key Creation] Нет серверов с доступным лимитом в кластере {cluster_id}")
+            return
+
+        semaphore = asyncio.Semaphore(2)
 
         remnawave_created = False
         remnawave_key = None
@@ -71,6 +98,9 @@ async def create_key_on_cluster(
                     logger.warning("Нет inbound_id у серверов Remnawave")
                 else:
                     traffic_limit_bytes = int((plan or 1) * TOTAL_GB * 1024**3)
+                    short_uuid = None
+                    if remnawave_link and "/" in remnawave_link:
+                        short_uuid = remnawave_link.rstrip("/").split("/")[-1]
 
                     user_data = {
                         "username": email,
@@ -81,6 +111,9 @@ async def create_key_on_cluster(
                         "activeUserInbounds": inbound_ids,
                     }
 
+                    if short_uuid:
+                        user_data["shortUuid"] = short_uuid
+
                     result = await remna.create_user(user_data)
                     if not result:
                         logger.error("Ошибка при создании пользователя в Remnawave")
@@ -152,12 +185,7 @@ async def create_client_on_server(
     Создает клиента на указанном сервере.
     """
     async with semaphore:
-        xui = AsyncApi(
-            server_info["api_url"],
-            username=ADMIN_USERNAME,
-            password=ADMIN_PASSWORD,
-            logger=logger,
-        )
+        xui = await get_xui_instance(server_info["api_url"])
 
         inbound_id = server_info.get("inbound_id")
         server_name = server_info.get("server_name", "unknown")
@@ -243,8 +271,13 @@ async def renew_key_in_cluster(cluster_id, email, client_id, new_expiry_time, to
 
         if remnawave_inbound_ids:
             remnawave_server = next(
-                (srv for srv in cluster if srv.get("panel_type", "").lower() == "remnawave" and srv.get("inbound_id") in remnawave_inbound_ids),
-                None
+                (
+                    srv
+                    for srv in cluster
+                    if srv.get("panel_type", "").lower() == "remnawave"
+                    and srv.get("inbound_id") in remnawave_inbound_ids
+                ),
+                None,
             )
 
             if not remnawave_server:
@@ -258,10 +291,11 @@ async def renew_key_in_cluster(cluster_id, email, client_id, new_expiry_time, to
                         uuid=client_id,
                         expire_at=expire_iso,
                         active_user_inbounds=remnawave_inbound_ids,
-                        traffic_limit_bytes=total_gb
+                        traffic_limit_bytes=total_gb,
                     )
                     if updated:
                         logger.info(f"Подписка Remnawave {client_id} успешно продлена")
+                        await remna.reset_user_traffic(client_id)
                     else:
                         logger.warning(f"Не удалось продлить подписку Remnawave {client_id}")
                 else:
@@ -272,12 +306,7 @@ async def renew_key_in_cluster(cluster_id, email, client_id, new_expiry_time, to
             server_name = server_info.get("server_name", "unknown")
 
             if panel_type == "3x-ui":
-                xui = AsyncApi(
-                    server_info["api_url"],
-                    username=ADMIN_USERNAME,
-                    password=ADMIN_PASSWORD,
-                    logger=logger,
-                )
+                xui = await get_xui_instance(server_info["api_url"])
 
                 inbound_id = server_info.get("inbound_id")
 
@@ -344,12 +373,7 @@ async def delete_key_from_cluster(cluster_id, email, client_id):
                 continue
 
             elif panel_type == "3x-ui":
-                xui = AsyncApi(
-                    server_info["api_url"],
-                    username=ADMIN_USERNAME,
-                    password=ADMIN_PASSWORD,
-                    logger=logger,
-                )
+                xui = await get_xui_instance(server_info["api_url"])
 
                 inbound_id = server_info.get("inbound_id")
                 if not inbound_id:
@@ -426,9 +450,9 @@ async def update_key_on_cluster(tg_id, client_id, email, expiry_time, cluster_id
                     remnawave_key = result.get("subscriptionUrl")
                     logger.info(f"[Update] Remnawave: клиент заново создан, новый UUID: {remnawave_client_id}")
                 else:
-                    logger.error(f"[Update] Ошибка создания Remnawave клиента")
+                    logger.error("[Update] Ошибка создания Remnawave клиента")
             else:
-                logger.error(f"[Update] Не удалось авторизоваться в Remnawave")
+                logger.error("[Update] Не удалось авторизоваться в Remnawave")
 
         if not remnawave_client_id:
             logger.warning(f"[Update] Remnawave client_id не получен. Используется исходный: {client_id}")
@@ -441,12 +465,7 @@ async def update_key_on_cluster(tg_id, client_id, email, expiry_time, cluster_id
                 logger.warning(f"[Update] INBOUND_ID отсутствует для сервера {server_name}. Пропуск.")
                 continue
 
-            xui = AsyncApi(
-                server_info["api_url"],
-                username=ADMIN_USERNAME,
-                password=ADMIN_PASSWORD,
-                logger=logger,
-            )
+            xui = await get_xui_instance(server_info["api_url"])
 
             if SUPERNODE:
                 sub_id = email
@@ -509,9 +528,7 @@ async def update_subscription(tg_id: int, email: str, session: Any, cluster_over
     )
     new_cluster_id = cluster_override or await get_least_loaded_cluster()
 
-    new_client_id, remnawave_key = await update_key_on_cluster(
-        tg_id, client_id, email, expiry_time, new_cluster_id
-    )
+    new_client_id, remnawave_key = await update_key_on_cluster(tg_id, client_id, email, expiry_time, new_cluster_id)
 
     servers = await get_servers()
     cluster_servers = servers.get(new_cluster_id, [])
@@ -534,14 +551,7 @@ async def update_subscription(tg_id: int, email: str, session: Any, cluster_over
 async def get_user_traffic(session: Any, tg_id: int, email: str) -> dict[str, Any]:
     """
     Получает трафик пользователя на всех серверах, где у него есть ключ (3x-ui и Remnawave).
-
-    Args:
-        session (Any): Сессия базы данных.
-        tg_id (int): ID пользователя Telegram.
-        email (str): Email пользователя.
-
-    Returns:
-        dict[str, Any]: Структура с данными о трафике.
+    Для Remnawave трафик считается один раз и отображается как "Remnawave (общий):".
     """
     query = "SELECT client_id, server_id FROM keys WHERE tg_id = $1 AND email = $2"
     rows = await session.fetch(query, tg_id, email)
@@ -565,6 +575,10 @@ async def get_user_traffic(session: Any, tg_id: int, email: str) -> dict[str, An
     servers_map = {row["server_name"]: row for row in server_rows}
 
     user_traffic_data = {}
+    tasks = []
+
+    remnawave_client_id = None
+    remnawave_checked = False
 
     async def fetch_traffic(server_info: dict, client_id: str) -> tuple[str, Any]:
         server_name = server_info["server_name"]
@@ -573,8 +587,7 @@ async def get_user_traffic(session: Any, tg_id: int, email: str) -> dict[str, An
 
         try:
             if panel_type == "3x-ui":
-                xui = AsyncApi(api_url, username=ADMIN_USERNAME, password=ADMIN_PASSWORD, logger=logger)
-                await xui.login()
+                xui = await get_xui_instance(api_url)
                 traffic_info = await get_client_traffic(xui, client_id)
                 if traffic_info["status"] == "success" and traffic_info["traffic"]:
                     client_data = traffic_info["traffic"][0]
@@ -582,40 +595,49 @@ async def get_user_traffic(session: Any, tg_id: int, email: str) -> dict[str, An
                     return server_name, round(used_gb, 2)
                 else:
                     return server_name, "Ошибка получения трафика"
-
-            elif panel_type == "remnawave":
-                remna = RemnawaveAPI(api_url)
-                logged_in = await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD)
-                if not logged_in:
-                    return server_name, "Не удалось авторизоваться"
-
-                user_data = await remna.get_user_by_uuid(client_id)
-                if not user_data:
-                    return server_name, "Клиент не найден"
-
-                used_bytes = user_data.get("usedTrafficBytes", 0)
-                used_gb = used_bytes / 1073741824
-                return server_name, round(used_gb, 2)
-
             else:
                 return server_name, f"Неизвестная панель: {panel_type}"
-
         except Exception as e:
             return server_name, f"Ошибка: {e}"
 
-    tasks = []
     for row in rows:
         client_id = row["client_id"]
         server_id = row["server_id"]
 
-        matched_servers = [s for s in servers_map.values() if s["server_name"] == server_id or s["cluster_name"] == server_id]
+        matched_servers = [
+            s for s in servers_map.values() if s["server_name"] == server_id or s["cluster_name"] == server_id
+        ]
         for server_info in matched_servers:
-            tasks.append(fetch_traffic(server_info, client_id))
+            panel_type = server_info.get("panel_type", "3x-ui").lower()
+
+            if panel_type == "remnawave" and not remnawave_checked:
+                remnawave_client_id = client_id
+                remnawave_api_url = server_info["api_url"]
+                remnawave_checked = True
+            elif panel_type == "3x-ui":
+                tasks.append(fetch_traffic(server_info, client_id))
 
     results = await asyncio.gather(*tasks, return_exceptions=True)
+
     for server, result in results:
         user_traffic_data[server] = result
 
+    if remnawave_client_id:
+        try:
+            remna = RemnawaveAPI(remnawave_api_url)
+            if not await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
+                user_traffic_data["Remnawave (общий)"] = "Не удалось авторизоваться"
+            else:
+                user_data = await remna.get_user_by_uuid(remnawave_client_id)
+                if not user_data:
+                    user_traffic_data["Remnawave (общий)"] = "Клиент не найден"
+                else:
+                    used_bytes = user_data.get("usedTrafficBytes", 0)
+                    used_gb = round(used_bytes / 1073741824, 2)
+                    user_traffic_data["Remnawave (общий)"] = used_gb
+        except Exception as e:
+            user_traffic_data["Remnawave (общий)"] = f"Ошибка: {e}"
+
     return {"status": "success", "traffic": user_traffic_data}
 
 
@@ -652,12 +674,7 @@ async def toggle_client_on_cluster(cluster_id: str, email: str, client_id: str,
         tasks = []
 
         for server_info in cluster:
-            xui = AsyncApi(
-                server_info["api_url"],
-                username=ADMIN_USERNAME,
-                password=ADMIN_PASSWORD,
-                logger=logger,
-            )
+            xui = await get_xui_instance(server_info["api_url"])
 
             inbound_id = server_info.get("inbound_id")
             server_name = server_info.get("server_name", "unknown")
@@ -760,8 +777,7 @@ async def reset_traffic_in_cluster(cluster_id: str, email: str) -> None:
                     logger.warning(f"INBOUND_ID отсутствует для сервера {server_name}. Пропуск.")
                     continue
 
-                xui = AsyncApi(api_url, username=ADMIN_USERNAME, password=ADMIN_PASSWORD, logger=logger)
-                await xui.login()
+                xui = await get_xui_instance(api_url)
 
                 unique_email = f"{email}_{server_name.lower()}" if SUPERNODE else email
                 tasks.append(xui.client.reset_stats(int(inbound_id), unique_email))
@@ -773,4 +789,4 @@ async def reset_traffic_in_cluster(cluster_id: str, email: str) -> None:
 
     except Exception as e:
         logger.error(f"[Reset Traffic] Ошибка при сбросе трафика клиента {email} в кластере {cluster_id}: {e}")
-        raise
+        raise

handlers/keys/key_view.py

@@ -1,21 +1,22 @@
-from aiogram import F, Router
-from aiogram.types import CallbackQuery, Message, InlineKeyboardButton, WebAppInfo
-from aiogram.utils.keyboard import InlineKeyboardBuilder
-import pytz
 import html
 import os
 import re
+
 from datetime import datetime
-from aiogram.fsm.state import State, StatesGroup
 from typing import Any
 
+import pytz
+
+from aiogram import F, Router
 from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.types import CallbackQuery, InlineKeyboardButton, Message, WebAppInfo
+from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from config import (
     CONNECT_PHONE_BUTTON,
     ENABLE_DELETE_KEY_BUTTON,
     ENABLE_UPDATE_SUBSCRIPTION_BUTTON,
-    PUBLIC_LINK,
     QRCODE,
     TOGGLE_CLIENT,
     USE_COUNTRY_SELECTION,
@@ -46,12 +47,21 @@ from handlers.texts import (
     NO_SUBSCRIPTIONS_MSG,
     key_message,
 )
-from handlers.utils import edit_or_send_message, handle_error, is_full_remnawave_cluster
+from handlers.utils import (
+    edit_or_send_message,
+    format_days,
+    format_hours,
+    format_minutes,
+    get_russian_month,
+    handle_error,
+    is_full_remnawave_cluster,
+)
 from logger import logger
 
 
 router = Router()
 
+
 class RenameKeyState(StatesGroup):
     waiting_for_new_alias = State()
 
@@ -129,7 +139,7 @@ async def handle_rename_key(callback: CallbackQuery, state: FSMContext):
     await edit_or_send_message(
         target_message=callback.message,
         text="✏️ Введите новое имя подписки (до 10 символов):",
-        reply_markup=builder.as_markup()
+        reply_markup=builder.as_markup(),
     )
 
 
@@ -142,7 +152,9 @@ async def handle_new_alias_input(message: Message, state: FSMContext, session: A
         return
 
     if not alias or not re.match(r"^[a-zA-Zа-яА-ЯёЁ0-9@._-]+$", alias):
-        await message.answer("❌ Введены недопустимые символы или имя пустое. Используйте только буквы, цифры и @._-\nПовторите ввод.")
+        await message.answer(
+            "❌ Введены недопустимые символы или имя пустое. Используйте только буквы, цифры и @._-\nПовторите ввод."
+        )
         return
 
     data = await state.get_data()
@@ -210,15 +222,17 @@ async def process_callback_view_key(callback_query: CallbackQuery, session: Any)
         time_left = expiry_date - datetime.utcnow()
 
         if time_left.total_seconds() <= 0:
-            days_left_message = "<b>🕒 Статус подписки:</b>\n🔴 Истекла\nОсталось часов: 0\nОсталось минут: 0"
+            days_left_message = "<b>🕒 Статус подписки:</b>\n🔴 Истекла"
         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> минут"
+            days_left_message = (
+                f"Осталось: <b>{format_days(days)}</b>, <b>{format_hours(hours)}</b>, <b>{format_minutes(minutes)}</b>"
+            )
 
-        formatted_expiry_date = expiry_date.strftime("%d %B %Y года")
+        formatted_expiry_date = f"{expiry_date.strftime('%d')} {get_russian_month(expiry_date)} {expiry_date.strftime('%Y')} года"
         response_message = key_message(
             final_link,
             formatted_expiry_date,
@@ -227,7 +241,7 @@ async def process_callback_view_key(callback_query: CallbackQuery, session: Any)
             server_name if USE_COUNTRY_SELECTION else None,
         )
 
-        if (not key or not key.startswith(PUBLIC_LINK)) or ENABLE_UPDATE_SUBSCRIPTION_BUTTON:
+        if ENABLE_UPDATE_SUBSCRIPTION_BUTTON:
             builder.row(
                 InlineKeyboardButton(
                     text="🔄 Обновить подписку",
@@ -303,4 +317,4 @@ async def process_callback_view_key(callback_query: CallbackQuery, session: Any)
             tg_id,
             callback_query,
             f"Ошибка при получении информации о ключе: {e}",
-        )
+        )

handlers/keys/keys.py

@@ -4,7 +4,6 @@ from typing import Any
 
 from aiogram import F, Router, types
 from aiogram.exceptions import TelegramBadRequest
-
 from aiogram.types import CallbackQuery
 
 from database import (
@@ -17,11 +16,11 @@ from handlers.buttons import (
     BACK,
     CANCEL,
 )
-from handlers.keys.key_view import process_callback_view_key
 from handlers.keys.key_utils import (
     delete_key_from_cluster,
     update_subscription,
 )
+from handlers.keys.key_view import process_callback_view_key
 from handlers.texts import (
     DELETE_KEY_CONFIRM_MSG,
     KEY_DELETED_MSG_SIMPLE,

handlers/keys/subscriptions.py

@@ -5,11 +5,8 @@ import re
 import time
 import urllib.parse
 
-from datetime import datetime
-
 import aiohttp
 import asyncpg
-import pytz
 
 from aiohttp import web
 
@@ -19,7 +16,6 @@ from config import (
     SUPERNODE,
     SUPPORT_CHAT_URL,
     TOTAL_GB,
-    TRANSITION_DATE_STR,
     USERNAME_BOT,
     USE_COUNTRY_SELECTION,
 )
@@ -29,76 +25,37 @@ 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 []
+    except Exception:
         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, return_exceptions=True)
     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, include_remnawave_key: str = None) -> list[str]:
     urls = []
     if USE_COUNTRY_SELECTION:
-        logger.info(f"[Sub] Страна-режим активен. Ищем сервер {server_id}.")
         server_data = await conn.fetchrow("SELECT subscription_url FROM servers WHERE server_name = $1", server_id)
         if server_data and server_data["subscription_url"]:
             urls.append(f"{server_data['subscription_url']}/{email}")
@@ -111,54 +68,24 @@ async def get_subscription_urls(server_id: str, email: str, conn, include_remnaw
 
     if include_remnawave_key:
         urls.append(include_remnawave_key)
-        logger.info(f"[Sub] Добавлена Remnawave ссылка: {include_remnawave_key}")
 
-    logger.info(f"[Sub] Список URL подписок: {urls}")
     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)
@@ -167,89 +94,50 @@ def calculate_traffic(cleaned_subscriptions: list[str], expiry_time_ms: int | No
                     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} | Поддержка↗️"
@@ -266,13 +154,23 @@ def prepare_headers(
     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,
         }
+    elif "v2raytun" in user_agent:
+        encoded_project_name = f"{project_name}\n{subscription_info}"
+        announce_str = "🔑 Выберите сервер ⬇️ | 💬 Поддержка ➡️"
+        return {
+            "Content-Type": "text/plain; charset=utf-8",
+            "Content-Disposition": "inline",
+            "update-always": "true",
+            "announce": "base64:" + base64.b64encode(announce_str.encode("utf-8")).decode("utf-8"),
+            "announce-url": f"{SUPPORT_CHAT_URL}",
+            "profile-title": "base64:" + base64.b64encode(encoded_project_name.encode("utf-8")).decode("utf-8"),
+        }
     else:
         encoded_project_name = f"{project_name}\n{subscription_info}"
         return {
@@ -283,65 +181,36 @@ def prepare_headers(
         }
 
 
-async def handle_subscription(request: web.Request, old_subscription: bool = False) -> web.Response:
-    """
-    Обрабатывает запрос на подписку (старую или новую).
-
-    Args:
-        request: Объект запроса
-        old_subscription: Флаг, указывающий на тип подписки (старая или новая)
-
-    Returns:
-        Ответ с подпиской или сообщением об ошибке
-    """
+async def handle_subscription(request: web.Request) -> web.Response:
     email = request.match_info.get("email")
-    tg_id = request.match_info.get("tg_id") if not old_subscription else None
+    tg_id = request.match_info.get("tg_id")
 
-    if not email or (not old_subscription and not tg_id):
-        logger.warning("Получен запрос с отсутствующими параметрами")
+    if not email or not tg_id:
         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 int(tg_id) != int(stored_tg_id):
-            logger.warning(f"Неверный tg_id для клиента с email {email}.")
+        if int(tg_id) != int(stored_tg_id):
             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, include_remnawave_key=client_data.get("remnawave_link")
-)
+            server_id, email, conn, include_remnawave_key=client_data.get("remnawave_link")
+        )
 
         if not urls:
             return web.Response(text="❌ Сервер не найден.", status=404)
 
-        query_string = request.query_string if not old_subscription else ""
+        query_string = request.query_string
         combined_subscriptions = await combine_unique_lines(urls, tg_id or email, query_string)
         random.shuffle(combined_subscriptions)
 
@@ -354,17 +223,6 @@ async def handle_subscription(request: web.Request, old_subscription: bool = Fal
         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/general_notifications.py

@@ -23,13 +23,14 @@ from config import (
 from database import (
     add_notification,
     check_notification_time,
+    check_notifications_bulk,
     delete_key,
+    delete_notification,
     get_all_keys,
     get_balance,
     get_last_notification_time,
     update_balance,
     update_key_expiry,
-    delete_notification
 )
 from handlers.keys.key_utils import delete_key_from_cluster, renew_key_in_cluster
 from handlers.notifications.notify_kb import build_notification_expired_kb, build_notification_kb
@@ -44,10 +45,11 @@ from handlers.texts import (
     KEY_RENEWED,
     KEY_RENEWED_TEMP_MSG,
 )
+from handlers.utils import format_hours, format_minutes
 from logger import logger
 from handlers.utils import format_hours, format_months, format_minutes
 
-from .notify_utils import send_notification
+from .notify_utils import send_messages_with_limit, send_notification
 from .special_notifications import notify_inactive_trial_users, notify_users_no_traffic
 
 
@@ -115,6 +117,9 @@ async def periodic_notifications(bot: Bot):
 
 
 async def notify_24h_keys(bot: Bot, conn: asyncpg.Connection, current_time: int, threshold_time_24h: int, keys: list):
+    """
+    Отправляет уведомления пользователям о том, что их подписка истекает через 24 часа.
+    """
     logger.info("Начало проверки подписок, истекающих через 24 часа.")
 
     expiring_keys = [
@@ -122,26 +127,29 @@ async def notify_24h_keys(bot: Bot, conn: asyncpg.Connection, current_time: int,
     ]
     logger.info(f"Найдено {len(expiring_keys)} подписок, истекающих через 24 часа.")
 
+    tg_ids = [key["tg_id"] for key in expiring_keys]
+    emails = [key.get("email", "") for key in expiring_keys]
+
+    users = await check_notifications_bulk("key_24h", 24, conn, tg_ids=tg_ids, emails=emails)
+    messages = []
+
     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
-
+        can_notify = await check_notification_time(tg_id, notification_id, hours=24, session=conn)
         if not can_notify:
             continue
 
+        user = next((u for u in users if u["tg_id"] == tg_id and u["email"] == email), None)
+        if not user:
+            continue
+
+        expiry_timestamp = key.get("expiry_time")
         hours_left = int((expiry_timestamp - current_time) / (1000 * 3600))
         hours_left_formatted = (
-            f"⏳ Осталось времени: {format_hours(hours_left)}" 
-            if hours_left > 0 
-            else "⏳ Последний день подписки!"
+            f"⏳ Осталось времени: {format_hours(hours_left)}" if hours_left > 0 else "⏳ Последний день подписки!"
         )
 
         expiry_datetime = datetime.fromtimestamp(expiry_timestamp / 1000, tz=moscow_tz)
@@ -157,12 +165,17 @@ async def notify_24h_keys(bot: Bot, conn: asyncpg.Connection, current_time: int,
             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}")
+            messages.append({
+                "tg_id": tg_id,
+                "text": notification_text,
+                "photo": "notify_24h.jpg",
+                "keyboard": keyboard,
+            })
+            await add_notification(tg_id, notification_id, session=conn)
+
+    if messages:
+        await send_messages_with_limit(bot, messages)
+        logger.info(f"Отправлено {len(messages)} уведомлений об истечении подписки через 24 часа.")
 
     logger.info("Обработка всех уведомлений за 24 часа завершена.")
     await asyncio.sleep(1)
@@ -179,26 +192,29 @@ async def notify_10h_keys(bot: Bot, conn: asyncpg.Connection, current_time: int,
     ]
     logger.info(f"Найдено {len(expiring_keys)} подписок, истекающих через 10 часов.")
 
+    tg_ids = [key["tg_id"] for key in expiring_keys]
+    emails = [key.get("email", "") for key in expiring_keys]
+
+    users = await check_notifications_bulk("key_10h", 10, conn, tg_ids=tg_ids, emails=emails)
+    messages = []
+
     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
-
+        can_notify = await check_notification_time(tg_id, notification_id, hours=10, session=conn)
         if not can_notify:
             continue
 
+        user = next((u for u in users if u["tg_id"] == tg_id and u["email"] == email), None)
+        if not user:
+            continue
+
+        expiry_timestamp = key.get("expiry_time")
         hours_left = int((expiry_timestamp - current_time) / (1000 * 3600))
         hours_left_formatted = (
-            f"⏳ Осталось времени: {format_hours(hours_left)}" 
-            if hours_left > 0 
-            else "⏳ Последний день подписки!"
+            f"⏳ Осталось времени: {format_hours(hours_left)}" if hours_left > 0 else "⏳ Последний день подписки!"
         )
 
         expiry_datetime = datetime.fromtimestamp(expiry_timestamp / 1000, tz=moscow_tz)
@@ -219,12 +235,17 @@ async def notify_10h_keys(bot: Bot, conn: asyncpg.Connection, current_time: int,
                 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}")
+            messages.append({
+                "tg_id": tg_id,
+                "text": notification_text,
+                "photo": "notify_10h.jpg",
+                "keyboard": keyboard,
+            })
+            await add_notification(tg_id, notification_id, session=conn)
+
+    if messages:
+        await send_messages_with_limit(bot, messages)
+        logger.info(f"Отправлено {len(messages)} уведомлений об истечении подписки через 10 часов.")
 
     logger.info("Обработка всех уведомлений за 10 часов завершена.")
     await asyncio.sleep(1)
@@ -239,6 +260,12 @@ async def handle_expired_keys(bot: Bot, conn: asyncpg.Connection, current_time:
     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)} истекших ключей.")
 
+    tg_ids = [key["tg_id"] for key in expired_keys]
+    emails = [key.get("email", "") for key in expired_keys]
+
+    users = await check_notifications_bulk("key_expired", 0, conn, tg_ids=tg_ids, emails=emails)
+    messages = []
+
     for key in expired_keys:
         tg_id = key["tg_id"]
         email = key.get("email", "")
@@ -246,11 +273,7 @@ async def handle_expired_keys(bot: Bot, conn: asyncpg.Connection, current_time:
         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
+        last_notification_time = await get_last_notification_time(tg_id, notification_id, session=conn)
 
         if NOTIFY_RENEW_EXPIRED:
             try:
@@ -289,22 +312,17 @@ async def handle_expired_keys(bot: Bot, conn: asyncpg.Connection, current_time:
                     logger.info(f"🗑 Ключ {client_id} для пользователя {tg_id} успешно удалён.")
 
                     keyboard = build_notification_expired_kb()
-                    try:
-                        await send_notification(
-                            bot,
-                            tg_id,
-                            "notify_expired.jpg",
-                            KEY_DELETED_MSG.format(email=email),
-                            keyboard,
-                        )
-                        logger.info(f"Отправлено уведомление об удалении подписки {email} пользователю {tg_id}.")
-                    except Exception as e:
-                        logger.error(f"Не удалось отправить уведомление об удалении пользователю {tg_id}: {e}")
+                    messages.append({
+                        "tg_id": tg_id,
+                        "text": KEY_DELETED_MSG.format(email=email),
+                        "photo": "notify_expired.jpg",
+                        "keyboard": keyboard,
+                    })
                 except Exception as e:
                     logger.error(f"Ошибка удаления ключа {client_id} для пользователя {tg_id}: {e}")
                 continue
 
-        if last_notification_time is None:
+        if last_notification_time is None and any(u["tg_id"] == tg_id and u["email"] == email for u in users):
             keyboard = build_notification_kb(email)
 
             if NOTIFY_DELETE_DELAY > 0:
@@ -313,53 +331,38 @@ async def handle_expired_keys(bot: Bot, conn: asyncpg.Connection, current_time:
 
                 if hours > 0:
                     if minutes > 0:
-                        time_left_formatted = f"{format_hours(hours)} и {format_minutes(minutes)}"
                         delay_message = KEY_EXPIRED_DELAY_HOURS_MINUTES_MSG.format(
-                            email=email,
-                            time_left_formatted=time_left_formatted
+                            email=email, hours_formatted=format_hours(hours), minutes_formatted=format_minutes(minutes)
                         )
                     else:
-                        time_left_formatted = format_hours(hours)
                         delay_message = KEY_EXPIRED_DELAY_HOURS_MSG.format(
-                            email=email,
-                            time_left_formatted=time_left_formatted
+                            email=email, hours_formatted=format_hours(hours)
                         )
                 else:
-                    minutes_formatted = format_minutes(minutes)
                     delay_message = KEY_EXPIRED_DELAY_MINUTES_MSG.format(
-                        email=email,
-                        minutes_formatted=minutes_formatted
+                        email=email, minutes_formatted=format_minutes(minutes)
                     )
             else:
                 delay_message = KEY_EXPIRED_NO_DELAY_MSG.format(email=email)
 
-            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}")
+            messages.append({
+                "tg_id": tg_id,
+                "text": delay_message,
+                "photo": "notify_expired.jpg",
+                "keyboard": keyboard,
+            })
+            await add_notification(tg_id, notification_id, session=conn)
+
+    if messages:
+        await send_messages_with_limit(bot, messages)
+        logger.info(f"Отправлено {len(messages)} уведомлений об истекших ключах.")
 
     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
+    bot, conn, key: dict, notification_id: str, renewal_period_months: int, standard_photo: str, standard_caption: str
 ):
     """
     Если баланс пользователя позволяет, продлевает ключ на максимальный возможный срок и списывает средства;
@@ -398,14 +401,14 @@ async def process_auto_renew_or_notify(
         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")
-        months_formatted = format_months(renewal_period_months)
+        total_gb = int(renewal_period_months * TOTAL_GB * 1024**3)
 
         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 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)
 
@@ -423,13 +426,22 @@ async def process_auto_renew_or_notify(
             )
 
             keyboard = build_notification_expired_kb()
-            await send_notification(bot, tg_id, "notify_expired.jpg", renewed_message, keyboard)
+            result = await send_notification(bot, tg_id, "notify_expired.jpg", renewed_message, keyboard)
+            if result:
+                logger.info(f"✅ Уведомление о продлении подписки {email} отправлено пользователю {tg_id}.")
+            else:
+                logger.warning(
+                    f"📢 Не удалось отправить уведомление о продлении подписки {email} пользователю {tg_id}."
+                )
         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)
+        result = await send_notification(bot, tg_id, standard_photo, standard_caption, keyboard)
+        if result:
+            logger.info(f"📢 Отправлено уведомление об истекающей подписке {email} пользователю {tg_id}.")
+            await add_notification(tg_id, notification_id, session=conn)
+        else:
+            logger.warning(f"📢 Не удалось отправить уведомление об истекающей подписке {email} пользователю {tg_id}.")

handlers/notifications/notify_utils.py

@@ -10,6 +10,23 @@ from aiogram.types import BufferedInputFile, InlineKeyboardMarkup
 from logger import logger
 
 
+async def send_messages_with_limit(bot: Bot, messages: list[dict], messages_per_second: int = 25):
+    """
+    Отправляет сообщения с ограничением по количеству сообщений в секунду.
+    """
+    batch_size = messages_per_second
+    for i in range(0, len(messages), batch_size):
+        batch = messages[i : i + batch_size]
+        tasks = []
+        for msg in batch:
+            tasks.append(send_notification(bot, msg["tg_id"], msg.get("photo"), msg["text"], msg.get("keyboard")))
+        try:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        except Exception as e:
+            logger.error(f"⚠ Ошибка при отправке сообщений в батче: {e}")
+        await asyncio.sleep(1.0)
+
+
 def rate_limited_send(func):
     async def wrapper(*args, **kwargs):
         while True:
@@ -34,25 +51,17 @@ def rate_limited_send(func):
 async def send_notification(
     bot: Bot,
     tg_id: int,
-    image_filename: str,
+    image_filename: str | None,
     caption: str,
     keyboard: InlineKeyboardMarkup | None = None,
 ) -> bool:
     """
     Отправляет уведомление пользователю.
-
-    Args:
-        bot: Экземпляр бота для отправки сообщений
-        tg_id: Telegram ID пользователя
-        image_filename: Имя файла изображения в директории img
-        caption: Текст сообщения
-        keyboard: Клавиатура для сообщения (опционально)
-
-    Returns:
-        bool: True если сообщение успешно отправлено, False в случае ошибки
     """
-    photo_path = os.path.join("img", image_filename)
+    if image_filename is None:
+        return await _send_text_notification(bot, tg_id, caption, keyboard)
 
+    photo_path = os.path.join("img", image_filename)
     if os.path.isfile(photo_path):
         return await _send_photo_notification(bot, tg_id, photo_path, image_filename, caption, keyboard)
     else:

handlers/notifications/special_notifications.py

@@ -12,15 +12,18 @@ 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,
+    check_notifications_bulk,
     create_blocked_user,
 )
 from handlers.buttons import MAIN_MENU
 from handlers.keys.key_utils import get_user_traffic
 from handlers.texts import TRIAL_INACTIVE_BONUS_MSG, TRIAL_INACTIVE_FIRST_MSG, ZERO_TRAFFIC_MSG
+from handlers.utils import format_days
 from logger import logger
 from handlers.utils import format_days
 
+from .notify_utils import send_messages_with_limit, send_notification
+
 
 router = Router()
 
@@ -35,87 +38,53 @@ async def notify_inactive_trial_users(bot: Bot, conn: asyncpg.Connection):
     """
     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)} неактивных пользователей.")
+    users = await check_notifications_bulk("inactive_trial", NOTIFY_INACTIVE, conn)
+    logger.info(f"Найдено {len(users)} неактивных пользователей для уведомления.")
 
-    for user in inactive_trial_users:
+    messages = []
+
+    for user in 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)
+        builder = InlineKeyboardBuilder()
+        builder.row(
+            types.InlineKeyboardButton(
+                text="🚀 Активировать пробный период",
+                callback_data="create_key",
+            )
+        )
+        builder.row(types.InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+        keyboard = builder.as_markup()
 
-            if can_notify:
-                builder = InlineKeyboardBuilder()
-                builder.row(
-                    types.InlineKeyboardButton(
-                        text="🚀 Активировать пробный период",
-                        callback_data="create_key",
-                    )
-                )
-                builder.row(types.InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-                keyboard = builder.as_markup()
+        trial_extended = user["last_notification_time"] is not None
 
-                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:
+            total_days = NOTIFY_EXTRA_DAYS + TRIAL_TIME
+            message = TRIAL_INACTIVE_BONUS_MSG.format(
+                display_name=display_name,
+                extra_days_formatted=format_days(NOTIFY_EXTRA_DAYS),
+                total_days_formatted=format_days(total_days),
+            )
+            await conn.execute("UPDATE users SET trial = -1 WHERE tg_id = $1", tg_id)
+        else:
+            message = TRIAL_INACTIVE_FIRST_MSG.format(
+                display_name=display_name, trial_time_formatted=format_days(TRIAL_TIME)
+            )
 
-                if trial_extended:
-                    total_days = NOTIFY_EXTRA_DAYS + TRIAL_TIME
-                    trial_time_formatted = format_days(TRIAL_TIME)
-                    extra_days_formatted = format_days(NOTIFY_EXTRA_DAYS)
-                    total_days_formatted = format_days(total_days)
-                    message = TRIAL_INACTIVE_BONUS_MSG.format(
-                        display_name=display_name,
-                        extra_days_formatted=extra_days_formatted,
-                        total_days_formatted=total_days_formatted,
-                    )
-                    await conn.execute("UPDATE connections SET trial = -1 WHERE tg_id = $1", tg_id)
-                else:
-                    trial_time_formatted = format_days(TRIAL_TIME)
-                    message = TRIAL_INACTIVE_FIRST_MSG.format(
-                        display_name=display_name,
-                        trial_time_formatted=trial_time_formatted,
-                    )
+        messages.append({
+            "tg_id": tg_id,
+            "text": message,
+            "keyboard": keyboard,
+        })
+        await add_notification(tg_id, "inactive_trial", session=conn)
 
-                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)
+    if messages:
+        await send_messages_with_limit(bot, messages)
+        logger.info(f"Отправлено {len(messages)} уведомлений неактивным пользователям.")
 
     logger.info("✅ Проверка пользователей с неактивным пробным периодом завершена.")
 
@@ -185,11 +154,14 @@ async def notify_users_no_traffic(bot: Bot, conn: asyncpg.Connection, current_ti
             message = ZERO_TRAFFIC_MSG.format(email=email)
 
             try:
-                await bot.send_message(tg_id, message, reply_markup=keyboard)
-                logger.info(f"📩 Отправлено уведомление пользователю {tg_id} о нулевом трафике.")
+                result = await send_notification(bot, tg_id, None, message, keyboard)
                 await conn.execute(
                     "UPDATE keys SET notified = TRUE WHERE tg_id = $1 AND client_id = $2", tg_id, client_id
                 )
+                if result:
+                    logger.info(f"📩 Отправлено уведомление пользователю {tg_id} о нулевом трафике.")
+                else:
+                    logger.warning(f"📩 Не удалось отправить уведомление пользователю {tg_id} о нулевом трафике.")
             except TelegramForbiddenError:
                 logger.warning(f"🚫 Бот заблокирован пользователем {tg_id}.")
                 await create_blocked_user(tg_id, conn)

handlers/pay.py

@@ -1,3 +1,7 @@
+import os
+
+from typing import Any
+
 from aiogram import F, Router
 from aiogram.types import CallbackQuery, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
@@ -10,8 +14,19 @@ from config import (
     YOOKASSA_ENABLE,
     YOOMONEY_ENABLE,
 )
-from handlers.buttons import CRYPTOBOT, MAIN_MENU, ROBOKASSA, STARS, YOOKASSA, YOOMONEY
-from handlers.texts import PAYMENT_METHODS_MSG
+from database import get_last_payments
+from handlers.buttons import (
+    BALANCE_HISTORY,
+    COUPON,
+    CRYPTOBOT,
+    MAIN_MENU,
+    PAYMENT,
+    ROBOKASSA,
+    STARS,
+    YOOKASSA,
+    YOOMONEY,
+)
+from handlers.texts import BALANCE_HISTORY_HEADER, BALANCE_MANAGEMENT_TEXT, PAYMENT_METHODS_MSG
 
 from .utils import edit_or_send_message
 
@@ -69,3 +84,63 @@ async def handle_pay(callback_query: CallbackQuery):
         media_path=None,
         disable_web_page_preview=False,
     )
+
+
+@router.callback_query(F.data == "balance")
+async def balance_handler(callback_query: CallbackQuery, session: Any):
+    result = await session.fetchrow(
+        "SELECT balance FROM users WHERE tg_id = $1",
+        callback_query.from_user.id,
+    )
+    balance = result["balance"] if result else 0.0
+    balance = int(balance)
+
+    builder = InlineKeyboardBuilder()
+    builder.row(InlineKeyboardButton(text=PAYMENT, callback_data="pay"))
+    builder.row(InlineKeyboardButton(text=BALANCE_HISTORY, callback_data="balance_history"))
+    builder.row(InlineKeyboardButton(text=COUPON, callback_data="activate_coupon"))
+    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+    text = BALANCE_MANAGEMENT_TEXT.format(balance=balance)
+    image_path = os.path.join("img", "pic.jpg")
+
+    await edit_or_send_message(
+        target_message=callback_query.message,
+        text=text,
+        reply_markup=builder.as_markup(),
+        media_path=image_path,
+        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 = BALANCE_HISTORY_HEADER
+        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,
+    )

handlers/payments/robokassa_pay.py

@@ -19,9 +19,9 @@ from config import (
 from robokassa import HashAlgorithm, Robokassa
 
 from database import (
-    add_connection,
+    add_user,
+    check_user_exists,
     add_payment,
-    check_connection_exists,
     get_key_count,
     get_temporary_data,
     update_balance,
@@ -96,10 +96,20 @@ async def process_callback_pay_robokassa(callback_query: types.CallbackQuery, st
     key_count = await get_key_count(tg_id)
 
     if key_count == 0:
-        exists = await check_connection_exists(tg_id)
+        exists = await check_user_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.")
+            from_user = callback_query.from_user
+            await add_user(
+                tg_id=from_user.id,
+                username=from_user.username,
+                first_name=from_user.first_name,
+                last_name=from_user.last_name,
+                language_code=from_user.language_code,
+                is_bot=from_user.is_bot,
+                session=session,
+            )
+            logger.info(f"[DB] Новый пользователь {tg_id} создан через Robokassa.")
+
 
     await callback_query.message.delete()
     

handlers/profile.py

@@ -1,63 +1,42 @@
 import html
-from io import BytesIO
 import os
 
 import asyncpg
-import qrcode
-
-from typing import Any
 
 from aiogram import F, Router
-from aiogram.enums import ParseMode
 from aiogram.fsm.context import FSMContext
 from aiogram.types import (
     CallbackQuery,
     InlineKeyboardButton,
-    InlineQuery,
-    InlineQueryResultArticle,
-    InputTextMessageContent,
     Message,
 )
 from aiogram.utils.keyboard import InlineKeyboardBuilder
 
 from config import (
-    ADMIN_ID,
     DATABASE_URL,
     GIFT_BUTTON,
-    INLINE_MODE,
     INSTRUCTIONS_BUTTON,
     NEWS_MESSAGE,
     REFERRAL_BUTTON,
-    REFERRAL_OFFERS,
     SHOW_START_MENU_ONCE,
-    TOP_REFERRAL_BUTTON,
-    TRIAL_TIME,
-    USERNAME_BOT,
 )
-from database import get_balance, get_key_count, get_last_payments, get_referral_stats, get_trial
+from database import get_balance, get_key_count, get_trial
 from handlers.buttons import (
     ABOUT_VPN,
     ADD_SUB,
     BACK,
     BALANCE,
-    BALANCE_HISTORY,
-    COUPON,
     GIFTS,
     INSTRUCTIONS,
     INVITE,
-    MAIN_MENU,
     MY_SUBS,
-    PAYMENT,
-    QR,
-    TOP_FIVE,
-    TRIAL_SUB
+    TRIAL_SUB,
 )
-from handlers.texts import BALANCE_HISTORY_HEADER, BALANCE_MANAGEMENT_TEXT, INVITE_TEXT_NON_INLINE, TOP_REFERRALS_TEXT
 from logger import logger
 
 from .admin.panel.keyboard import AdminPanelCallback
-from .texts import get_referral_link, invite_message_send, profile_message_send
-from .utils import edit_or_send_message, format_days
+from .texts import profile_message_send
+from .utils import edit_or_send_message
 
 
 router = Router()
@@ -148,224 +127,3 @@ async def process_callback_view_profile(
         )
     finally:
         await conn.close()
-
-
-@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
-    balance = int(balance)
-
-    builder = InlineKeyboardBuilder()
-    builder.row(InlineKeyboardButton(text=PAYMENT, callback_data="pay"))
-    builder.row(InlineKeyboardButton(text=BALANCE_HISTORY, callback_data="balance_history"))
-    builder.row(InlineKeyboardButton(text=COUPON, callback_data="activate_coupon"))
-    builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-
-    text = BALANCE_MANAGEMENT_TEXT.format(balance=balance)
-    image_path = os.path.join("img", "pic.jpg")
-
-    await edit_or_send_message(
-        target_message=callback_query.message,
-        text=text,
-        reply_markup=builder.as_markup(),
-        media_path=image_path,
-        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 = BALANCE_HISTORY_HEADER
-        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.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=INVITE, switch_inline_query="invite")
-    else:
-        invite_text = INVITE_TEXT_NON_INLINE.format(referral_link=referral_link)
-        builder.button(text=INVITE, switch_inline_query=invite_text)
-    builder.button(text=QR, callback_data=f"show_referral_qr|{chat_id}")
-    if TOP_REFERRAL_BUTTON:
-        builder.button(text=TOP_FIVE, callback_data="top_referrals")
-    builder.button(text=MAIN_MENU, 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}"
-    trial_time_formatted = format_days(TRIAL_TIME)
-    results: list[InlineQueryResultArticle] = []
-
-    for index, offer in enumerate(REFERRAL_OFFERS):
-        description = offer["description"][:64]
-        message_text = offer["message"].format(trial_time=TRIAL_TIME, trial_time_formatted=trial_time_formatted)[: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)
-
-
-@router.callback_query(F.data.startswith("show_referral_qr|"))
-async def show_referral_qr(callback_query: CallbackQuery):
-    try:
-        chat_id = callback_query.data.split("|")[1]
-        referral_link = get_referral_link(chat_id)
-
-        qr = qrcode.QRCode(version=1, box_size=10, border=4)
-        qr.add_data(referral_link)
-        qr.make(fit=True)
-
-        img = qr.make_image(fill_color="black", back_color="white")
-        buffer = BytesIO()
-        img.save(buffer, format="PNG")
-        buffer.seek(0)
-
-        qr_path = f"/tmp/qrcode_referral_{chat_id}.png"
-        with open(qr_path, "wb") as f:
-            f.write(buffer.read())
-
-        builder = InlineKeyboardBuilder()
-        builder.row(InlineKeyboardButton(text=BACK, callback_data="invite"))
-        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-
-        await edit_or_send_message(
-            target_message=callback_query.message,
-            text="📷 <b>Ваш QR-код для реферальной ссылки.</b>",
-            reply_markup=builder.as_markup(),
-            media_path=qr_path,
-        )
-
-        os.remove(qr_path)
-
-    except Exception as e:
-        logger.error(f"Ошибка при генерации QR-кода для реферальной ссылки: {e}", exc_info=True)
-        await callback_query.message.answer("❌ Произошла ошибка при создании QR-кода.")
-        
-
-@router.callback_query(F.data == "top_referrals")
-async def top_referrals_handler(callback_query: CallbackQuery):
-    conn = await asyncpg.connect(DATABASE_URL)
-    try:
-        user_referral_count = await conn.fetchval(
-            "SELECT COUNT(*) FROM referrals WHERE referrer_tg_id = $1",
-            callback_query.from_user.id
-        ) or 0
-
-        personal_block = "Твоё место в рейтинге:\n"
-        if user_referral_count > 0:
-            user_position = await conn.fetchval(
-                """
-                SELECT COUNT(*) + 1 FROM (
-                    SELECT COUNT(*) as cnt 
-                    FROM referrals 
-                    GROUP BY referrer_tg_id 
-                    HAVING COUNT(*) > $1
-                ) AS better_users
-                """,
-                user_referral_count
-            )
-            personal_block += f"{user_position}. {callback_query.from_user.id} - {user_referral_count} чел."
-        else:
-            personal_block += "Ты еще не приглашал пользователей в проект."
-
-        top_referrals = await conn.fetch(
-            """
-            SELECT referrer_tg_id, COUNT(*) as referral_count
-            FROM referrals
-            GROUP BY referrer_tg_id
-            ORDER BY referral_count DESC
-            LIMIT 5
-            """
-        )
-
-        is_admin = callback_query.from_user.id in ADMIN_ID
-        rows = ""
-        for i, row in enumerate(top_referrals, 1):
-            tg_id = str(row["referrer_tg_id"])
-            count = row["referral_count"]
-            display_id = tg_id if is_admin else f"{tg_id[:5]}*****"
-            rows += f"{i}. {display_id} - {count} чел.\n"
-
-        text = TOP_REFERRALS_TEXT.format(personal_block=personal_block, rows=rows)
-
-        builder = InlineKeyboardBuilder()
-        builder.row(InlineKeyboardButton(text=BACK, callback_data="invite"))
-        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
-
-        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,
-        )
-    finally:
-        await conn.close()

handlers/refferal.py

@@ -0,0 +1,261 @@
+import os
+
+from io import BytesIO
+from typing import Any
+
+import asyncpg
+import qrcode
+
+from aiogram import F, Router
+from aiogram.enums import ParseMode
+from aiogram.fsm.context import FSMContext
+from aiogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineQuery,
+    InlineQueryResultArticle,
+    InputTextMessageContent,
+    Message,
+)
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from bot import bot
+from config import (
+    ADMIN_ID,
+    DATABASE_URL,
+    INLINE_MODE,
+    TOP_REFERRAL_BUTTON,
+    TRIAL_TIME,
+    USERNAME_BOT,
+)
+from database import add_referral, add_user, check_user_exists, get_referral_by_referred_id, get_referral_stats
+from handlers.buttons import (
+    BACK,
+    INVITE,
+    MAIN_MENU,
+    QR,
+    TOP_FIVE,
+)
+from handlers.texts import (
+    INVITE_TEXT_NON_INLINE,
+    NEW_REFERRAL_NOTIFICATION,
+    REFERRAL_OFFERS,
+    REFERRAL_SUCCESS_MSG,
+    TOP_REFERRALS_TEXT,
+)
+from logger import logger
+
+from .texts import get_referral_link, invite_message_send
+from .utils import edit_or_send_message, format_days
+
+
+router = Router()
+
+
+@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=INVITE, switch_inline_query="invite")
+    else:
+        invite_text = INVITE_TEXT_NON_INLINE.format(referral_link=referral_link)
+        builder.button(text=INVITE, switch_inline_query=invite_text)
+    builder.button(text=QR, callback_data=f"show_referral_qr|{chat_id}")
+    if TOP_REFERRAL_BUTTON:
+        builder.button(text=TOP_FIVE, callback_data="top_referrals")
+    builder.button(text=MAIN_MENU, 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}"
+    trial_time_formatted = format_days(TRIAL_TIME)
+    results: list[InlineQueryResultArticle] = []
+
+    for index, offer in enumerate(REFERRAL_OFFERS):
+        description = offer["description"][:64]
+        message_text = offer["message"].format(trial_time=TRIAL_TIME, trial_time_formatted=trial_time_formatted)[: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)
+
+
+@router.callback_query(F.data.startswith("show_referral_qr|"))
+async def show_referral_qr(callback_query: CallbackQuery):
+    try:
+        chat_id = callback_query.data.split("|")[1]
+        referral_link = get_referral_link(chat_id)
+
+        qr = qrcode.QRCode(version=1, box_size=10, border=4)
+        qr.add_data(referral_link)
+        qr.make(fit=True)
+
+        img = qr.make_image(fill_color="black", back_color="white")
+        buffer = BytesIO()
+        img.save(buffer, format="PNG")
+        buffer.seek(0)
+
+        qr_path = f"/tmp/qrcode_referral_{chat_id}.png"
+        with open(qr_path, "wb") as f:
+            f.write(buffer.read())
+
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=BACK, callback_data="invite"))
+        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+        await edit_or_send_message(
+            target_message=callback_query.message,
+            text="📷 <b>Ваш QR-код для реферальной ссылки.</b>",
+            reply_markup=builder.as_markup(),
+            media_path=qr_path,
+        )
+
+        os.remove(qr_path)
+
+    except Exception as e:
+        logger.error(f"Ошибка при генерации QR-кода для реферальной ссылки: {e}", exc_info=True)
+        await callback_query.message.answer("❌ Произошла ошибка при создании QR-кода.")
+
+
+@router.callback_query(F.data == "top_referrals")
+async def top_referrals_handler(callback_query: CallbackQuery):
+    conn = await asyncpg.connect(DATABASE_URL)
+    try:
+        user_referral_count = (
+            await conn.fetchval("SELECT COUNT(*) FROM referrals WHERE referrer_tg_id = $1", callback_query.from_user.id)
+            or 0
+        )
+
+        personal_block = "Твоё место в рейтинге:\n"
+        if user_referral_count > 0:
+            user_position = await conn.fetchval(
+                """
+                SELECT COUNT(*) + 1 FROM (
+                    SELECT COUNT(*) as cnt 
+                    FROM referrals 
+                    GROUP BY referrer_tg_id 
+                    HAVING COUNT(*) > $1
+                ) AS better_users
+                """,
+                user_referral_count,
+            )
+            personal_block += f"{user_position}. {callback_query.from_user.id} - {user_referral_count} чел."
+        else:
+            personal_block += "Ты еще не приглашал пользователей в проект."
+
+        top_referrals = await conn.fetch(
+            """
+            SELECT referrer_tg_id, COUNT(*) as referral_count
+            FROM referrals
+            GROUP BY referrer_tg_id
+            ORDER BY referral_count DESC
+            LIMIT 5
+            """
+        )
+
+        is_admin = callback_query.from_user.id in ADMIN_ID
+        rows = ""
+        for i, row in enumerate(top_referrals, 1):
+            tg_id = str(row["referrer_tg_id"])
+            count = row["referral_count"]
+            display_id = tg_id if is_admin else f"{tg_id[:5]}*****"
+            rows += f"{i}. {display_id} - {count} чел.\n"
+
+        text = TOP_REFERRALS_TEXT.format(personal_block=personal_block, rows=rows)
+
+        builder = InlineKeyboardBuilder()
+        builder.row(InlineKeyboardButton(text=BACK, callback_data="invite"))
+        builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
+
+        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,
+        )
+    finally:
+        await conn.close()
+
+
+async def handle_referral_link(referral_code: str, message: Message, state: FSMContext, session: Any):
+    try:
+        referrer_tg_id = int(referral_code)
+        user_exists_now = await check_user_exists(message.chat.id)
+
+        if referrer_tg_id == message.chat.id:
+            await message.answer("❌ Вы не можете быть реферальной ссылкой самого себя.")
+            return
+
+        if user_exists_now:
+            await message.answer("❌ Вы уже зарегистрированы и не можете использовать реферальную ссылку.")
+            return
+
+        existing_referral = await get_referral_by_referred_id(message.chat.id, session)
+        if existing_referral:
+            await message.answer("❌ Вы уже использовали реферальную ссылку.")
+            return
+
+        await add_referral(message.chat.id, referrer_tg_id, session)
+
+        from_user = message.from_user
+        await add_user(
+            tg_id=from_user.id,
+            username=from_user.username,
+            first_name=from_user.first_name,
+            last_name=from_user.last_name,
+            language_code=from_user.language_code,
+            is_bot=from_user.is_bot,
+            session=session,
+        )
+
+        try:
+            await bot.send_message(
+                referrer_tg_id,
+                NEW_REFERRAL_NOTIFICATION.format(referred_id=message.chat.id),
+            )
+        except Exception as e:
+            logger.error(f"Не удалось отправить уведомление пригласившему ({referrer_tg_id}): {e}")
+
+        await message.answer(REFERRAL_SUCCESS_MSG.format(referrer_tg_id=referrer_tg_id))
+        return
+
+    except Exception as e:
+        logger.error(f"Ошибка при обработке реферальной ссылки {referral_code}: {e}")
+        await message.answer("❌ Произошла ошибка при обработке реферальной ссылки.")
+        return

handlers/start.py

@@ -24,22 +24,17 @@ from config import (
     SUPPORT_CHAT_URL,
 )
 from database import (
-    add_connection,
-    add_referral,
-    check_connection_exists,
-    get_referral_by_referred_id,
+    add_user,
+    check_user_exists,
     get_trial,
-    update_balance,
 )
-from handlers.buttons import ABOUT_VPN, BACK, CHANNEL, MAIN_MENU, SUPPORT
+from handlers.buttons import ABOUT_VPN, BACK, CHANNEL, MAIN_MENU, SUPPORT, TRIAL_SUB
 from handlers.captcha import generate_captcha
-from handlers.keys.key_mode.key_create import create_key
+from handlers.coupons import activate_coupon
+from handlers.payments.gift import handle_gift_link
 from handlers.profile import process_callback_view_profile
 from handlers.texts import (
-    GIFT_ALREADY_USED_OR_NOT_EXISTS_MSG,
-    NEW_REFERRAL_NOTIFICATION,
     NOT_SUBSCRIBED_YET_MSG,
-    REFERRAL_SUCCESS_MSG,
     SUBSCRIPTION_CHECK_ERROR_MSG,
     SUBSCRIPTION_CONFIRMED_MSG,
     SUBSCRIPTION_REQUIRED_MSG,
@@ -47,9 +42,9 @@ from handlers.texts import (
     get_about_vpn,
 )
 from logger import logger
-from handlers.coupons import activate_coupon
 
 from .admin.panel.keyboard import AdminPanelCallback
+from .refferal import handle_referral_link
 from .utils import edit_or_send_message
 
 
@@ -65,17 +60,18 @@ async def handle_start_callback_query(
 
 @router.message(Command("start"))
 async def start_command(message: Message, state: FSMContext, session: Any, admin: bool, captcha: bool = True):
-    """Обрабатывает команду /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
+        user_exists = await check_user_exists(message.chat.id)
+        if not user_exists:
+            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
 
     state_data = await state.get_data()
     text_to_process = state_data.get("original_text", message.text)
@@ -111,123 +107,6 @@ async def start_command(message: Message, state: FSMContext, session: Any, admin
     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:
-            if "coupons_" in text:
-                logger.info(f"Обнаружена ссылка на купон: {text}")
-                coupon_code = text.split("coupons_")[1]
-                await activate_coupon(message, state, session, coupon_code=coupon_code, admin=admin)
-                return
-
-            if "gift_" in text:
-                parts = text.split("gift_")[1].split("_")
-                if len(parts) < 2:
-                    await message.answer("❌ Неверный формат ссылки на подарок.")
-                    return await process_callback_view_profile(message, state, admin)
-                gift_id = parts[0]
-                async with session.transaction():
-                    gift_info = await session.fetchrow(
-                        """
-                        SELECT sender_tg_id, selected_months, expiry_time, is_used, recipient_tg_id 
-                        FROM gifts 
-                        WHERE gift_id = $1
-                        FOR UPDATE
-                        """,
-                        gift_id,
-                    )
-                if not gift_info:
-                    await message.answer(GIFT_ALREADY_USED_OR_NOT_EXISTS_MSG)
-                    return await process_callback_view_profile(message, state, admin)
-
-                if gift_info["is_used"]:
-                    await message.answer("Этот подарок уже был использован.")
-                    return await process_callback_view_profile(message, state, admin)
-
-                if gift_info["sender_tg_id"] == message.chat.id:
-                    await message.answer("❌ Вы не можете получить подарок от самого себя.")
-                    return await process_callback_view_profile(message, state, admin)
-
-                if gift_info["recipient_tg_id"]:
-                    await message.answer("❌ Этот подарок уже был активирован другим пользователем.")
-                    return await process_callback_view_profile(message, state, admin)
-
-                existing_referral = await get_referral_by_referred_id(message.chat.id, session)
-                if not existing_referral:
-                    await add_referral(message.chat.id, gift_info["sender_tg_id"], session)
-
-                connection_exists = await check_connection_exists(message.chat.id)
-                if not connection_exists:
-                    await add_connection(tg_id=message.chat.id, session=session)
-
-                await session.execute("UPDATE connections SET trial = 1 WHERE tg_id = $1", message.chat.id)
-
-                await create_key(
-                    message.chat.id,
-                    gift_info["expiry_time"].replace(tzinfo=None),
-                    state,
-                    session,
-                    message,
-                )
-                await session.execute(
-                    "UPDATE gifts SET is_used = TRUE, recipient_tg_id = $1 WHERE gift_id = $2",
-                    message.chat.id,
-                    gift_id,
-                )
-                await message.answer(
-                    f"🎉 Ваш подарок на {gift_info['selected_months']} "
-                    f"{'месяц' if gift_info['selected_months'] == 1 else 'месяца' if gift_info['selected_months'] in [2, 3, 4] else 'месяцев'} активирован!"
-                )
-                return
-
-            if "referral_" in text:
-                try:
-                    referrer_tg_id = int(text.split("referral_")[1])
-                    connection_exists_now = await check_connection_exists(message.chat.id)
-                    if connection_exists_now:
-                        await message.answer("❌ Вы уже зарегистрированы и не можете использовать реферальную ссылку.")
-                        return await process_callback_view_profile(message, state, admin)
-                    if referrer_tg_id == message.chat.id:
-                        await message.answer("❌ Вы не можете быть рефералом самого себя.")
-                        return await process_callback_view_profile(message, state, admin)
-                    existing_referral = await get_referral_by_referred_id(message.chat.id, session)
-                    if existing_referral:
-                        return await process_callback_view_profile(message, state, admin)
-
-                    await add_referral(message.chat.id, referrer_tg_id, session)
-                    await message.answer(REFERRAL_SUCCESS_MSG.format(referrer_tg_id=referrer_tg_id))
-                    try:
-                        await bot.send_message(
-                            referrer_tg_id,
-                            NEW_REFERRAL_NOTIFICATION.format(referred_id=message.chat.id),
-                        )
-                    except Exception as e:
-                        logger.error(f"Не удалось отправить уведомление пригласившему ({referrer_tg_id}): {e}")
-                    return await process_callback_view_profile(message, state, admin)
-                except (ValueError, IndexError):
-                    pass
-
-            logger.info("Пользователь зашел без реферальной ссылки, подарка или купона.")
-
-        except Exception as e:
-            logger.error(f"Ошибка при обработке текста {message.text} — {e}", exc_info=True)
-            await message.answer("❌ Произошла ошибка. Попробуйте позже.")
-            return
-
-    final_exists = await check_connection_exists(message.chat.id)
-    if final_exists:
-        if SHOW_START_MENU_ONCE:
-            return await process_callback_view_profile(message, state, admin)
-        else:
-            return await show_start_menu(message, admin, session)
-    else:
-        await add_connection(tg_id=message.chat.id, session=session)
-        return 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
@@ -257,6 +136,117 @@ async def check_subscription_callback(callback_query: CallbackQuery, state: FSMC
         await callback_query.answer(SUBSCRIPTION_CHECK_ERROR_MSG, show_alert=True)
 
 
+async def process_start_logic(
+    message: Message, state: FSMContext, session: Any, admin: bool, text_to_process: str = None
+):
+    text = text_to_process or message.text or message.caption
+
+    if not text:
+        logger.info(f"[StartLogic] Текста нет — вызываю стартовое меню для {message.chat.id}")
+        await show_start_menu(message, admin, session)
+        return
+
+    if text.startswith("/start "):
+        parts = text.split(maxsplit=1)
+        if len(parts) > 1:
+            text = parts[1]
+
+    try:
+        gift_detected = False
+        text_parts = text.split("-")
+
+        for part in text_parts:
+            if "coupons" in part:
+                logger.info(f"Обнаружена ссылка на купон: {part}")
+                coupon_code = part.split("coupons")[1].strip("_")
+                await activate_coupon(message, state, session, coupon_code=coupon_code, admin=admin)
+                continue
+
+            if "gift" in part:
+                gift_raw = part.split("gift")[1].strip("_")
+                parts = gift_raw.split("_")
+                if len(parts) < 2:
+                    await message.answer("❌ Неверный формат ссылки на подарок.")
+                    return await process_callback_view_profile(message, state, admin)
+
+                gift_id = parts[0]
+                sender_id = parts[1]
+                logger.info(f"[GIFT] Обнаружен подарок {gift_id} от {sender_id}")
+                await handle_gift_link(gift_id, message, state, session)
+                gift_detected = True
+                break
+
+            if "referral" in part:
+                referrer_tg_id = part.split("referral")[1].strip("_")
+                try:
+                    referrer_tg_id = int(referrer_tg_id)
+                    await handle_referral_link(referrer_tg_id, message, state, session)
+                except (ValueError, IndexError):
+                    pass
+                continue
+
+            if "utm" in part:
+                utm_code = part
+                logger.info(f"Обнаружена ссылка на UTM: {utm_code}")
+                await handle_utm_link(utm_code, message, state, session)
+                continue
+
+        if gift_detected:
+            return
+
+        user_exists = await check_user_exists(message.chat.id)
+        if not user_exists:
+            from_user = message.from_user
+            await add_user(
+                tg_id=from_user.id,
+                username=from_user.username,
+                first_name=from_user.first_name,
+                last_name=from_user.last_name,
+                language_code=from_user.language_code,
+                is_bot=from_user.is_bot,
+                session=session,
+            )
+
+        trial_status = await get_trial(message.chat.id, session)
+
+        if SHOW_START_MENU_ONCE:
+            if trial_status > 0:
+                await process_callback_view_profile(message, state, admin)
+            else:
+                await show_start_menu(message, admin, session)
+        else:
+            await show_start_menu(message, admin, session)
+
+    except Exception as e:
+        logger.error(f"Ошибка при обработке текста {message.text} — {e}", exc_info=True)
+        await message.answer("❌ Произошла ошибка. Попробуйте позже.")
+
+
+async def handle_utm_link(utm_code, message, state, session):
+    exists = await session.fetchval("SELECT 1 FROM tracking_sources WHERE code = $1", utm_code)
+    if exists:
+        current_code = await session.fetchval("SELECT source_code FROM users WHERE tg_id = $1", message.chat.id)
+        if current_code is None:
+            user_exists = await check_user_exists(message.chat.id)
+            from_user = message.from_user
+            if not user_exists:
+                await add_user(
+                    tg_id=from_user.id,
+                    username=from_user.username,
+                    first_name=from_user.first_name,
+                    last_name=from_user.last_name,
+                    language_code=from_user.language_code,
+                    is_bot=from_user.is_bot,
+                    session=session,
+                    source_code=utm_code,
+                )
+            else:
+                await session.execute("UPDATE users SET source_code = $1 WHERE tg_id = $2", utm_code, message.chat.id)
+        logger.info(f"[UTM] Привязана {utm_code} к пользователю {message.chat.id}")
+    else:
+        await message.answer("❌ UTM ссылка не найдена.")
+
+
 async def show_start_menu(message: Message, admin: bool, session: Any):
     """Функция для отображения стандартного меню через редактирование сообщения.
     Если редактирование не удалось, отправляем новое сообщение."""
@@ -269,7 +259,9 @@ async def show_start_menu(message: Message, admin: bool, session: Any):
         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="🎁 Пробная подписка", callback_data="create_key"))
+            builder.row(InlineKeyboardButton(text=TRIAL_SUB, callback_data="create_key"))
+        else:
+            builder.row(InlineKeyboardButton(text=MAIN_MENU, callback_data="profile"))
     else:
         logger.warning(f"Сессия базы данных отсутствует, пропускаем проверку триала для {message.chat.id}")
 
@@ -321,4 +313,4 @@ async def handle_about_vpn(callback_query: CallbackQuery):
         reply_markup=builder.as_markup(),
         media_path=image_path,
         force_text=False,
-    )
+    )

handlers/utils.py

@@ -10,97 +10,105 @@ import asyncpg
 
 from aiogram.types import BufferedInputFile, InlineKeyboardMarkup, InputMediaPhoto, Message
 
+from datetime import datetime
 from bot import bot
-from config import DATABASE_URL
+from config import ADMIN_ID, 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:
+def generate_random_email(length: int = 8) -> 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()
     server_to_cluster = {}
-    cluster_loads = dict.fromkeys(servers.keys(), 0)
+    cluster_loads = {}
+
     for cluster_name, cluster_servers in servers.items():
+        cluster_loads[cluster_name] = 0
         for server in cluster_servers:
             server_to_cluster[server["server_name"]] = cluster_name
-    logger.info(f"Сопоставление серверов и кластеров: {server_to_cluster}")
+
     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:
                 server_id = key["server_id"]
-
                 cluster_id = server_to_cluster.get(server_id, server_id)
-
                 if cluster_id in cluster_loads:
                     cluster_loads[cluster_id] += 1
-                else:
-                    logger.warning(f"⚠️ Сервер {server_id} не найден в известных кластерах!")
-    logger.info(f"Загруженность кластеров после запроса к БД: {cluster_loads}")
-    if not cluster_loads:
-        logger.warning("⚠️ В базе данных или конфигурации нет кластеров!")
+
+            available_clusters = {}
+            for cluster_name, cluster_servers in servers.items():
+                for server in cluster_servers:
+                    if server.get("enabled", True) and await check_server_key_limit(server, conn):
+                        available_clusters[cluster_name] = cluster_loads[cluster_name]
+                        break
+
+    if not available_clusters:
+        logger.warning("❌ Нет доступных кластеров с лимитом ключей!")
         return "cluster1"
-    least_loaded_cluster = min(cluster_loads, key=lambda k: (cluster_loads[k], k))
-    logger.info(f"✅ Выбран наименее загруженный кластер: {least_loaded_cluster}")
+
+    least_loaded_cluster = min(available_clusters, key=lambda k: (available_clusters[k], k))
+    logger.info(f"✅ Выбран наименее загруженный кластер с лимитом: {least_loaded_cluster}")
 
     return least_loaded_cluster
 
 
+async def check_server_key_limit(server_info: dict, conn) -> bool:
+    """
+    Универсальная проверка лимита ключей для сервера в режимах кластеров и стран.
+    """
+    server_name = server_info.get("server_name")
+    cluster_name = server_info.get("cluster_name")
+    max_keys = server_info.get("max_keys")
+
+    if not max_keys:
+        return True
+
+    identifier = cluster_name if cluster_name else server_name
+    total_keys = await conn.fetchval("SELECT COUNT(*) FROM keys WHERE server_id = $1", identifier)
+
+    if total_keys >= max_keys:
+        logger.warning(f"[Key Limit] Сервер {server_name} достиг лимита: {total_keys}/{max_keys}")
+        return False
+
+    usage_percent = total_keys / max_keys
+
+    if usage_percent >= 0.9:
+        notif_key = f"server_warn_{server_name}"
+        already_sent = await conn.fetchval(
+            "SELECT EXISTS (SELECT 1 FROM notifications WHERE tg_id = 0 AND notification_type = $1)", notif_key
+        )
+        if not already_sent:
+            for admin_id in ADMIN_ID:
+                try:
+                    await bot.send_message(
+                        admin_id,
+                        f"⚠️ Сервер <b>{server_name}</b> почти заполнен ({int(usage_percent * 100)}%)."
+                        f"\nРекомендуется создать новый для балансировки.",
+                    )
+                except Exception:
+                    pass
+            await conn.execute(
+                "INSERT INTO notifications (tg_id, notification_type) VALUES (0, $1) ON CONFLICT DO NOTHING",
+                notif_key,
+            )
+
+    return True
+
+
 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"):
@@ -122,14 +130,18 @@ def get_plural_form(num: int, form1: str, form2: str, form3: str) -> str:
         return form3
     return {1: form1, 2: form2, 3: form2, 4: form2}.get(n % 10, form3)
 
+
 def format_months(months: int) -> str:
     """Форматирует количество месяцев с правильным склонением"""
     if months <= 0:
         return "0 месяцев"
     return f"{months} {get_plural_form(months, 'месяц', 'месяца', 'месяцев')}"
 
+
 def format_days(days: int) -> str:
-    """Форматирует количество дней с правильным склонением"""
+    """
+    Форматирует количество дней с правильным склонением.
+    """
     if days <= 0:
         return "0 дней"
     return f"{days} {get_plural_form(days, 'день', 'дня', 'дней')}"
@@ -147,6 +159,20 @@ def format_minutes(minutes: int) -> str:
     return f"{minutes} {get_plural_form(minutes, 'минута', 'минуты', 'минут')}"
 
 
+def format_hours(hours: int) -> str:
+    """Форматирует количество часов с правильным склонением"""
+    if hours <= 0:
+        return "0 часов"
+    return f"{hours} {get_plural_form(hours, 'час', 'часа', 'часов')}"
+
+
+def format_minutes(minutes: int) -> str:
+    """Форматирует количество минут с правильным склонением"""
+    if minutes <= 0:
+        return "0 минут"
+    return f"{minutes} {get_plural_form(minutes, 'минута', 'минуты', 'минут')}"
+
+
 async def edit_or_send_message(
     target_message: Message,
     text: str,
@@ -157,15 +183,6 @@ async def edit_or_send_message(
 ):
     """
     Универсальная функция для редактирования исходного сообщения 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:
@@ -210,11 +227,6 @@ async def edit_or_send_message(
 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
@@ -244,3 +256,46 @@ async def is_full_remnawave_cluster(cluster_id: str, session) -> bool:
         cluster_id,
     )
     return server and server["panel_type"].lower() == "remnawave"
+
+
+def sanitize_key_name(key_name: str) -> str:
+    """
+    Очищает название ключа, оставляя только допустимые символы.
+
+    Args:
+        key_name (str): Исходное название ключа.
+
+    Returns:
+        str: Очищенное название ключа в нижнем регистре.
+    """
+    return re.sub(r"[^a-z0-9@._-]", "", key_name.lower())
+
+
+RUSSIAN_MONTHS = {
+    'January': 'Января',
+    'February': 'Февраля',
+    'March': 'Марта',
+    'April': 'Апреля',
+    'May': 'Мая',
+    'June': 'Июня',
+    'July': 'Июля',
+    'August': 'Августа',
+    'September': 'Сентября',
+    'October': 'Октября',
+    'November': 'Ноября',
+    'December': 'Декабря'
+}
+
+
+def get_russian_month(date: datetime) -> str:
+    """
+    Преобразует английское название месяца в русское.
+    
+    Args:
+        date: Объект datetime, из которого извлекается месяц.
+    
+    Returns:
+        Название месяца на русском языке.
+    """
+    english_month = date.strftime("%B")
+    return RUSSIAN_MONTHS.get(english_month, english_month)

middlewares/__init__.py

@@ -8,6 +8,8 @@ from .loggings import LoggingMiddleware
 from .session import SessionMiddleware
 from .throttling import ThrottlingMiddleware
 from .user import UserMiddleware
+from .maintenance import MaintenanceModeMiddleware
+
 
 
 def register_middleware(
@@ -16,40 +18,27 @@ def register_middleware(
     exclude: Iterable[str] | None = None,
 ) -> None:
     """Регистрирует middleware в диспетчере.
-
-    Args:
-        dispatcher: Экземпляр диспетчера Aiogram
-        middlewares: Опциональный список middleware для регистрации.
-                    Если не указан, регистрируются все стандартные middleware.
-        exclude: Опциональный список имен middleware, которые нужно исключить из регистрации.
-                Применяется только если middlewares не указан.
     """
-    # Если middleware не указаны, используем стандартный набор
     if middlewares is None:
-        # Словарь всех доступных middleware
         available_middlewares = {
             "admin": AdminMiddleware(),
             "session": SessionMiddleware(),
+            "maintenance": MaintenanceModeMiddleware(), 
             "logging": LoggingMiddleware(),
             "throttling": ThrottlingMiddleware(),
             "user": UserMiddleware(),
         }
 
-        # Фильтруем middleware по списку исключений
         exclude_set = set(exclude or [])
         middlewares = [middleware for name, middleware in available_middlewares.items() if name not in exclude_set]
 
-    # Регистрируем middleware для всех типов обработчиков
     handlers = [
         dispatcher.message,
         dispatcher.callback_query,
         dispatcher.inline_query,
-        # Можно добавить другие типы обработчиков при необходимости
     ]
 
-    # Регистрируем каждый middleware для каждого типа обработчика
     for middleware in middlewares:
-        # Если передан класс, а не экземпляр, создаем экземпляр
         if isinstance(middleware, type):
             middleware = middleware()
 

middlewares/maintenance.py

@@ -0,0 +1,20 @@
+from aiogram import BaseMiddleware
+from aiogram.types import Message, CallbackQuery
+from config import ADMIN_ID
+
+maintenance_mode = False
+
+class MaintenanceModeMiddleware(BaseMiddleware):
+    async def __call__(self, handler, event, data):
+        if maintenance_mode:
+            user_id = None
+            if isinstance(event, Message):
+                user_id = event.from_user.id
+            elif isinstance(event, CallbackQuery):
+                user_id = event.from_user.id
+
+            if user_id and user_id not in ADMIN_ID:
+                await event.answer("⚙️ Бот временно недоступен. Ведутся технические работы.")
+                return
+        
+        return await handler(event, data)

middlewares/user.py

@@ -51,6 +51,7 @@ class UserMiddleware(BaseMiddleware):
             language_code=user.language_code,
             is_bot=user.is_bot,
             session=session,
+            only_if_exists=True,
         )
 
         logger.debug(f"Получены данные пользователя из БД: {user.id}")

panels/three_xui.py

@@ -1,10 +1,21 @@
+import time
+
 from dataclasses import dataclass
 from typing import Any
 
 import httpx
 import py3xui
 
-from config import LIMIT_IP, SUPERNODE
+from py3xui import AsyncApi
+
+from config import (
+    ADMIN_PASSWORD,
+    ADMIN_USERNAME,
+    LIMIT_IP,
+    SUPERNODE,
+    USE_XUI_TOKEN,
+    XUI_TOKEN,
+)
 from logger import logger
 
 
@@ -24,21 +35,39 @@ class ClientConfig:
     sub_id: str
 
 
+_xui_instance_cache: dict[str, tuple[AsyncApi, float]] = {}
+SESSION_TTL = 1800
+
+
+async def get_xui_instance(api_url: str) -> AsyncApi:
+    key = f"{api_url}|{ADMIN_USERNAME}"
+    current_time = time.time()
+
+    xui_entry = _xui_instance_cache.get(key)
+    if xui_entry:
+        xui, last_login = xui_entry
+        if current_time - last_login < SESSION_TTL:
+            return xui
+        else:
+            logger.info("[XUI Cache] Сессия устарела (>30 минут), переподключение...")
+            await xui.login()
+            _xui_instance_cache[key] = (xui, current_time)
+            return xui
+
+    xui = AsyncApi(
+        api_url,
+        ADMIN_USERNAME,
+        ADMIN_PASSWORD,
+        token=XUI_TOKEN if USE_XUI_TOKEN else None,
+        logger=logger,
+    )
+    await xui.login()
+    _xui_instance_cache[key] = (xui, current_time)
+    return xui
+
+
 async def add_client(xui: py3xui.AsyncApi, config: ClientConfig) -> dict[str, Any]:
-    """
-    Добавляет клиента на сервер через 3x-ui.
-
-    Args:
-        xui: Экземпляр API клиента
-        config: Конфигурация клиента
-
-    Returns:
-        Dict[str, Any]: Результат операции в формате
-            {'status': 'success'|'failed'|'duplicate', 'error': str, 'email': str}
-    """
     try:
-        await xui.login()
-
         client = py3xui.Client(
             id=config.client_id,
             email=config.email.lower(),
@@ -53,7 +82,6 @@ async def add_client(xui: py3xui.AsyncApi, config: ClientConfig) -> dict[str, An
 
         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 httpx.ConnectTimeout as e:
@@ -80,31 +108,10 @@ async def extend_client_key(
     sub_id: str,
     tg_id: int,
 ) -> 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.")
+        if not client or not client.id:
+            logger.warning(f"Клиент с email {email} не найден или не имеет ID.")
             return None
 
         logger.info(f"Обновление ключа клиента {email} с ID {client.id} до {new_expiry_time}")
@@ -152,8 +159,6 @@ async def delete_client(
         bool: True если удаление успешно, False в противном случае
     """
     try:
-        await xui.login()
-
         if SUPERNODE:
             await xui.client.delete(inbound_id, client_id)
             logger.info(f"Клиент с ID {client_id} был удален успешно (SUPERNODE)")
@@ -179,20 +184,8 @@ async def delete_client(
 
 
 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}
@@ -210,24 +203,8 @@ async def get_client_traffic(xui: py3xui.AsyncApi, client_id: str) -> dict[str,
 
 
 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()
-
         client = await xui.client.get_by_email(email)
-
         if not client:
             logger.warning(f"Клиент с email {email} и ID {client_id} не найден.")
             return False

utils/csv_export.py

@@ -1,4 +1,5 @@
 import csv
+from datetime import datetime
 
 from io import StringIO
 from typing import Any
@@ -12,18 +13,17 @@ async def export_users_csv(session: Any) -> BufferedInputFile:
     """
     query = """
         SELECT 
-            u.tg_id, 
-            u.username, 
-            u.first_name, 
-            u.last_name, 
-            u.language_code, 
-            u.is_bot, 
-            c.balance, 
-            c.trial,
-            u.created_at  -- Добавляем дату регистрации
-        FROM users u
-        LEFT JOIN connections c ON u.tg_id = c.tg_id
-        ORDER BY u.created_at ASC  -- Сортировка от старых к новым
+            tg_id, 
+            username, 
+            first_name, 
+            last_name, 
+            language_code, 
+            is_bot, 
+            balance, 
+            trial,
+            created_at  
+        FROM users
+        ORDER BY created_at ASC
     """
 
     users = await session.fetch(query)
@@ -173,7 +173,7 @@ async def export_hot_leads_csv(session: Any) -> BufferedInputFile:
 
 async def export_keys_csv(session) -> BufferedInputFile:
     """
-    Экспорт подписок в CSV.
+    Экспорт подписок в CSV с нормальными датами.
     """
     keys = await session.fetch("""
         SELECT tg_id, client_id, email, created_at, expiry_time, key, server_id, is_frozen, alias
@@ -185,9 +185,12 @@ async def export_keys_csv(session) -> BufferedInputFile:
     buffer.write("tg_id,client_id,email,created_at,expiry_time,key,server_id,is_frozen,alias\n")
 
     for row in keys:
+        created_at = datetime.utcfromtimestamp(row['created_at'] / 1000).strftime("%Y-%m-%d %H:%M:%S")
+        expiry_time = datetime.utcfromtimestamp(row['expiry_time'] / 1000).strftime("%Y-%m-%d %H:%M:%S")
+        
         buffer.write(
             f"{row['tg_id']},{row['client_id']},{row['email']},"
-            f"{row['created_at']},{row['expiry_time']},{row['key']},"
+            f"{created_at},{expiry_time},{row['key']},"
             f"{row['server_id']},{row['is_frozen']},{row['alias'] or ''}\n"
         )