Update remnawave.py

Bedolaganew

.env.example

@@ -1,71 +1,79 @@
-# Bot Configuration
+# TELEGRAM BOT CONFIGURATION
 BOT_TOKEN=
+ADMIN_IDS=
+SUPPORT_USERNAME=
 
-# настройки реф программы юзернейм без @!
-BOT_USERNAME=
-REFERRAL_FIRST_REWARD=100.0
-REFERRAL_REFERRED_BONUS=100.0
-REFERRAL_THRESHOLD=200.0
-REFERRAL_PERCENTAGE=0.2
+# DATABASE CONFIGURATION
+DATABASE_URL=sqlite+aiosqlite:///./bot.db
+REDIS_URL=redis://localhost:6379/0
 
-# RemnaWave API Configuration
-REMNAWAVE_URL=https://example.com
-REMNAWAVE_TOKEN=
+# REMNAWAVE API CONFIGURATION
+REMNAWAVE_API_URL=
+REMNAWAVE_API_KEY=
 
-# Admin Configuration (comma-separated list of Telegram user IDs)
-ADMIN_IDS=123445567,12342123
+# TRIAL SUBSCRIPTION SETTINGS
+TRIAL_DURATION_DAYS=3
+TRIAL_TRAFFIC_LIMIT_GB=10
+TRIAL_DEVICE_LIMIT=2
+TRIAL_SQUAD_UUID=
+DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
 
-# Support Configuration
-SUPPORT_USERNAME=support
+# SUBSCRIPTION PRICING (в копейках для точности)
+BASE_SUBSCRIPTION_PRICE=50000
 
-TRIAL_ENABLED=true # Включить триал
-TRIAL_DURATION_DAYS=3 # Дней триала 
-TRIAL_TRAFFIC_GB=2 # Лимит трафика у триал подписки
-TRIAL_SQUAD_UUID=  # UUID сквада из панели remnawave /dashboard/management/internal-squads
-TRIAL_PRICE=0.0 # Оставить 0!
-TRIAL_NOTIFICATION_ENABLED=true # Уведомление об истекшей триальной подписке 
-TRIAL_NOTIFICATION_HOURS_AFTER=1 # Через сколько отсылать сообщение 
-TRIAL_NOTIFICATION_HOURS_WINDOW=23 # Через сколько выслать повторно 
+PRICE_14_DAYS=5000
+PRICE_30_DAYS=9900  
+PRICE_60_DAYS=18900
+PRICE_90_DAYS=26900
+PRICE_180_DAYS=49900
+PRICE_360_DAYS=89900
 
-# Monitor Service Settings (дополнительные настройки)
-MONITOR_CHECK_INTERVAL=21600   # Промежуток проверики (3600 - будет раз в час проверять и слать уведомления)
-MONITOR_DAILY_CHECK_HOUR=10 # Ежедневный чек в 10 утра
-MONITOR_WARNING_DAYS=2 # За сколько начинать до окончания подписки слать уведомления
-DELETE_EXPIRED_TRIAL_DAYS=1   # Через сколько дней после истечения удалять триал подписки
-DELETE_EXPIRED_REGULAR_DAYS=7 # Через сколько дней после истечения удалять обычные подписки  
-AUTO_DELETE_ENABLED=true  # Включить автоматическое удаление при ежедневной проверке
+PRICE_TRAFFIC_5GB=2000
+PRICE_TRAFFIC_10GB=4000
+PRICE_TRAFFIC_25GB=6000
+PRICE_TRAFFIC_50GB=10000
+PRICE_TRAFFIC_100GB=15000
+PRICE_TRAFFIC_250GB=20000
+PRICE_TRAFFIC_UNLIMITED=25000
 
+PRICE_PER_DEVICE=5000
 
-LUCKY_GAME_ENABLED=true                 # Включить/выключить игру удачи
-LUCKY_GAME_REWARD=50.0                  # Размер награды за выигрыш в рублях
-LUCKY_GAME_NUMBERS=30                   # Общее количество чисел для выбора (1-30)
-LUCKY_GAME_WINNING_COUNT=25              # Количество выигрышных чисел из общего количества
+# REFERRAL SYSTEM SETTINGS
+REFERRAL_REGISTRATION_REWARD=5000
+REFERRED_USER_REWARD=10000
+REFERRAL_COMMISSION_PERCENT=25
 
-# ================================
-# TELEGRAM STARS НАСТРОЙКИ
-# ================================
-# Включить/выключить пополнение через Telegram Stars
-STARS_ENABLED=true
-# Курсы обмена звезд на рубли
-# Формат: STARS_{количество_звезд}_RATE={рубли}
-# 100 звёзд
-STARS_100_RATE=110
-# 150 звёзд 
-STARS_150_RATE=165
-# 250 звёзд
-STARS_250_RATE=280
-# 350 звёзд
-STARS_350_RATE=355
-# 500 звёзд
-STARS_500_RATE=550
-# 750 звёзд
-STARS_750_RATE=800
-# 1000 звёзд 
-STARS_1000_RATE=1000
+# AUTO-PAYMENT SETTINGS
+AUTOPAY_WARNING_DAYS=3,1
 
+# MONITORING SETTINGS
+MONITORING_INTERVAL=60
+INACTIVE_USER_DELETE_MONTHS=3
 
-TRIBUTE_ENABLED=true  # true/false включить/выключить пополнение баланса с помощью доната на Tribute
-TRIBUTE_API_KEY=  # API ключ из настроек Tribute
-TRIBUTE_WEBHOOK_PORT=8081
+TRIAL_WARNING_HOURS=2
+ENABLE_NOTIFICATIONS=true
+NOTIFICATION_RETRY_ATTEMPTS=3
+MONITORING_LOGS_RETENTION_DAYS=30
+
+# PAYMENT SYSTEMS
+TELEGRAM_STARS_ENABLED=true
+TRIBUTE_ENABLED=false
+TRIBUTE_API_KEY=
+TRIBUTE_WEBHOOK_SECRET=your_webhook_secret
+TRIBUTE_DONATE_LINK=https://t.me/tribute/app?startapp=XXXX
 TRIBUTE_WEBHOOK_PATH=/tribute-webhook
-TRIBUTE_DONATE_LINK=https://t.me/tribute/app?startapp=XXXXXXXX  # укажите ссылку на донат в Tribute
+TRIBUTE_WEBHOOK_PORT=8081
+
+WEBHOOK_URL=https://example.com
+WEBHOOK_PATH=/webhook
+
+# LOCALIZATION
+DEFAULT_LANGUAGE=ru
+AVAILABLE_LANGUAGES=ru
+
+# LOGGING
+LOG_LEVEL=INFO
+LOG_FILE=/tmp/bot.log
+
+# DEVELOPMENT
+DEBUG=false

Dockerfile

@@ -1,46 +1,33 @@
-# Use Python 3.11 slim image
 FROM python:3.11-slim
 
-# Set working directory
 WORKDIR /app
 
-# Set environment variables
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PYTHONPATH=/app
-
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
     gcc \
-    g++ \
-    libpq-dev \
-    curl \
-    && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-# Create non-root user
-RUN groupadd -r botuser && useradd -r -g botuser botuser
-
 # Copy requirements first for better caching
 COPY requirements.txt .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir --upgrade pip setuptools wheel && \
-    pip install --no-cache-dir -r requirements.txt --prefer-binary
+RUN pip install --no-cache-dir -r requirements.txt
 
 # Copy application code
 COPY . .
 
-# Create necessary directories
-RUN mkdir -p /app/logs /app/data && \
-    chown -R botuser:botuser /app
+# Create logs directory
+RUN mkdir -p logs
 
-# Switch to non-root user
-USER botuser
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
 
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
-    CMD python -c "import asyncio; import sys; sys.exit(0)"
+# Create non-root user
+RUN useradd --create-home --shell /bin/bash app
+RUN chown -R app:app /app
+USER app
 
-# Default command
-CMD ["python3", "main.py"]
+# Expose port (if needed for webhooks)
+EXPOSE 8000
+
+# Run the application
+CMD ["python", "main.py"]

README.md

@@ -1,4 +1,18 @@
-# 🤖 Remnawave Bedolaga Bot
+# 🤖 Remnawave Bedolaga Bot 2.0.0
+
+## ⚠️ Важная пометка
+
+Бедолага был **полностью** переписан с нуля. 
+
+Версия 2.0.0 — Это не просто обновление, это в целом - переосмысление логики работы бота, с полностью новой архитектурой, улучшенной производительностью и расширенным функционалом. 
+
+**Обновление не совместимо со крайней версией 1.4.2!** 
+
+Поэтому заранее извинюсь перед всеми, кто уже начал пользоваться моим бедолагой, увы, делать нормальную миграцию всех данных у меня уже совсем сил ноль, да и не ожидал такого успеха, поэтому-то и решил полностью переписать бота, пока еще не совсем поздно, доработав его опираясь на ваши отзывы и запросы. 
+
+На данный момент новая версия бота, по моим оценкам, отлажена на **90%**+-. 
+
+Собственно, те кто установил бота - могут пока перенести всех юзеров из панели в бота через синхронизацию.
 
 <div align="center">
 
@@ -27,135 +41,251 @@
 <td width="50%">
 
 ### 👤 **Для пользователей**
-- 💰 **Управление балансом** - Telegram Stars + Telegram Tribute + P2P через поддержку
-- 🛒 **Покупка подписок** - различные тарифы с настройкой squad
-- 📱 **Управление подписками** - просмотр, продление, ссылки, настройка автопродления
-- 🎁 **Промокоды** - денежные бонусы
-- 👥 **Реферальная программа** - зарабатывай с друзей и их последующих пополнений
-- 🎰 **Игра удачи** - ежедневные бонусы
+- 💰 **Управление балансом** - Telegram Stars + Telegram Tribute
+- 🛒 **Покупка подписки** - Гибкая конфигурация подписки
+- 📱 **Управление подписками** - просмотр, продление, ссылки, настройка автопродления. Полня конфигурация своей подписки: выбор лимита трафика, выбор стран(Работает через сквады Remnawave), выбор кол-ва устройств. Возможность платно сбросить, увеличить кол-во трафика на подписке, изменить подключенные сервера(сквады) у подписки
+- 🎁 **Промокоды** - денежные бонусы, дни подписки(На отладке) + триал подписка по коду(На отладке)
+- 👥 **Реферальная программа** - зарабатывай с друзей и их последующих покупок
 - 🆓 **Тестовая подписка** - бесплатная пробная версия
-- ♾️ **Автопродление** - настраиваемое автообновление
-- 🌐 **Мультиязычность** - русский и английский
+- 💬 **Уведомления об истечении подписки**
+- 📖 **Правила сервиса**
 
 </td>
 <td width="50%">
 
 ### ⚙️ **Для администраторов**
-- 📊 **Детальная статистика** - пользователи, платежи, подписки
+- 📊 **Детальная статистика** - пользователи, подписки
 - 👥 **Управление пользователями** - поиск, редактирование, баланс
-- 💳 **Управление платежами** - одобрение, история, Telegram Stars
 - 🎫 **Управление промокодами** - создание, статистика, массовые операции
-- 🖥 **Мониторинг системы** - состояние нод, синхронизация с Remnawave
-- 📨 **Рассылки** - уведомления пользователям
-- 🔍 **Мониторинг подписок** - автоуведомления об истечении
+- 🖥 **Мониторинг системы** - состояние нод/панели, синхронизация с Remnawave, просмотр сквадов и их создание
+- 📨 **Рассылки** - уведомления пользователям по критериям 
+- 🔍 **Мониторинг подписок** - Включение/отключение мониторинга, просмотр настроек, лога, тестирование сервиса
 - 📋 **Правила сервиса** - настройка через админ-панель
-- ♾️ **Статистика автопродления** - полный контроль
+- 💰 **Рефералы** - статистика рефералов
 
 </td>
 </tr>
 </table>
 
-# 🚀 Автоматический установщик 
-
-(ТЕСТИРУЕТСЯ, ДРУЗЬЯ КАК БЫ ВАМ НЕ ХОТЕЛОСЬ, ЧТОБЫ ВСЕ САМО ПОСТАВИЛОСЬ, НО Я ПОКА НЕ МОГУ ЗАСТАВИТЬ СКРИПТ КОРРЕКТНО НАСТРАИВАТЬ ВАМ ВЕБХУК С ОБРАТНЫМ ПРОКСИ, ПОЭТОМУ СОБИРАЕМ РУЧКАМИ ДОКЕР БОТА, ПОДКЛЮЧАЕМ ЕГО К СЕТИ ВАШЕГО NGINX/CADDY ДОКЕРА. ДЕЛАЕМ  РУЧКАМИ ОБРАТНО ПРОКСИ НА ХУК /tribute-webhook И КАЙФУЕМ - НЕЙРОНКА КЛАУД В ПОМОЩЬ)
-
 ## Структура проекта
 
 После установки в `/opt/bedolaga-bot/`:
 
 ```
-/opt/bedolaga-bot/
-├── docker-compose.yml    # Конфигурация контейнеров
-├── .env                  # Переменные окружения
-├── logs/                 # Логи бота
-├── data/                 # Данные приложения
-└── backups/              # Резервные копии БД
+bedolaga_bot/
+├── main.py                    # Точка входа                
+├── requirements.txt           # Зависимости                
+├── .env.example               # Пример конфига               
+│
+├── app/
+│   ├── __init__.py
+│   ├── bot.py                 # Инициализация бота          
+│   ├── config.py              # Конфигурация                 
+│   ├── states.py              # FSM состояния                   
+│   │
+│   ├── handlers/              # Обработчики
+│   │   ├── __init__.py
+│   │   ├── start.py           # Регистрация и старт          
+│   │   ├── menu.py            # Главное меню               
+│   │   ├── subscription.py    # Подписки                   
+│   │   ├── balance.py         # Баланс                   
+│   │   ├── promocode.py       # Промокоды                  
+│   │   ├── referral.py        # Рефералы                  
+│   │   ├── support.py         # Техподдержка                  
+│   │   ├── admin/             # Админ панель
+│   │   │   ├── __init__.py
+│   │   │   ├── main.py        # Главная админки           
+│   │   │   ├── users.py       # Управление юзерами          
+│   │   │   ├── subscriptions.py # Настройки подписок         
+│   │   │   ├── promocodes.py  # Управление промокодами        
+│   │   │   ├── messages.py    # Рассылки                      
+│   │   │   ├── monitoring.py  # Мониторинг                  
+│   │   │   ├── referrals.py   # Статистика рефералов          
+│   │   │   ├── rules.py       # Правила сервиса  
+│   │   │   ├── servers.py             
+│   │   │   ├── remnawave.py   # Система RemnaWave            
+│   │   │   └── statistics.py  # Общая статистика             
+│   │   └── common.py          # Общие обработчики            
+│   │
+│   ├── keyboards/             # Клавиатуры
+│   │   ├── __init__.py
+│   │   ├── inline.py          # Inline клавиатуры          
+│   │   ├── reply.py           # Reply клавиатуры         
+│   │   └── admin.py           # Админские клавиатуры       
+│   │
+│   ├── database/              # База данных
+│   │   ├── __init__.py
+│   │   ├── models.py          # Модели SQLAlchemy            
+│   │   ├── database.py        # Подключение к БД            
+│   │   └── crud/              # CRUD операции
+│   │       ├── __init__.py
+│   │       ├── user.py                                      
+│   │       ├── subscription.py                             
+│   │       ├── transaction.py             
+│   │       ├── rules.py      
+│   │       ├── server_squad.py                       
+│   │       ├── promocode.py                                
+│   │       └── referral.py                                 
+│   │
+│   ├── services/              # Бизнес-логика
+│   │   ├── __init__.py                                        
+│   │   ├── user_service.py             # Сервис пользователей          
+│   │   ├── subscription_service.py     # Сервис подписок          
+│   │   ├── payment_service.py          # Платежи                      
+│   │   ├── promocode_service.py        # Промокоды                    
+│   │   ├── referral_service.py         # Рефералы                        
+│   │   ├── monitoring_service.py       # Мониторинг     
+│   │   ├── tribute_service.py               
+│   │   └── remnawave_service.py       # Интеграция с Remnawave       
+│   │
+│   ├── utils/                 # Утилиты
+│   │   ├── __init__.py                                          
+│   │   ├── decorators.py      # Декораторы                      
+│   │   ├── formatters.py      # Форматирование данных            
+│   │   ├── validators.py      # Валидация                       
+│   │   ├── pagination.py      # Пагинация    
+│   │   ├── user_utils.py                        
+│   │   └── cache.py           # Кеширование                     
+│   │
+│   ├── middlewares/           # Middleware
+│   │   ├── __init__.py
+│   │   ├── auth.py           # Авторизация                  
+│   │   ├── logging.py        # Логирование                   
+│   │   └── throttling.py     # Ограничение запросов         
+│   │
+│   ├── localization/          # Локализация
+│   │   ├── __init__.py
+│   │   ├── texts.py          # Тексты интерфейса             
+│   │   └── languages/
+│   │
+│   └── external/              # Внешние API
+│       ├── __init__.py
+│       ├── remnawave_api.py   # Ваш API файл               
+│       ├── telegram_stars.py  # Telegram Stars             
+│       └── tribute.py         # Tribute платежи             
+│
+├── migrations/                # Миграции БД
+│   └── alembic/
+│
+└── logs/                      # Логи
 ```
 
 ---
 
-> 💡 **Совет:** После установки добавьте установщик в закладки для быстрого доступа к меню управления!
-
-## 💡 Полезные команды
-
-# Быстрый перезапуск
-docker compose restart
-
-# Очистка логов
-docker compose logs --tail=100
-
-# Проверка использования ресурсов
-docker stats
-
-# Резервная копия одной командой
-docker compose exec postgres pg_dump -U remnawave_user remnawave_bot > backup.sql
-
 <details>
-<summary>🎁 Реферальная программа</summary>
+<summary>⚙️ Env параметры</summary>
 
-| Переменная | Описание | По умолчанию |
-|------------|----------|--------------|
-| `REFERRAL_FIRST_REWARD` | Награда за первого реферала | `100.0` |
-| `REFERRAL_REFERRED_BONUS` | Бонус приглашенному | `100.0` |
-| `REFERRAL_THRESHOLD` | Порог активации (руб.) | `200.0` |
-| `REFERRAL_PERCENTAGE` | % с последующих платежей | `0.2` (20%) |
+### 3. Конфигурация
 
-</details>
+Скопируйте `.env.example` в `.env` и заполните переменные согласно таблицам ниже:
 
-<details>
-<summary>⭐ Telegram Stars</summary>
+#### 🤖 Основные настройки бота
 
 | Переменная | Описание | Пример |
 |------------|----------|---------|
-| `STARS_ENABLED` | Включить оплату звездами | `true` |
-| `STARS_100_RATE` | Курс 100 звезд → рублей | `110` |
-| `STARS_250_RATE` | Курс 250 звезд → рублей | `280` |
-| `STARS_500_RATE` | Курс 500 звезд → рублей | `550` |
+| `BOT_TOKEN` | Токен Telegram бота | `1234567890:AABBCCddEEffGGhhIIjjKKllMM` |
+| `ADMIN_IDS` | ID администраторов (через запятую) | `123456789,987654321` |
+| `SUPPORT_USERNAME` | Username техподдержки | `@support_bot` |
 
-</details>
-
-<details>
-<summary>⭐ Telegram Tribute</summary>
+#### 🗄️ База данных и кеширование
 
 | Переменная | Описание | Пример |
 |------------|----------|---------|
-| `TRIBUTE_ENABLED` | Включить оплату с помощью доната на Tribute | `false` |
-| `TRIBUTE_API_KEY` | API ключ из настроек Tribute | `XXXXXXXXXXX` |
-| `TRIBUTE_WEBHOOK_PORT` | Порт | `8081` |
-| `TRIBUTE_WEBHOOK_PATH` | URL Webhook Path | `/tribute-webhook` |
-| `TRIBUTE_DONATE_LINK` | Ссылка на ваш донат из Tribute | `https://t.me/tribute/app?startapp=XXXXXXXXXXXXX` |
+| `DATABASE_URL` | URL подключения к БД | `sqlite+aiosqlite:///./bot.db` |
+| `REDIS_URL` | URL подключения к Redis | `redis://localhost:6379/0` |
 
-</details>
+#### 🖥️ Remnawave API
 
-<details>
-<summary>🔍 Мониторинг подписок</summary>
+| Переменная | Описание | Пример |
+|------------|----------|---------|
+| `REMNAWAVE_API_URL` | URL API Remnawave | `https://panel.example.com` |
+| `REMNAWAVE_API_KEY` | JWT токен для API | `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...` |
 
-| Переменная | Описание | По умолчанию |
-|------------|----------|--------------|
-| `MONITOR_ENABLED` | Включить мониторинг | `true` |
-| `MONITOR_CHECK_INTERVAL` | Интервал проверки (сек) | `1800` (30 мин) |
-| `MONITOR_WARNING_DAYS` | За сколько дней предупреждать | `3` |
-| `AUTO_DELETE_ENABLED` | Автоудаление истекших | `true` |
-
-</details>
-
-<details>
-<summary> Триал</summary>
+#### 🎁 Тестовая подписка
 
 | Переменная | Описание | По умолчанию |
 |------------|----------|--------------|
 | `TRIAL_ENABLED` | Включить триал | `true` |
 | `TRIAL_DURATION_DAYS` | Дней триала | `3` |
-| `TRIAL_SQUAD_UUID` | Сквад триальной подписки | `` |
-| `TRIAL_NOTIFICATION_ENABLED` | Уведомление об истечении триал подписки | `true` |
-| `TRIAL_NOTIFICATION_HOURS_AFTER` | Через сколько отсылать сообщение  | `1` |
-| `TRIAL_NOTIFICATION_HOURS_WINDOW` | Через сколько выслать повторно  | `` |
+| `TRIAL_TRAFFIC_LIMIT_GB` | Лимит трафика (ГБ) | `10` |
+| `TRIAL_DEVICE_LIMIT` | Лимит устройств | `2` |
+| `TRIAL_SQUAD_UUID` | UUID сквада для триала | `b96250d4-1455-45b1-ab38-e617a8e8f5ff` |
+| `TRIAL_NOTIFICATION_ENABLED` | Уведомления об истечении | `true` |
+| `TRIAL_NOTIFICATION_HOURS_AFTER` | Через сколько часов уведомить | `1` |
+| `TRIAL_WARNING_HOURS` | За сколько часов предупредить | `2` |
 
+#### 💰 Ценообразование (в копейках)
+
+| Переменная | Описание | По умолчанию |
+|------------|----------|--------------|
+| `BASE_SUBSCRIPTION_PRICE` | Базовая цена подписки | `50000` |
+| `PRICE_14_DAYS` | 14 дней | `5000` |
+| `PRICE_30_DAYS` | 30 дней | `9900` |
+| `PRICE_60_DAYS` | 60 дней | `18900` |
+| `PRICE_90_DAYS` | 90 дней | `26900` |
+| `PRICE_180_DAYS` | 180 дней | `49900` |
+| `PRICE_360_DAYS` | 360 дней | `89900` |
+| `PRICE_TRAFFIC_5GB` | 5 ГБ трафика | `2000` |
+| `PRICE_TRAFFIC_10GB` | 10 ГБ трафика | `4000` |
+| `PRICE_TRAFFIC_25GB` | 25 ГБ трафика | `6000` |
+| `PRICE_TRAFFIC_50GB` | 50 ГБ трафика | `10000` |
+| `PRICE_TRAFFIC_100GB` | 100 ГБ трафика | `15000` |
+| `PRICE_TRAFFIC_250GB` | 250 ГБ трафика | `20000` |
+| `PRICE_TRAFFIC_UNLIMITED` | Безлимитный трафик | `25000` |
+| `PRICE_PER_DEVICE` | Цена за дополнительное устройство | `5000` |
+| `DEFAULT_TRAFFIC_RESET_STRATEGY` | Стратегия сброса трафика | `MONTH` |
+
+#### 🤝 Реферальная система (В копейках)
+
+| Переменная | Описание | По умолчанию |
+|------------|----------|--------------|
+| `REFERRAL_REGISTRATION_REWARD` | Награда за регистрацию реферала | `5000` |
+| `REFERRED_USER_REWARD` | Бонус приглашенному пользователю | `2500` |
+| `REFERRAL_COMMISSION_PERCENT` | % с покупок рефералов | `10` |
+
+#### ⭐ Telegram Stars
+
+| Переменная | Описание | Пример |
+|------------|----------|---------|
+| `TELEGRAM_STARS_ENABLED` | Включить оплату звездами | `true` |
+
+#### 💳 Tribute
+
+| Переменная | Описание | Пример |
+|------------|----------|---------|
+| `TRIBUTE_ENABLED` | Включить оплату через Tribute | `true` |
+| `TRIBUTE_API_KEY` | API ключ Tribute | `d03424f0-8427c-1234-2134-a472439` |
+| `TRIBUTE_DONATE_LINK` | Ссылка на донат | `https://t.me/tribute/app?startapp=XXXX` |
+| `TRIBUTE_WEBHOOK_PATH` | Путь для webhook | `/tribute-webhook` |
+| `TRIBUTE_WEBHOOK_PORT` | Порт для webhook | `8081` |
+| `TRIBUTE_WEBHOOK_SECRET` | Секрет для webhook | `your_webhook_secret` |
+| `WEBHOOK_URL` | URL для webhook | `https://your-domain.com` |
+| `WEBHOOK_PATH` | Путь для webhook (не менять) | `/webhook` |
+
+#### 🔍 Мониторинг и автоплатежи
+
+| Переменная | Описание | По умолчанию |
+|------------|----------|--------------|
+| `MONITORING_INTERVAL` | Интервал мониторинга (сек) | `60` |
+| `AUTOPAY_WARNING_DAYS` | Дни предупреждения о списании | `3,1` |
+| `ENABLE_NOTIFICATIONS` | Включить уведомления | `true` |
+| `NOTIFICATION_RETRY_ATTEMPTS` | Попытки отправки уведомлений | `3` |
+| `MONITORING_LOGS_RETENTION_DAYS` | Хранение логов мониторинга (дни) | `30` |
+| `INACTIVE_USER_DELETE_MONTHS` | Удаление неактивных пользователей (мес) | `3` |
+
+#### 🌐 Локализация и прочее
+
+| Переменная | Описание | По умолчанию |
+|------------|----------|--------------|
+| `DEFAULT_LANGUAGE` | Язык по умолчанию (Англа нет, но все для его реализации есть) | `ru` |
+| `AVAILABLE_LANGUAGES` | Доступные языки | `ru,en` |
+| `LOG_LEVEL` | Уровень логирования | `INFO` |
+| `LOG_FILE` | Файл логов | `/tmp/bot.log` |
+| `DEBUG` | Режим отладки | `false` |
 </details>
 <details>
 <summary>⚙️ Настройка Telegram Tribute</summary>
 
-0) Обновляемся до версии 1.4.0
 1) Регистрируемся и проходим верификацию в Tribute
 2) Создаем донат ссылку, копируем вставляем в .env бота, конфигурируем остальные параметры из .env.example для работы Tribute
 3) Настраиваем обратное прокси на /tribute-webhook
@@ -224,6 +354,16 @@ docker compose exec postgres pg_dump -U remnawave_user remnawave_bot > backup.sq
 <details>
 <summary>🏠 Для локальной установки (панель + бот)</summary>
 
+Используя готовый образ:
+
+```bash
+docker run -d \
+  --name vpn-bot \
+  --env-file .env \
+  -v $(pwd)/logs:/app/logs \
+  fr1ngg/remnawave-bedolaga-telegram-bot:latest
+```
+
 ```yaml
 services:
   postgres:
@@ -252,6 +392,7 @@ services:
       - .env
     environment:
       DATABASE_URL: postgresql+asyncpg://remnawave_user:secure_password_123@postgres:5432/remnawave_bot
+      REDIS_URL: redis://redis:6379/0
     volumes:
       - ./logs:/app/logs
       - ./data:/app/data
@@ -312,8 +453,23 @@ services:
     networks:
       - bot_network
 
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    networks:
+      - bot_network
+
 volumes:
   postgres_data:
+  redis_data:
 
 networks:
   bot_network:
@@ -327,27 +483,50 @@ networks:
 
 ---
 
+### 🔧 Первичная настройка в боте
+
+После успешного запуска бота необходимо выполнить синхронизацию данных:
+
+#### 📡 Синхронизация серверов (обязательно)
+
+1. Зайдите в бот и откройте **Админ панель**
+2. Перейдите в **Подписки** → **Управление серверами**
+3. Нажмите **Синхронизация**
+4. Дождитесь завершения процесса
+
+> ⚠️ **Важно!** Без синхронизации серверов пользователи не смогут выбирать страны при покупке подписки. Сквады из вашей Remnawave панели автоматически импортируются в бота.
+
+#### 👥 Синхронизация пользователей (если есть существующая база)
+
+Если у вас уже были пользователи в Remnawave до установки бота:
+
+1. Зайдите в **Админ панель** → **Remnawave**
+2. Выберите **Синхронизация**
+3. Нажмите **Синхронизировать всех**
+4. Дождитесь завершения импорта пользователей и их подписок
+
+> 💡 **Совет:** Синхронизация может занять несколько минут в зависимости от количества пользователей. Процесс отображается в режиме реального времени.
+
 ## 🎯 Использование
 
 ### 👤 Для пользователей
 
 1. **Запуск** → Найдите бота и нажмите `/start`
-2. **Язык** → Выберите русский или английский  
-3. **Баланс** → "💰 Баланс" → "💳 Пополнить" → Telegram Stars
+2. **Правила** → Примите правила 
+3. **Баланс** → "💰 Баланс" 
 4. **Подписка** → "🛒 Купить подписку" → выбор тарифа → оплата
-5. **Управление** → "📋 Мои подписки" → выбор → получение ссылки
+5. **Управление** → "📋 Мои подписки" → выбор → Конфигурация → получение ссылки
 6. **Рефералы** → "👥 Рефералы" → поделиться ссылкой
 
 ### ⚙️ Для администраторов
 
 Доступ через кнопку **"⚙️ Админ панель"**:
 
-- **📦 Управление подписками** → создание и настройка тарифов
-- **👥 Управление пользователями** → поиск, редактирование балансов
-- **💰 Управление платежами** → одобрение Telegram Stars платежей
-- **🎁 Промокоды** → создание денежных бонусов
-- **📨 Рассылки** → уведомления пользователям
-- **🖥 Система Remnawave** → мониторинг нод, синхронизация
+- **📦 Управление подписками** → создание и настройка серверов, цен
+- **👥 Управление пользователями** → поиск, редактирование балансов, блокировка
+- **🎁 Промокоды** → создание денежных бонусов, подарочных дней подписки 
+- **📨 Рассылки** → уведомления пользователям по критериям 
+- **🖥 Система Remnawave** → мониторинг нод/панели, синхронизация
 - **📊 Статистика** → подробная аналитика
 
 ---
@@ -365,10 +544,10 @@ networks:
 
 ### ⚡ Оптимизация
 
-- **Redis** → включите для кэширования (`--profile with-redis`)
+- **Redis** → включите для кэширования
 - **PostgreSQL** → настройте для production нагрузок
-- **Nginx** → используйте как reverse proxy (`--profile with-nginx`)
-- **Мониторинг** → отслеживайте через `docker stats`
+- **Nginx** → используйте как reverse proxy 
+- **Мониторинг** → отслеживайте через `
 
 ---
 
@@ -392,28 +571,22 @@ sudo systemctl stop bedolaga-bot
 sudo systemctl restart bedolaga-bot
 ```
 
-### 🔄 Обновление
+### 🔄 Обновления
+
+Для получения обновлений:
 
 ```bash
-# Автоматическое через меню
-sudo ./bedolaga.sh
-
-# Ручное обновление
-docker compose down
-docker compose pull bot
-docker compose up -d
+git pull origin main
+pip install -r requirements.txt
+alembic upgrade head
 ```
 
-### 💾 Резервное копирование
+При использовании Docker:
 
 ```bash
-# Создание backup
-docker exec remnawave_bot_db pg_dump -U remnawave_user remnawave_bot > backup.sql
-
-# Восстановление
-docker exec -i remnawave_bot_db psql -U remnawave_user remnawave_bot < backup.sql
+docker pull fr1ngg/remnawave-bedolaga-telegram-bot:latest
+docker-compose up -d
 ```
-
 ---
 
 ## 🐛 Устранение неполадок
@@ -450,12 +623,6 @@ docker exec remnawave_bot env | grep BOT_TOKEN
 ```bash
 # Проверка PostgreSQL
 docker compose logs postgres
-
-# Подключение к БД
-docker exec -it remnawave_bot_db psql -U remnawave_user remnawave_bot
-
-# Экстренное восстановление через меню
-sudo ./bedolaga.sh → "10) Экстренное исправление БД"
 ```
 
 </details>
@@ -479,64 +646,44 @@ docker exec remnawave_bot curl -I http://remnawave:3000
 
 </details>
 
-<details>
-<summary>⚠️ Проблема обновления 1.3.3 → 1.3.4</summary>
-
-**Симптом:** SQL ошибки после обновления связанные с автоплатежами
-
-**Решение через меню:**
-```bash
-sudo ./bedolaga.sh
-# Выберите: "10) Экстренное исправление БД (Python)"
-# Или: "11) Экстренное исправление БД (SQL)"
-```
-
-**Ручное решение:**
-1. Скачайте `emergency_fix.py`
-2. Добавьте в `docker-compose.yml`:
-```yaml
-emergency-fix:
-  image: fr1ngg/remnawave-bedolaga-telegram-bot:latest
-  volumes:
-    - ./emergency_fix.py:/app/emergency_fix.py
-  environment:
-    - DATABASE_URL=postgresql+asyncpg://remnawave_user:secure_password_123@postgres:5432/remnawave_bot
-  networks:
-    - bot_network
-  profiles:
-    - emergency
-  command: python emergency_fix.py
-```
-3. Запустите: `docker compose run --rm emergency-fix`
-
-</details>
-
 ---
 
+## 🔒 Безопасность
+
+- Все пароли и ключи хранятся в переменных окружения
+- Валидация всех пользовательских данных
+- Защита от SQL инъекций через SQLAlchemy ORM
+- Middleware для авторизации и ограничения запросов
+- Логирование всех важных операций
+
 ## 🗺️ Roadmap
 
 ### ✅ Реализовано
-
+-----------------------------------------------------------------------------
+---------------------------Версия 1.0.0-1.4.2--------------------------------
 - ✅ **Мониторинг подписок** - автоуведомления и контроль
 - ✅ **Telegram Stars** - пополнение баланса звездами  
 - ✅ **Синхронизация Remnawave** - импорт пользователей и статистика
 - ✅ **Реферальная система** - полнофункциональная программа
-- ✅ **Игра удачи** - ежедневные розыгрыши бонусов
+- ✅ **Игра удачи** - ежедневные розыгрыши бонусов (вырезано в версии 2.0)
 - ✅ **Управление промокодами** - создание, редактирование, статистика
 - ✅ **Правила сервиса** - настройка через админ-панель
 - ✅ **Автоплатежи** - настраиваемое автопродление подписок
 - ✅ **Просмотр подписок пользователей** - детальная статистика
-- - ✅ **Автоматическое пополнение лк с помощью доната Tribute**
+- ✅ **Автоматическое пополнение лк с помощью доната Tribute**
+-----------------------------------------------------------------------------
+---------------------------Версия 2.0.0+-------------------------------------
+- 🌟 Глобальное обновление 2.0 - полное обновление архитектуры, отказ от мультиподписок -> переход к единой конфигурируемой подписке
+
+  
 ### 🎯 В планах
 
 | Версия | Функция | Приоритет | Описание |
 |--------|---------|-----------|----------|
-| **v1.4.5** | Юкасса интеграция | 🔴 High | Автоматические платежи |
-| **v1.4.5** | Веб-панель управления | 🟡 Medium | Полный веб-интерфейс |
-| **v1.4.5** | Безопасное удаление | 🟡 Medium | Архивирование вместо удаления |
-| **v1.5.0** | Дополнительные платежи | 🟡 Medium | Сбербанк, Tinkoff, Crypto |
-| **v1.5.0** | Уведомления | 🟡 Medium | Webhook, Email, другие чаты |
-| **v1.6.0** | Система блокировок | 🟢 Low | Бан/разбан пользователей |
+| **v2.1.0** | Юкасса интеграция | 🔴 High | Автоматические платежи |
+| **v2.2.0+** | Веб-панель управления | 🟡 Medium | Полный веб-интерфейс |
+| **v2.3.0+** | Дополнительные платежи | 🟡 Medium | Сбербанк, Tinkoff, Crypto |
+| **v2.3.0** | Уведомления | 🟡 Medium | Webhook, Email, другие чаты |
 
 ### 💡 Хотите добавить функцию?
 
@@ -617,8 +764,10 @@ emergency-fix:
 
 | Донатер | Сумма |
 |---------|-------|
-| Илья (@ispanec_nn) | $15 |
-| @Legacyyy777 | 600 руб |
+| 1) Илья (@ispanec_nn) | $15 |
+| 2) @pilot_737800 | 1250 руб |
+| 3) @Legacyyy777 | 600 руб |
+| 4) @Legacyyy777 | 400 руб |
 
 ---
 

api_error_handlers.py

@@ -1,201 +0,0 @@
-import logging
-from typing import Optional, Dict, Any, Callable
-from aiogram.types import CallbackQuery
-from aiogram import Router
-from remnawave_api import RemnaWaveAPI
-from translations import t
-
-logger = logging.getLogger(__name__)
-
-class APIErrorHandler:
-    
-    @staticmethod
-    async def handle_api_error(callback: CallbackQuery, error: Exception, 
-                             operation: str, user_language: str = 'ru',
-                             fallback_keyboard=None) -> bool:
-        error_message = str(error).lower()
-        
-        if "timeout" in error_message or "connection" in error_message:
-            text = "⏱ Таймаут подключения к API\n\n"
-            text += "Возможные причины:\n"
-            text += "• Медленный интернет\n"
-            text += "• Перегрузка сервера RemnaWave\n"
-            text += "• Временные проблемы с сетью\n\n"
-            text += "🔄 Попробуйте повторить операцию через несколько секунд"
-            
-        elif "401" in error_message or "unauthorized" in error_message:
-            text = "🔐 Ошибка авторизации API\n\n"
-            text += "Токен доступа недействителен или истек.\n"
-            text += "Обратитесь к администратору для обновления токена."
-            
-        elif "404" in error_message or "not found" in error_message:
-            text = f"❌ Ресурс не найден\n\n"
-            text += f"Операция: {operation}\n"
-            text += "Возможно, запрашиваемый объект был удален или не существует."
-            
-        elif "500" in error_message or "internal server error" in error_message:
-            text = "🔥 Внутренняя ошибка сервера RemnaWave\n\n"
-            text += "Сервер временно недоступен.\n"
-            text += "Попробуйте повторить операцию позже."
-            
-        else:
-            text = f"❌ Ошибка API операции: {operation}\n\n"
-            text += f"Детали: {str(error)[:100]}{'...' if len(str(error)) > 100 else ''}\n\n"
-            text += "Обратитесь к администратору если проблема повторяется."
-        
-        try:
-            await callback.message.edit_text(
-                text,
-                reply_markup=fallback_keyboard or error_recovery_keyboard(operation, user_language)
-            )
-            return True
-        except Exception as edit_error:
-            logger.error(f"Failed to edit message with error info: {edit_error}")
-            try:
-                await callback.answer(f"❌ Ошибка: {operation}", show_alert=True)
-                return True
-            except:
-                return False
-
-    @staticmethod
-    async def safe_api_call(api_method: Callable, *args, **kwargs) -> tuple[bool, Any]:
-        try:
-            result = await api_method(*args, **kwargs)
-            return True, result
-        except Exception as e:
-            logger.error(f"API call failed: {api_method.__name__} - {e}")
-            return False, str(e)
-
-def create_error_recovery_keyboard(error_context: str, language: str = 'ru'):
-    from keyboards import error_recovery_keyboard
-    return error_recovery_keyboard(error_context, language)
-
-async def safe_get_nodes(api: RemnaWaveAPI) -> tuple[bool, list]:
-    try:
-        logger.info("Attempting to fetch nodes from API...")
-        nodes = await api.get_all_nodes()
-        
-        if nodes is None:
-            logger.warning("API returned None for nodes")
-            return False, []
-        
-        if not isinstance(nodes, list):
-            logger.warning(f"API returned non-list for nodes: {type(nodes)}")
-            return False, []
-        
-        logger.info(f"Successfully fetched {len(nodes)} nodes")
-        return True, nodes
-        
-    except Exception as e:
-        logger.error(f"Error fetching nodes: {e}")
-        return False, []
-
-async def safe_get_system_users(api: RemnaWaveAPI) -> tuple[bool, list]:
-    try:
-        logger.info("Attempting to fetch system users from API...")
-        users = await api.get_all_system_users_full()
-        
-        if users is None:
-            logger.warning("API returned None for users")
-            return False, []
-        
-        if not isinstance(users, list):
-            logger.warning(f"API returned non-list for users: {type(users)}")
-            return False, []
-        
-        logger.info(f"Successfully fetched {len(users)} users")
-        return True, users
-        
-    except Exception as e:
-        logger.error(f"Error fetching system users: {e}")
-        return False, []
-
-async def safe_restart_nodes(api: RemnaWaveAPI, all_nodes: bool = True, node_id: str = None) -> tuple[bool, str]:
-    try:
-        if all_nodes:
-            logger.info("Attempting to restart all nodes...")
-            result = await api.restart_all_nodes()
-        else:
-            logger.info(f"Attempting to restart node {node_id}...")
-            result = await api.restart_node(node_id)
-        
-        if result:
-            message = "Команда перезагрузки отправлена успешно"
-            logger.info(f"Restart command sent successfully")
-            return True, message
-        else:
-            message = "API вернул отрицательный результат"
-            logger.warning("API returned negative result for restart")
-            return False, message
-            
-    except Exception as e:
-        logger.error(f"Error restarting nodes: {e}")
-        return False, str(e)
-
-async def check_api_health(api: RemnaWaveAPI) -> Dict[str, Any]:
-    health_info = {
-        'api_available': False,
-        'nodes_accessible': False,
-        'users_accessible': False,
-        'system_stats_accessible': False,
-        'errors': []
-    }
-    
-    if api is None:
-        health_info['errors'].append("API instance is None")
-        return health_info
-    
-    try:
-        success, nodes = await safe_get_nodes(api)
-        if success:
-            health_info['api_available'] = True
-            health_info['nodes_accessible'] = True
-        else:
-            health_info['errors'].append("Cannot fetch nodes")
-    except Exception as e:
-        health_info['errors'].append(f"Nodes check failed: {e}")
-    
-    try:
-        success, users = await safe_get_system_users(api)
-        if success:
-            health_info['users_accessible'] = True
-        else:
-            health_info['errors'].append("Cannot fetch users")
-    except Exception as e:
-        health_info['errors'].append(f"Users check failed: {e}")
-    
-    try:
-        stats = await api.get_system_stats()
-        if stats:
-            health_info['system_stats_accessible'] = True
-        else:
-            health_info['errors'].append("Cannot fetch system stats")
-    except Exception as e:
-        health_info['errors'].append(f"System stats check failed: {e}")
-    
-    return health_info
-
-def handle_api_errors(operation_name: str):
-    def decorator(func):
-        async def wrapper(callback: CallbackQuery, user, *args, **kwargs):
-            try:
-                return await func(callback, user, *args, **kwargs)
-            except Exception as e:
-                logger.error(f"Error in {func.__name__}: {e}")
-                
-                api = kwargs.get('api')
-                fallback_keyboard = None
-                
-                if 'nodes' in operation_name.lower():
-                    from keyboards import admin_system_keyboard
-                    fallback_keyboard = admin_system_keyboard(user.language)
-                elif 'users' in operation_name.lower():
-                    from keyboards import system_users_keyboard
-                    fallback_keyboard = system_users_keyboard(user.language)
-                
-                await APIErrorHandler.handle_api_error(
-                    callback, e, operation_name, user.language, fallback_keyboard
-                )
-        
-        return wrapper
-    return decorator

app-config.json

@@ -0,0 +1,163 @@
+{
+  "ios": [
+    {
+      "id": "happ",
+      "name": "Happ",
+      "isFeatured": true,
+      "urlScheme": "happ://add/",
+      "installationStep": {
+        "buttons": [
+          {
+            "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215",
+            "buttonText": {
+              "en": "App Store [EU]",
+              "ru": "App Store [EU]"
+            }
+          },
+          {
+            "buttonLink": "https://apps.apple.com/ru/app/happ-proxy-utility-plus/id6746188973",
+            "buttonText": {
+              "en": "App Store [RU]",
+              "ru": "App Store [RU]"
+            }
+          }
+        ],
+        "description": {
+          "en": "Open the page in App Store and install the app. Launch it, in the VPN configuration permission window click Allow and enter your passcode.",
+          "ru": "Откройте страницу в App Store и установите приложение. Вернись на страницу с подпиской"
+        }
+      },
+      "addSubscriptionStep": {
+        "description": {
+          "en": "Click the button below — the app will open and the subscription will be added automatically",
+          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
+        }
+      },
+      "connectAndUseStep": {
+        "description": {
+          "en": "In the main section, click the large power button in the center to connect to VPN. Don't forget to select a server from the server list. If needed, choose another server from the server list.",
+          "ru": "В главном разделе нажмите большую кнопку включения в центре для подключения к VPN. Не забудьте выбрать сервер в списке серверов. При необходимости выберите другой сервер из списка серверов."
+        }
+      }
+    }
+  ],
+  "android": [
+    {
+      "id": "happ",
+      "name": "Happ",
+      "isFeatured": true,
+      "urlScheme": "happ://add/",
+      "installationStep": {
+        "buttons": [
+          {
+            "buttonLink": "https://play.google.com/store/apps/details?id=com.happproxy",
+            "buttonText": {
+              "en": "Google Play",
+              "ru": "Google Play"
+            }
+          },
+          {
+            "buttonLink": "https://github.com/Happ-proxy/happ-android/releases/latest/download/Happ.apk",
+            "buttonText": {
+              "en": "Download APK",
+              "ru": "Скачать APK"
+            }
+          }
+        ],
+        "description": {
+          "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
+          "ru": "Откройте страницу в Google Play и установите приложение. Или установите приложение из APK файла напрямую, если Google Play не работает."
+        }
+      },
+      "addSubscriptionStep": {
+        "description": {
+          "en": "Click the button below to add subscription",
+          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
+        }
+      },
+      "connectAndUseStep": {
+        "description": {
+          "en": "Open the app and connect to the server",
+          "ru": "Откройте приложение и подключитесь к серверу"
+        }
+      }
+    }
+  ],
+  "pc": [
+    {
+      "id": "happ",
+      "name": "Happ",
+      "isFeatured": false,
+      "urlScheme": "happ://add/",
+      "installationStep": {
+        "buttons": [
+          {
+            "buttonLink": "https://apps.apple.com/us/app/happ-proxy-utility/id6504287215?l=ru",
+            "buttonText": {
+              "en": "Mac Os",
+              "ru": "Mac Os"
+            }
+          },
+          {
+            "buttonLink": "https://github.com/Happ-proxy/happ-desktop/releases/latest/download/setup-Happ.x86.exe",
+            "buttonText": {
+              "en": "Windows",
+              "ru": "Windows"
+            }
+          }
+        ],
+        "description": {
+          "en": "Choose the version for your device, click the button below and install the app.",
+          "ru": "Выберите подходящую версию для вашего устройства, нажмите на кнопку ниже и установите приложение"
+        }
+      },
+      "addSubscriptionStep": {
+        "description": {
+          "en": "Click the button below to add subscription",
+          "ru": "Нажмите кнопку выше — (Подключить подписку) приложение откроется, и подписка добавится автоматически."
+        }
+      },
+      "connectAndUseStep": {
+        "description": {
+          "en": "You can select a server",
+          "ru": "Выберете локацию, включить VPN"
+        }
+      }
+    }
+  ],
+  "tv": [
+    {
+      "id": "vpn4tv",
+      "name": "VPN4TV",
+      "isFeatured": true,
+      "urlScheme": "",
+      "installationStep": {
+        "buttons": [
+          {
+            "buttonLink": "https://play.google.com/store/apps/details?id=com.vpn4tv.hiddify",
+            "buttonText": {
+              "en": "Google Play",
+              "ru": "Google Play"
+            }
+          }
+        ],
+        "description": {
+          "en": "Open the page in Google Play and install the app. Or install the app directly from the APK file if Google Play is not working.",
+          "ru": "Откройте страницу в Google Play и установите приложение"
+        }
+      },
+      "addSubscriptionStep": {
+        "description": {
+          "en": "Click the button below to add subscription",
+          "ru": "Нажмите кнопку выше — (Скопировать ссылку подписки) ты скопируешь свою подписку, далее на телевизоре открой VPN4TV, следуя инструкция передай telegram боту ссылку, которую ты скопировал"
+        }
+      },
+      "connectAndUseStep": {
+        "description": {
+          "en": "Open the app and connect to the server",
+          "ru": "Приложение автоматически обновится и загрузит нужные конфиги на твой телевизор, подключай VPN"
+        }
+      }
+    }
+  ]
+}

app/bot.py

@@ -0,0 +1,88 @@
+import logging
+from aiogram import Bot, Dispatcher, types
+from aiogram.fsm.storage.redis import RedisStorage
+from aiogram.fsm.storage.memory import MemoryStorage
+import redis.asyncio as redis
+
+from app.config import settings
+from app.middlewares.auth import AuthMiddleware
+from app.middlewares.logging import LoggingMiddleware
+from app.middlewares.throttling import ThrottlingMiddleware
+from app.utils.cache import cache 
+
+from app.handlers import (
+    start, menu, subscription, balance, promocode, 
+    referral, support, common
+)
+from app.handlers.admin import (
+    main as admin_main, users as admin_users, subscriptions as admin_subscriptions,
+    promocodes as admin_promocodes, messages as admin_messages,
+    monitoring as admin_monitoring, referrals as admin_referrals,
+    rules as admin_rules, remnawave as admin_remnawave,
+    statistics as admin_statistics, servers as admin_servers  
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def debug_callback_handler(callback: types.CallbackQuery):
+    logger.info(f"🔍 DEBUG CALLBACK:")
+    logger.info(f"  - Data: {callback.data}")
+    logger.info(f"  - User: {callback.from_user.id}")
+    logger.info(f"  - Username: {callback.from_user.username}")
+
+
+async def setup_bot() -> tuple[Bot, Dispatcher]:
+    
+    try:
+        await cache.connect()
+        logger.info("✅ Кеш инициализирован")
+    except Exception as e:
+        logger.warning(f"⚠️ Кеш не инициализирован: {e}")
+    
+    bot = Bot(token=settings.BOT_TOKEN, parse_mode="HTML")
+    
+    try:
+        redis_client = redis.from_url(settings.REDIS_URL)
+        await redis_client.ping()
+        storage = RedisStorage(redis_client)
+        logger.info("✅ Подключено к Redis для FSM storage")
+    except Exception as e:
+        logger.warning(f"⚠️ Не удалось подключиться к Redis: {e}")
+        logger.info("🔄 Используется MemoryStorage для FSM")
+        storage = MemoryStorage()
+    
+    dp = Dispatcher(storage=storage)
+    
+    dp.message.middleware(LoggingMiddleware())
+    dp.callback_query.middleware(LoggingMiddleware())
+    dp.message.middleware(AuthMiddleware())
+    dp.callback_query.middleware(AuthMiddleware())
+    dp.message.middleware(ThrottlingMiddleware())
+    dp.callback_query.middleware(ThrottlingMiddleware())
+
+    start.register_handlers(dp)
+    menu.register_handlers(dp)
+    subscription.register_handlers(dp)
+    balance.register_handlers(dp)
+    promocode.register_handlers(dp)
+    referral.register_handlers(dp)
+    support.register_handlers(dp)
+    
+    admin_main.register_handlers(dp)
+    admin_users.register_handlers(dp)
+    admin_subscriptions.register_handlers(dp)
+    admin_servers.register_handlers(dp)  
+    admin_promocodes.register_handlers(dp)
+    admin_messages.register_handlers(dp)
+    admin_monitoring.register_handlers(dp)
+    admin_referrals.register_handlers(dp)
+    admin_rules.register_handlers(dp)
+    admin_remnawave.register_handlers(dp)
+    admin_statistics.register_handlers(dp)
+
+    common.register_handlers(dp)
+    
+    logger.info("✅ Бот успешно настроен")
+    
+    return bot, dp

app/config.py

@@ -0,0 +1,188 @@
+import os
+from typing import List, Optional, Union
+from pydantic_settings import BaseSettings
+from pydantic import field_validator, Field
+from pathlib import Path
+
+
+class Settings(BaseSettings):
+    
+    BOT_TOKEN: str
+    ADMIN_IDS: str = ""
+    SUPPORT_USERNAME: str = "@support"
+    
+    DATABASE_URL: str
+    REDIS_URL: str = "redis://localhost:6379/0"
+    
+    REMNAWAVE_API_URL: str
+    REMNAWAVE_API_KEY: str
+    
+    TRIAL_DURATION_DAYS: int = 3
+    TRIAL_TRAFFIC_LIMIT_GB: int = 10
+    TRIAL_DEVICE_LIMIT: int = 2
+    TRIAL_SQUAD_UUID: str
+    DEFAULT_TRAFFIC_RESET_STRATEGY: str = "MONTH"
+    
+    TRIAL_WARNING_HOURS: int = 2 
+    ENABLE_NOTIFICATIONS: bool = True 
+    NOTIFICATION_RETRY_ATTEMPTS: int = 3 
+    
+    MONITORING_LOGS_RETENTION_DAYS: int = 30 
+    NOTIFICATION_CACHE_HOURS: int = 24  
+    
+    BASE_SUBSCRIPTION_PRICE: int = 50000
+    
+    PRICE_14_DAYS: int = 50000
+    PRICE_30_DAYS: int = 99000
+    PRICE_60_DAYS: int = 189000
+    PRICE_90_DAYS: int = 269000
+    PRICE_180_DAYS: int = 499000
+    PRICE_360_DAYS: int = 899000
+    
+    PRICE_TRAFFIC_5GB: int = 10000
+    PRICE_TRAFFIC_10GB: int = 19000
+    PRICE_TRAFFIC_25GB: int = 45000
+    PRICE_TRAFFIC_50GB: int = 85000
+    PRICE_TRAFFIC_100GB: int = 159000
+    PRICE_TRAFFIC_250GB: int = 369000
+    PRICE_TRAFFIC_UNLIMITED: int = 0
+    
+    PRICE_PER_DEVICE: int = 5000
+    
+    REFERRAL_REGISTRATION_REWARD: int = 5000
+    REFERRED_USER_REWARD: int = 2500
+    REFERRAL_COMMISSION_PERCENT: int = 10
+    
+    AUTOPAY_WARNING_DAYS: str = "3,1"
+    
+    DEFAULT_AUTOPAY_DAYS_BEFORE: int = 3 
+    MIN_BALANCE_FOR_AUTOPAY_KOPEKS: int = 10000  
+    
+    MONITORING_INTERVAL: int = 60
+    INACTIVE_USER_DELETE_MONTHS: int = 3
+    
+    TELEGRAM_STARS_ENABLED: bool = True
+    
+    TRIBUTE_ENABLED: bool = False
+    TRIBUTE_API_KEY: Optional[str] = None
+    TRIBUTE_WEBHOOK_SECRET: Optional[str] = None
+    TRIBUTE_DONATE_LINK: Optional[str] = None
+    TRIBUTE_WEBHOOK_PATH: str = "/tribute-webhook"
+    TRIBUTE_WEBHOOK_PORT: int = 8081
+    
+    DEFAULT_LANGUAGE: str = "ru"
+    AVAILABLE_LANGUAGES: str = "ru,en"
+    
+    LOG_LEVEL: str = "INFO"
+    LOG_FILE: str = "logs/bot.log"
+    
+    DEBUG: bool = False
+    WEBHOOK_URL: Optional[str] = None
+    WEBHOOK_PATH: str = "/webhook"
+    
+    APP_CONFIG_PATH: str = "app-config.json"
+    ENABLE_DEEP_LINKS: bool = True
+    APP_CONFIG_CACHE_TTL: int = 3600  # 1 час
+    
+    @field_validator('LOG_FILE', mode='before')
+    @classmethod
+    def ensure_log_dir(cls, v):
+        log_path = Path(v)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        return str(log_path)
+    
+    def is_admin(self, user_id: int) -> bool:
+        return user_id in self.get_admin_ids()
+    
+    def get_admin_ids(self) -> List[int]:
+        try:
+            admin_ids = self.ADMIN_IDS
+            
+            if isinstance(admin_ids, str):
+                if not admin_ids.strip():
+                    return []
+                return [int(x.strip()) for x in admin_ids.split(',') if x.strip()]
+            
+            return []
+            
+        except (ValueError, AttributeError):
+            return []
+    
+    def get_autopay_warning_days(self) -> List[int]:
+        try:
+            days = self.AUTOPAY_WARNING_DAYS
+            if isinstance(days, str):
+                if not days.strip():
+                    return [3, 1]
+                return [int(x.strip()) for x in days.split(',') if x.strip()]
+            return [3, 1]
+        except (ValueError, AttributeError):
+            return [3, 1]
+    
+    def get_available_languages(self) -> List[str]:
+        try:
+            langs = self.AVAILABLE_LANGUAGES
+            if isinstance(langs, str):
+                if not langs.strip():
+                    return ["ru", "en"]
+                return [x.strip() for x in langs.split(',') if x.strip()]
+            return ["ru", "en"]
+        except AttributeError:
+            return ["ru", "en"]
+    
+    def format_price(self, price_kopeks: int) -> str:
+        rubles = price_kopeks / 100
+        return f"{rubles:.2f} ₽"
+    
+    def kopeks_to_rubles(self, kopeks: int) -> float:
+        return kopeks / 100
+    
+    def rubles_to_kopeks(self, rubles: float) -> int:
+        return int(rubles * 100)
+    
+    def get_trial_warning_hours(self) -> int:
+        return self.TRIAL_WARNING_HOURS
+    
+    def is_notifications_enabled(self) -> bool:
+        return self.ENABLE_NOTIFICATIONS
+    
+    def get_app_config_path(self) -> str:
+        if os.path.isabs(self.APP_CONFIG_PATH):
+            return self.APP_CONFIG_PATH
+        
+        project_root = Path(__file__).parent.parent
+        return str(project_root / self.APP_CONFIG_PATH)
+    
+    def is_deep_links_enabled(self) -> bool:
+        return self.ENABLE_DEEP_LINKS
+    
+    def get_app_config_cache_ttl(self) -> int:
+        return self.APP_CONFIG_CACHE_TTL
+    
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8"
+    }
+
+
+settings = Settings()
+
+
+PERIOD_PRICES = {
+    14: settings.PRICE_14_DAYS,
+    30: settings.PRICE_30_DAYS,
+    60: settings.PRICE_60_DAYS,
+    90: settings.PRICE_90_DAYS,
+    180: settings.PRICE_180_DAYS,
+    360: settings.PRICE_360_DAYS,
+}
+
+TRAFFIC_PRICES = {
+    5: settings.PRICE_TRAFFIC_5GB,
+    10: settings.PRICE_TRAFFIC_10GB,
+    25: settings.PRICE_TRAFFIC_25GB,
+    50: settings.PRICE_TRAFFIC_50GB,
+    100: settings.PRICE_TRAFFIC_100GB,
+    250: settings.PRICE_TRAFFIC_250GB,
+    0: settings.PRICE_TRAFFIC_UNLIMITED, 
+}

app/database/crud/promocode.py

@@ -0,0 +1,236 @@
+import logging
+from datetime import datetime
+from typing import Optional, List
+from sqlalchemy import select, and_, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import PromoCode, PromoCodeUse, PromoCodeType
+
+logger = logging.getLogger(__name__)
+
+
+async def get_promocode_by_code(db: AsyncSession, code: str) -> Optional[PromoCode]:
+    result = await db.execute(
+        select(PromoCode)
+        .options(selectinload(PromoCode.uses))
+        .where(PromoCode.code == code.upper())
+    )
+    return result.scalar_one_or_none()
+
+
+async def create_promocode(
+    db: AsyncSession,
+    code: str,
+    type: PromoCodeType,
+    balance_bonus_kopeks: int = 0,
+    subscription_days: int = 0,
+    max_uses: int = 1,
+    valid_until: Optional[datetime] = None,
+    created_by: Optional[int] = None
+) -> PromoCode:
+    
+    promocode = PromoCode(
+        code=code.upper(),
+        type=type.value,
+        balance_bonus_kopeks=balance_bonus_kopeks,
+        subscription_days=subscription_days,
+        max_uses=max_uses,
+        valid_until=valid_until,
+        created_by=created_by
+    )
+    
+    db.add(promocode)
+    await db.commit()
+    await db.refresh(promocode)
+    
+    logger.info(f"✅ Создан промокод: {code}")
+    return promocode
+
+
+async def use_promocode(
+    db: AsyncSession,
+    promocode_id: int,
+    user_id: int
+) -> bool:
+    
+    try:
+        promocode = await db.get(PromoCode, promocode_id)
+        if not promocode:
+            return False
+        
+        usage = PromoCodeUse(
+            promocode_id=promocode_id,
+            user_id=user_id
+        )
+        db.add(usage)
+        
+        promocode.current_uses += 1
+        
+        await db.commit()
+        
+        logger.info(f"✅ Промокод {promocode.code} использован пользователем {user_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка использования промокода: {e}")
+        await db.rollback()
+        return False
+
+
+async def check_user_promocode_usage(
+    db: AsyncSession,
+    user_id: int,
+    promocode_id: int
+) -> bool:
+    
+    result = await db.execute(
+        select(PromoCodeUse).where(
+            and_(
+                PromoCodeUse.user_id == user_id,
+                PromoCodeUse.promocode_id == promocode_id
+            )
+        )
+    )
+    return result.scalar_one_or_none() is not None
+
+
+
+async def create_promocode_use(db: AsyncSession, promocode_id: int, user_id: int) -> PromoCodeUse:
+    promocode_use = PromoCodeUse(
+        promocode_id=promocode_id,
+        user_id=user_id,
+        used_at=datetime.utcnow()
+    )
+    
+    db.add(promocode_use)
+    await db.commit()
+    await db.refresh(promocode_use)
+    
+    logger.info(f"📝 Записано использование промокода {promocode_id} пользователем {user_id}")
+    return promocode_use
+
+
+async def get_promocode_use_by_user_and_code(
+    db: AsyncSession, 
+    user_id: int, 
+    promocode_id: int
+) -> Optional[PromoCodeUse]:
+    result = await db.execute(
+        select(PromoCodeUse).where(
+            and_(
+                PromoCodeUse.user_id == user_id,
+                PromoCodeUse.promocode_id == promocode_id
+            )
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_user_promocodes(db: AsyncSession, user_id: int) -> List[PromoCodeUse]:
+    result = await db.execute(
+        select(PromoCodeUse)
+        .where(PromoCodeUse.user_id == user_id)
+        .order_by(PromoCodeUse.used_at.desc())
+    )
+    return result.scalars().all()
+
+
+
+async def get_promocodes_list(
+    db: AsyncSession,
+    offset: int = 0,
+    limit: int = 50,
+    is_active: Optional[bool] = None
+) -> List[PromoCode]:
+    
+    query = select(PromoCode).options(selectinload(PromoCode.uses))
+    
+    if is_active is not None:
+        query = query.where(PromoCode.is_active == is_active)
+    
+    query = query.order_by(PromoCode.created_at.desc()).offset(offset).limit(limit)
+    
+    result = await db.execute(query)
+    return result.scalars().all()
+
+
+async def get_promocodes_count(
+    db: AsyncSession,
+    is_active: Optional[bool] = None
+) -> int:
+    
+    query = select(func.count(PromoCode.id))
+    
+    if is_active is not None:
+        query = query.where(PromoCode.is_active == is_active)
+    
+    result = await db.execute(query)
+    return result.scalar()
+
+
+async def update_promocode(
+    db: AsyncSession,
+    promocode: PromoCode,
+    **kwargs
+) -> PromoCode:
+    
+    for field, value in kwargs.items():
+        if hasattr(promocode, field):
+            setattr(promocode, field, value)
+    
+    promocode.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(promocode)
+    
+    return promocode
+
+
+async def delete_promocode(db: AsyncSession, promocode: PromoCode) -> bool:
+    
+    try:
+        await db.delete(promocode)
+        await db.commit()
+        
+        logger.info(f"🗑️ Удален промокод: {promocode.code}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка удаления промокода: {e}")
+        await db.rollback()
+        return False
+
+
+async def get_promocode_statistics(db: AsyncSession, promocode_id: int) -> dict:
+    
+    total_uses_result = await db.execute(
+        select(func.count(PromoCodeUse.id))
+        .where(PromoCodeUse.promocode_id == promocode_id)
+    )
+    total_uses = total_uses_result.scalar()
+    
+    today = datetime.utcnow().date()
+    today_uses_result = await db.execute(
+        select(func.count(PromoCodeUse.id))
+        .where(
+            and_(
+                PromoCodeUse.promocode_id == promocode_id,
+                PromoCodeUse.used_at >= today
+            )
+        )
+    )
+    today_uses = today_uses_result.scalar()
+    
+    recent_uses_result = await db.execute(
+        select(PromoCodeUse)
+        .where(PromoCodeUse.promocode_id == promocode_id)
+        .order_by(PromoCodeUse.used_at.desc())
+        .limit(10)
+    )
+    recent_uses = recent_uses_result.scalars().all()
+    
+    return {
+        "total_uses": total_uses,
+        "today_uses": today_uses,
+        "recent_uses": recent_uses
+    }

app/database/crud/referral.py

@@ -0,0 +1,268 @@
+import logging
+from datetime import datetime, timedelta
+from typing import List, Optional
+from sqlalchemy import select, and_, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import ReferralEarning, User
+
+logger = logging.getLogger(__name__)
+
+
+async def create_referral_earning(
+    db: AsyncSession,
+    user_id: int,
+    referral_id: int,
+    amount_kopeks: int,
+    reason: str,
+    referral_transaction_id: Optional[int] = None
+) -> ReferralEarning:
+    
+    earning = ReferralEarning(
+        user_id=user_id,
+        referral_id=referral_id,
+        amount_kopeks=amount_kopeks,
+        reason=reason,
+        referral_transaction_id=referral_transaction_id
+    )
+    
+    db.add(earning)
+    await db.commit()
+    await db.refresh(earning)
+    
+    logger.info(f"💰 Создан реферальный заработок: {amount_kopeks/100}₽ для пользователя {user_id}")
+    return earning
+
+
+async def get_referral_earnings_by_user(
+    db: AsyncSession,
+    user_id: int,
+    limit: int = 50,
+    offset: int = 0
+) -> List[ReferralEarning]:
+    
+    result = await db.execute(
+        select(ReferralEarning)
+        .options(
+            selectinload(ReferralEarning.referral),
+            selectinload(ReferralEarning.referral_transaction)
+        )
+        .where(ReferralEarning.user_id == user_id)
+        .order_by(ReferralEarning.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+    return result.scalars().all()
+
+
+async def get_referral_earnings_by_referral(
+    db: AsyncSession,
+    referral_id: int
+) -> List[ReferralEarning]:
+    
+    result = await db.execute(
+        select(ReferralEarning)
+        .where(ReferralEarning.referral_id == referral_id)
+        .order_by(ReferralEarning.created_at.desc())
+    )
+    return result.scalars().all()
+
+
+async def get_referral_earnings_sum(
+    db: AsyncSession,
+    user_id: int,
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None
+) -> int:
+    
+    query = select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0)).where(
+        ReferralEarning.user_id == user_id
+    )
+    
+    if start_date:
+        query = query.where(ReferralEarning.created_at >= start_date)
+    
+    if end_date:
+        query = query.where(ReferralEarning.created_at <= end_date)
+    
+    result = await db.execute(query)
+    return result.scalar()
+
+
+async def get_referral_statistics(db: AsyncSession) -> dict:
+    users_with_referrals_result = await db.execute(
+        select(func.count(func.distinct(User.id)))
+        .where(User.referred_by_id.isnot(None))
+    )
+    users_with_referrals = users_with_referrals_result.scalar()
+    
+    active_referrers_result = await db.execute(
+        select(func.count(func.distinct(User.referred_by_id)))
+        .where(User.referred_by_id.isnot(None))
+    )
+    active_referrers = active_referrers_result.scalar()
+    
+    referral_paid_result = await db.execute(
+        select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+    )
+    referral_paid = referral_paid_result.scalar()
+    
+    from app.database.models import Transaction, TransactionType
+    transaction_paid_result = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(Transaction.type == TransactionType.REFERRAL_REWARD.value)
+    )
+    transaction_paid = transaction_paid_result.scalar()
+    
+    total_paid = referral_paid + transaction_paid
+    
+    top_referrers_result = await db.execute(
+        select(
+            User.referred_by_id.label('referrer_id'),
+            func.count(User.id).label('referrals_count'),
+            func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0).label('referral_earnings'),
+            func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('transaction_earnings')
+        )
+        .outerjoin(
+            ReferralEarning, 
+            ReferralEarning.user_id == User.referred_by_id
+        )
+        .outerjoin(
+            Transaction,
+            and_(
+                Transaction.user_id == User.referred_by_id,
+                Transaction.type == TransactionType.REFERRAL_REWARD.value
+            )
+        )
+        .where(
+            and_(
+                User.referred_by_id.isnot(None),
+                User.referred_by_id != User.id 
+            )
+        )
+        .group_by(User.referred_by_id)
+        .order_by(func.count(User.id).desc())
+        .limit(5)
+    )
+    top_referrers_raw = top_referrers_result.all()
+    
+    top_referrers = []
+    for row in top_referrers_raw:
+        user_result = await db.execute(
+            select(User.id, User.username, User.first_name, User.last_name, User.telegram_id)
+            .where(User.id == row.referrer_id)
+        )
+        user = user_result.first()
+        
+        if user:
+            display_name = ""
+            if user.first_name:
+                display_name = user.first_name
+                if user.last_name:
+                    display_name += f" {user.last_name}"
+            elif user.username:
+                display_name = f"@{user.username}"
+            else:
+                display_name = f"ID{user.telegram_id}"
+            
+            total_earned = (row.referral_earnings or 0) + (row.transaction_earnings or 0)
+            
+            top_referrers.append({
+                "user_id": row.referrer_id,
+                "display_name": display_name,
+                "username": user.username,
+                "total_earned_kopeks": total_earned,
+                "referrals_count": row.referrals_count
+            })
+    
+    today = datetime.utcnow().date()
+    
+    today_referral_earnings = await db.execute(
+        select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+        .where(ReferralEarning.created_at >= today)
+    )
+    today_transaction_earnings = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(
+            and_(
+                Transaction.type == TransactionType.REFERRAL_REWARD.value,
+                Transaction.created_at >= today
+            )
+        )
+    )
+    today_earnings = today_referral_earnings.scalar() + today_transaction_earnings.scalar()
+    
+    week_ago = datetime.utcnow() - timedelta(days=7)
+    week_referral_earnings = await db.execute(
+        select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+        .where(ReferralEarning.created_at >= week_ago)
+    )
+    week_transaction_earnings = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(
+            and_(
+                Transaction.type == TransactionType.REFERRAL_REWARD.value,
+                Transaction.created_at >= week_ago
+            )
+        )
+    )
+    week_earnings = week_referral_earnings.scalar() + week_transaction_earnings.scalar()
+    
+    month_ago = datetime.utcnow() - timedelta(days=30)
+    month_referral_earnings = await db.execute(
+        select(func.coalesce(func.sum(ReferralEarning.amount_kopeks), 0))
+        .where(ReferralEarning.created_at >= month_ago)
+    )
+    month_transaction_earnings = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(
+            and_(
+                Transaction.type == TransactionType.REFERRAL_REWARD.value,
+                Transaction.created_at >= month_ago
+            )
+        )
+    )
+    month_earnings = month_referral_earnings.scalar() + month_transaction_earnings.scalar()
+    
+    return {
+        "users_with_referrals": users_with_referrals,
+        "active_referrers": active_referrers,
+        "total_paid_kopeks": total_paid,
+        "today_earnings_kopeks": today_earnings,
+        "week_earnings_kopeks": week_earnings,
+        "month_earnings_kopeks": month_earnings,
+        "top_referrers": top_referrers
+    }
+
+
+async def get_user_referral_stats(db: AsyncSession, user_id: int) -> dict:
+    
+    invited_count_result = await db.execute(
+        select(func.count(User.id)).where(User.referred_by_id == user_id)
+    )
+    invited_count = invited_count_result.scalar()
+    
+    total_earned = await get_referral_earnings_sum(db, user_id)
+    
+    month_ago = datetime.utcnow() - timedelta(days=30)
+    month_earned = await get_referral_earnings_sum(db, user_id, start_date=month_ago)
+    
+    active_referrals_result = await db.execute(
+        select(func.count(User.id))
+        .join(User.subscription)
+        .where(
+            and_(
+                User.referred_by_id == user_id,
+                User.subscription.has()
+            )
+        )
+    )
+    active_referrals = active_referrals_result.scalar()
+    
+    return {
+        "invited_count": invited_count,
+        "active_referrals": active_referrals,
+        "total_earned_kopeks": total_earned,
+        "month_earned_kopeks": month_earned
+    }

app/database/crud/rules.py

@@ -0,0 +1,82 @@
+import logging
+from typing import Optional
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime
+
+from app.database.models import ServiceRule
+
+logger = logging.getLogger(__name__)
+
+
+async def get_rules_by_language(db: AsyncSession, language: str = "ru") -> Optional[ServiceRule]:
+    result = await db.execute(
+        select(ServiceRule)
+        .where(
+            ServiceRule.language == language,
+            ServiceRule.is_active == True
+        )
+        .order_by(ServiceRule.order, ServiceRule.created_at.desc())
+        .limit(1)
+    )
+    return result.scalar_one_or_none()
+
+
+async def create_or_update_rules(
+    db: AsyncSession,
+    content: str,
+    language: str = "ru",
+    title: str = "Правила сервиса"
+) -> ServiceRule:
+    
+    existing_rules_result = await db.execute(
+        select(ServiceRule).where(
+            ServiceRule.language == language,
+            ServiceRule.is_active == True
+        )
+    )
+    existing_rules = existing_rules_result.scalars().all()
+    
+    for rule in existing_rules:
+        rule.is_active = False
+        rule.updated_at = datetime.utcnow()
+    
+    new_rules = ServiceRule(
+        title=title,
+        content=content,
+        language=language,
+        is_active=True,
+        order=0
+    )
+    
+    db.add(new_rules)
+    await db.commit()
+    await db.refresh(new_rules)
+    
+    logger.info(f"✅ Правила для языка {language} обновлены")
+    return new_rules
+
+
+async def get_current_rules_content(db: AsyncSession, language: str = "ru") -> str:
+    rules = await get_rules_by_language(db, language)
+    
+    if rules:
+        return rules.content
+    else:
+        return """
+🔒 <b>Правила использования сервиса</b>
+
+1. Сервис предоставляется "как есть" без каких-либо гарантий.
+
+2. Запрещается использование сервиса для незаконных действий.
+
+3. Администрация оставляет за собой право заблокировать доступ пользователя при нарушении правил.
+
+4. Возврат средств осуществляется в соответствии с политикой возврата.
+
+5. Пользователь несет полную ответственность за безопасность своего аккаунта.
+
+6. При возникновении вопросов обращайтесь в техническую поддержку.
+
+Используя сервис, вы соглашаетесь с данными правилами.
+"""

app/database/crud/server_squad.py

@@ -0,0 +1,355 @@
+import logging
+from typing import List, Optional, Tuple
+from sqlalchemy import select, and_, func, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import ServerSquad, SubscriptionServer
+
+logger = logging.getLogger(__name__)
+
+
+async def create_server_squad(
+    db: AsyncSession,
+    squad_uuid: str,
+    display_name: str,
+    original_name: str = None,
+    country_code: str = None,
+    price_kopeks: int = 0,
+    description: str = None,
+    max_users: int = None,
+    is_available: bool = True
+) -> ServerSquad:
+    
+    server_squad = ServerSquad(
+        squad_uuid=squad_uuid,
+        display_name=display_name,
+        original_name=original_name,
+        country_code=country_code,
+        price_kopeks=price_kopeks,
+        description=description,
+        max_users=max_users,
+        is_available=is_available
+    )
+    
+    db.add(server_squad)
+    await db.commit()
+    await db.refresh(server_squad)
+    
+    logger.info(f"✅ Создан сервер {display_name} (UUID: {squad_uuid})")
+    return server_squad
+
+
+async def get_server_squad_by_uuid(
+    db: AsyncSession, 
+    squad_uuid: str
+) -> Optional[ServerSquad]:
+    
+    result = await db.execute(
+        select(ServerSquad).where(ServerSquad.squad_uuid == squad_uuid)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_server_squad_by_id(
+    db: AsyncSession, 
+    server_id: int
+) -> Optional[ServerSquad]:
+    
+    result = await db.execute(
+        select(ServerSquad).where(ServerSquad.id == server_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_all_server_squads(
+    db: AsyncSession,
+    available_only: bool = False,
+    page: int = 1,
+    limit: int = 50
+) -> Tuple[List[ServerSquad], int]:
+    
+    query = select(ServerSquad)
+    
+    if available_only:
+        query = query.where(ServerSquad.is_available == True)
+    
+    count_query = select(func.count(ServerSquad.id))
+    if available_only:
+        count_query = count_query.where(ServerSquad.is_available == True)
+    
+    count_result = await db.execute(count_query)
+    total_count = count_result.scalar()
+    
+    offset = (page - 1) * limit
+    query = query.order_by(ServerSquad.sort_order, ServerSquad.display_name)
+    query = query.offset(offset).limit(limit)
+    
+    result = await db.execute(query)
+    servers = result.scalars().all()
+    
+    return servers, total_count
+
+
+async def get_available_server_squads(db: AsyncSession) -> List[ServerSquad]:
+    
+    result = await db.execute(
+        select(ServerSquad)
+        .where(ServerSquad.is_available == True)
+        .order_by(ServerSquad.sort_order, ServerSquad.display_name)
+    )
+    return result.scalars().all()
+
+
+async def update_server_squad(
+    db: AsyncSession,
+    server_id: int,
+    **updates
+) -> Optional[ServerSquad]:
+    
+    valid_fields = {
+        'display_name', 'country_code', 'price_kopeks', 'description',
+        'max_users', 'is_available', 'sort_order'
+    }
+    
+    filtered_updates = {k: v for k, v in updates.items() if k in valid_fields}
+    
+    if not filtered_updates:
+        return None
+    
+    await db.execute(
+        update(ServerSquad)
+        .where(ServerSquad.id == server_id)
+        .values(**filtered_updates)
+    )
+    
+    await db.commit()
+    
+    return await get_server_squad_by_id(db, server_id)
+
+
+async def delete_server_squad(db: AsyncSession, server_id: int) -> bool:
+    
+    connections_result = await db.execute(
+        select(func.count(SubscriptionServer.id))
+        .where(SubscriptionServer.server_squad_id == server_id)
+    )
+    connections_count = connections_result.scalar()
+    
+    if connections_count > 0:
+        logger.warning(f"❌ Нельзя удалить сервер {server_id}: есть активные подключения ({connections_count})")
+        return False
+    
+    await db.execute(
+        delete(ServerSquad).where(ServerSquad.id == server_id)
+    )
+    await db.commit()
+    
+    logger.info(f"🗑️ Удален сервер (ID: {server_id})")
+    return True
+
+
+async def sync_with_remnawave(
+    db: AsyncSession,
+    remnawave_squads: List[dict]
+) -> Tuple[int, int, int]:
+    
+    created = 0
+    updated = 0
+    disabled = 0
+    
+    existing_servers = {}
+    result = await db.execute(select(ServerSquad))
+    for server in result.scalars().all():
+        existing_servers[server.squad_uuid] = server
+    
+    remnawave_uuids = {squad['uuid'] for squad in remnawave_squads}
+    
+    for squad in remnawave_squads:
+        squad_uuid = squad['uuid']
+        original_name = squad.get('name', f'Squad {squad_uuid[:8]}')
+        
+        if squad_uuid in existing_servers:
+            server = existing_servers[squad_uuid]
+            if server.original_name != original_name:
+                server.original_name = original_name
+                updated += 1
+        else:
+            await create_server_squad(
+                db=db,
+                squad_uuid=squad_uuid,
+                display_name=_generate_display_name(original_name),
+                original_name=original_name,
+                country_code=_extract_country_code(original_name),
+                price_kopeks=1000, 
+                is_available=False 
+            )
+            created += 1
+    
+    for uuid, server in existing_servers.items():
+        if uuid not in remnawave_uuids and server.is_available:
+            server.is_available = False
+            disabled += 1
+    
+    await db.commit()
+    
+    logger.info(f"🔄 Синхронизация завершена: +{created} ~{updated} -{disabled}")
+    return created, updated, disabled
+
+
+def _generate_display_name(original_name: str) -> str:
+    
+    country_names = {
+        'NL': '🇳🇱 Нидерланды',
+        'DE': '🇩🇪 Германия', 
+        'US': '🇺🇸 США',
+        'FR': '🇫🇷 Франция',
+        'GB': '🇬🇧 Великобритания',
+        'IT': '🇮🇹 Италия',
+        'ES': '🇪🇸 Испания',
+        'CA': '🇨🇦 Канада',
+        'JP': '🇯🇵 Япония',
+        'SG': '🇸🇬 Сингапур',
+        'AU': '🇦🇺 Австралия',
+    }
+    
+    name_upper = original_name.upper()
+    for code, display_name in country_names.items():
+        if code in name_upper:
+            return display_name
+    
+    return f"🌍 {original_name}"
+
+
+def _extract_country_code(original_name: str) -> Optional[str]:
+    
+    codes = ['NL', 'DE', 'US', 'FR', 'GB', 'IT', 'ES', 'CA', 'JP', 'SG', 'AU']
+    name_upper = original_name.upper()
+    
+    for code in codes:
+        if code in name_upper:
+            return code
+    
+    return None
+
+
+async def get_server_statistics(db: AsyncSession) -> dict:
+    
+    total_result = await db.execute(select(func.count(ServerSquad.id)))
+    total_servers = total_result.scalar()
+    
+    available_result = await db.execute(
+        select(func.count(ServerSquad.id))
+        .where(ServerSquad.is_available == True)
+    )
+    available_servers = available_result.scalar()
+    
+    with_connections_result = await db.execute(
+        select(func.count(func.distinct(SubscriptionServer.server_squad_id)))
+    )
+    servers_with_connections = with_connections_result.scalar()
+    
+    revenue_result = await db.execute(
+        select(func.coalesce(func.sum(SubscriptionServer.paid_price_kopeks), 0))
+    )
+    total_revenue_kopeks = revenue_result.scalar()
+    
+    return {
+        'total_servers': total_servers,
+        'available_servers': available_servers,
+        'unavailable_servers': total_servers - available_servers,
+        'servers_with_connections': servers_with_connections,
+        'total_revenue_kopeks': total_revenue_kopeks,
+        'total_revenue_rubles': total_revenue_kopeks / 100
+    }
+
+async def add_user_to_servers(
+    db: AsyncSession,
+    server_squad_ids: List[int]
+) -> bool:
+    
+    try:
+        for server_id in server_squad_ids:
+            await db.execute(
+                update(ServerSquad)
+                .where(ServerSquad.id == server_id)
+                .values(current_users=ServerSquad.current_users + 1)
+            )
+        
+        await db.commit()
+        logger.info(f"✅ Увеличен счетчик пользователей для серверов: {server_squad_ids}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка увеличения счетчика пользователей: {e}")
+        await db.rollback()
+        return False
+
+
+async def remove_user_from_servers(
+    db: AsyncSession,
+    server_squad_ids: List[int]
+) -> bool:
+    
+    try:
+        for server_id in server_squad_ids:
+            await db.execute(
+                update(ServerSquad)
+                .where(ServerSquad.id == server_id)
+                .values(current_users=func.greatest(ServerSquad.current_users - 1, 0))
+            )
+        
+        await db.commit()
+        logger.info(f"✅ Уменьшен счетчик пользователей для серверов: {server_squad_ids}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка уменьшения счетчика пользователей: {e}")
+        await db.rollback()
+        return False
+
+
+async def get_server_ids_by_uuids(
+    db: AsyncSession,
+    squad_uuids: List[str]
+) -> List[int]:
+    
+    result = await db.execute(
+        select(ServerSquad.id)
+        .where(ServerSquad.squad_uuid.in_(squad_uuids))
+    )
+    return [row[0] for row in result.fetchall()]
+
+
+async def sync_server_user_counts(db: AsyncSession) -> int:
+    
+    try:
+        result = await db.execute(
+            select(
+                ServerSquad.id,
+                ServerSquad.squad_uuid,
+                func.count(SubscriptionServer.id).label('actual_users')
+            )
+            .outerjoin(SubscriptionServer, ServerSquad.id == SubscriptionServer.server_squad_id)
+            .join(Subscription, SubscriptionServer.subscription_id == Subscription.id)
+            .where(Subscription.status == 'active')
+            .group_by(ServerSquad.id, ServerSquad.squad_uuid)
+        )
+        
+        updated_count = 0
+        for server_id, squad_uuid, actual_users in result.fetchall():
+            await db.execute(
+                update(ServerSquad)
+                .where(ServerSquad.id == server_id)
+                .values(current_users=actual_users)
+            )
+            updated_count += 1
+        
+        await db.commit()
+        logger.info(f"✅ Синхронизированы счетчики для {updated_count} серверов")
+        return updated_count
+        
+    except Exception as e:
+        logger.error(f"Ошибка синхронизации счетчиков пользователей: {e}")
+        await db.rollback()
+        return 0

app/database/crud/squad.py

@@ -0,0 +1,61 @@
+import logging
+from typing import Optional, List
+from sqlalchemy import select, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import Squad
+
+logger = logging.getLogger(__name__)
+
+
+async def get_squad_by_uuid(db: AsyncSession, uuid: str) -> Optional[Squad]:
+    result = await db.execute(
+        select(Squad).where(Squad.uuid == uuid)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_available_squads(db: AsyncSession) -> List[Squad]:
+    result = await db.execute(
+        select(Squad).where(Squad.is_available == True)
+    )
+    return result.scalars().all()
+
+
+async def create_squad(
+    db: AsyncSession,
+    uuid: str,
+    name: str,
+    country_code: str = None,
+    price_kopeks: int = 0,
+    description: str = None
+) -> Squad:
+    squad = Squad(
+        uuid=uuid,
+        name=name,
+        country_code=country_code,
+        price_kopeks=price_kopeks,
+        description=description
+    )
+    
+    db.add(squad)
+    await db.commit()
+    await db.refresh(squad)
+    
+    logger.info(f"✅ Создан сквад: {name}")
+    return squad
+
+
+async def update_squad(
+    db: AsyncSession,
+    squad: Squad,
+    **kwargs
+) -> Squad:
+    for field, value in kwargs.items():
+        if hasattr(squad, field):
+            setattr(squad, field, value)
+    
+    await db.commit()
+    await db.refresh(squad)
+    
+    return squad

app/database/crud/subscription.py

@@ -0,0 +1,485 @@
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List, Tuple
+from sqlalchemy import select, and_, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import (
+    Subscription, SubscriptionStatus, User, 
+    SubscriptionServer
+)
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+async def get_subscription_by_user_id(db: AsyncSession, user_id: int) -> Optional[Subscription]:
+    result = await db.execute(
+        select(Subscription)
+        .options(selectinload(Subscription.user))
+        .where(Subscription.user_id == user_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def create_trial_subscription(
+    db: AsyncSession,
+    user_id: int,
+    duration_days: int = None,
+    traffic_limit_gb: int = None,
+    device_limit: int = None,
+    squad_uuid: str = None
+) -> Subscription:
+    
+    duration_days = duration_days or settings.TRIAL_DURATION_DAYS
+    traffic_limit_gb = traffic_limit_gb or settings.TRIAL_TRAFFIC_LIMIT_GB
+    device_limit = device_limit or settings.TRIAL_DEVICE_LIMIT
+    squad_uuid = squad_uuid or settings.TRIAL_SQUAD_UUID
+    
+    end_date = datetime.utcnow() + timedelta(days=duration_days)
+    
+    subscription = Subscription(
+        user_id=user_id,
+        status=SubscriptionStatus.ACTIVE.value,
+        is_trial=True,
+        start_date=datetime.utcnow(),
+        end_date=end_date,
+        traffic_limit_gb=traffic_limit_gb,
+        device_limit=device_limit,
+        connected_squads=[squad_uuid] if squad_uuid else []
+    )
+    
+    db.add(subscription)
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"🎁 Создана триальная подписка для пользователя {user_id}")
+    return subscription
+
+
+async def create_paid_subscription(
+    db: AsyncSession,
+    user_id: int,
+    duration_days: int,
+    traffic_limit_gb: int = 0, 
+    device_limit: int = 1,
+    connected_squads: List[str] = None
+) -> Subscription:
+    
+    end_date = datetime.utcnow() + timedelta(days=duration_days)
+    
+    subscription = Subscription(
+        user_id=user_id,
+        status=SubscriptionStatus.ACTIVE.value,
+        is_trial=False,
+        start_date=datetime.utcnow(),
+        end_date=end_date,
+        traffic_limit_gb=traffic_limit_gb,
+        device_limit=device_limit,
+        connected_squads=connected_squads or []
+    )
+    
+    db.add(subscription)
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"💎 Создана платная подписка для пользователя {user_id}")
+    return subscription
+
+
+async def extend_subscription(
+    db: AsyncSession,
+    subscription: Subscription,
+    days: int
+) -> Subscription:
+    
+    subscription.extend_subscription(days)
+    
+    if subscription.status == SubscriptionStatus.EXPIRED.value:
+        subscription.status = SubscriptionStatus.ACTIVE.value
+    
+    subscription.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"⏰ Подписка пользователя {subscription.user_id} продлена на {days} дней")
+    return subscription
+
+
+async def add_subscription_traffic(
+    db: AsyncSession,
+    subscription: Subscription,
+    gb: int
+) -> Subscription:
+    
+    subscription.add_traffic(gb)
+    subscription.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"📈 К подписке пользователя {subscription.user_id} добавлено {gb} ГБ трафика")
+    return subscription
+
+
+async def add_subscription_devices(
+    db: AsyncSession,
+    subscription: Subscription,
+    devices: int
+) -> Subscription:
+    
+    subscription.device_limit += devices
+    subscription.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"📱 К подписке пользователя {subscription.user_id} добавлено {devices} устройств")
+    return subscription
+
+
+async def add_subscription_squad(
+    db: AsyncSession,
+    subscription: Subscription,
+    squad_uuid: str
+) -> Subscription:
+    
+    if squad_uuid not in subscription.connected_squads:
+        subscription.connected_squads = subscription.connected_squads + [squad_uuid]
+        subscription.updated_at = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(subscription)
+        
+        logger.info(f"🌍 К подписке пользователя {subscription.user_id} добавлен сквад {squad_uuid}")
+    
+    return subscription
+
+
+async def remove_subscription_squad(
+    db: AsyncSession,
+    subscription: Subscription,
+    squad_uuid: str
+) -> Subscription:
+    
+    if squad_uuid in subscription.connected_squads:
+        squads = subscription.connected_squads.copy()
+        squads.remove(squad_uuid)
+        subscription.connected_squads = squads
+        subscription.updated_at = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(subscription)
+        
+        logger.info(f"🚫 Из подписки пользователя {subscription.user_id} удален сквад {squad_uuid}")
+    
+    return subscription
+
+
+async def update_subscription_autopay(
+    db: AsyncSession,
+    subscription: Subscription,
+    enabled: bool,
+    days_before: int = 3
+) -> Subscription:
+    
+    subscription.autopay_enabled = enabled
+    subscription.autopay_days_before = days_before
+    subscription.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(subscription)
+    
+    status = "включен" if enabled else "выключен"
+    logger.info(f"💳 Автоплатеж для подписки пользователя {subscription.user_id} {status}")
+    return subscription
+
+
+async def deactivate_subscription(
+    db: AsyncSession,
+    subscription: Subscription
+) -> Subscription:
+    
+    subscription.status = SubscriptionStatus.DISABLED.value
+    subscription.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"❌ Подписка пользователя {subscription.user_id} деактивирована")
+    return subscription
+
+
+async def get_expiring_subscriptions(
+    db: AsyncSession,
+    days_before: int = 3
+) -> List[Subscription]:
+    
+    threshold_date = datetime.utcnow() + timedelta(days=days_before)
+    
+    result = await db.execute(
+        select(Subscription)
+        .options(selectinload(Subscription.user))
+        .where(
+            and_(
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.end_date <= threshold_date,
+                Subscription.end_date > datetime.utcnow()
+            )
+        )
+    )
+    return result.scalars().all()
+
+
+async def get_expired_subscriptions(db: AsyncSession) -> List[Subscription]:
+    
+    result = await db.execute(
+        select(Subscription)
+        .options(selectinload(Subscription.user))
+        .where(
+            and_(
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.end_date <= datetime.utcnow()
+            )
+        )
+    )
+    return result.scalars().all()
+
+
+async def get_subscriptions_for_autopay(db: AsyncSession) -> List[Subscription]:
+    current_time = datetime.utcnow()
+    
+    result = await db.execute(
+        select(Subscription)
+        .options(selectinload(Subscription.user))
+        .where(
+            and_(
+                Subscription.status == SubscriptionStatus.ACTIVE.value,
+                Subscription.autopay_enabled == True,
+                Subscription.is_trial == False 
+            )
+        )
+    )
+    all_autopay_subscriptions = result.scalars().all()
+    
+    ready_for_autopay = []
+    for subscription in all_autopay_subscriptions:
+        days_until_expiry = (subscription.end_date - current_time).days
+        
+        if days_until_expiry <= subscription.autopay_days_before and subscription.end_date > current_time:
+            ready_for_autopay.append(subscription)
+    
+    return ready_for_autopay
+
+
+async def get_subscriptions_statistics(db: AsyncSession) -> dict:
+    
+    total_result = await db.execute(select(func.count(Subscription.id)))
+    total_subscriptions = total_result.scalar()
+    
+    active_result = await db.execute(
+        select(func.count(Subscription.id))
+        .where(Subscription.status == SubscriptionStatus.ACTIVE.value)
+    )
+    active_subscriptions = active_result.scalar()
+    
+    trial_result = await db.execute(
+        select(func.count(Subscription.id))
+        .where(
+            and_(
+                Subscription.is_trial == True,
+                Subscription.status == SubscriptionStatus.ACTIVE.value
+            )
+        )
+    )
+    trial_subscriptions = trial_result.scalar()
+    
+    paid_subscriptions = active_subscriptions - trial_subscriptions
+    
+    today = datetime.utcnow().date()
+    today_result = await db.execute(
+        select(func.count(Subscription.id))
+        .where(
+            and_(
+                Subscription.created_at >= today,
+                Subscription.is_trial == False
+            )
+        )
+    )
+    purchased_today = today_result.scalar()
+    
+    week_ago = datetime.utcnow() - timedelta(days=7)
+    week_result = await db.execute(
+        select(func.count(Subscription.id))
+        .where(
+            and_(
+                Subscription.created_at >= week_ago,
+                Subscription.is_trial == False
+            )
+        )
+    )
+    purchased_week = week_result.scalar()
+    
+    month_ago = datetime.utcnow() - timedelta(days=30)
+    month_result = await db.execute(
+        select(func.count(Subscription.id))
+        .where(
+            and_(
+                Subscription.created_at >= month_ago,
+                Subscription.is_trial == False
+            )
+        )
+    )
+    purchased_month = month_result.scalar()
+    
+    return {
+        "total_subscriptions": total_subscriptions,
+        "active_subscriptions": active_subscriptions,
+        "trial_subscriptions": trial_subscriptions,
+        "paid_subscriptions": paid_subscriptions,
+        "purchased_today": purchased_today,
+        "purchased_week": purchased_week,
+        "purchased_month": purchased_month
+    }
+
+
+async def update_subscription_usage(
+    db: AsyncSession,
+    subscription: Subscription,
+    used_gb: float
+) -> Subscription:
+    subscription.traffic_used_gb = used_gb
+    subscription.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(subscription)
+    
+    return subscription
+
+async def get_all_subscriptions(
+    db: AsyncSession, 
+    page: int = 1, 
+    limit: int = 10
+) -> Tuple[List[Subscription], int]:
+    count_result = await db.execute(
+        select(func.count(Subscription.id))
+    )
+    total_count = count_result.scalar()
+    
+    offset = (page - 1) * limit
+    
+    result = await db.execute(
+        select(Subscription)
+        .options(selectinload(Subscription.user))
+        .order_by(Subscription.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+    
+    subscriptions = result.scalars().all()
+    
+    return subscriptions, total_count
+
+async def add_subscription_servers(
+    db: AsyncSession,
+    subscription: Subscription,
+    server_squad_ids: List[int],
+    paid_prices: List[int] = None
+) -> Subscription:
+    
+    if paid_prices is None:
+        paid_prices = [0] * len(server_squad_ids)
+    
+    for i, server_id in enumerate(server_squad_ids):
+        subscription_server = SubscriptionServer(
+            subscription_id=subscription.id,
+            server_squad_id=server_id,
+            paid_price_kopeks=paid_prices[i] if i < len(paid_prices) else 0
+        )
+        db.add(subscription_server)
+    
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"🌍 К подписке {subscription.id} добавлено {len(server_squad_ids)} серверов")
+    return subscription
+
+async def get_subscription_server_ids(
+    db: AsyncSession,
+    subscription_id: int
+) -> List[int]:
+    
+    result = await db.execute(
+        select(SubscriptionServer.server_squad_id)
+        .where(SubscriptionServer.subscription_id == subscription_id)
+    )
+    return [row[0] for row in result.fetchall()]
+
+
+async def get_subscription_servers(
+    db: AsyncSession,
+    subscription_id: int
+) -> List[dict]:
+    
+    from app.database.models import ServerSquad
+    
+    result = await db.execute(
+        select(SubscriptionServer, ServerSquad)
+        .join(ServerSquad, SubscriptionServer.server_squad_id == ServerSquad.id)
+        .where(SubscriptionServer.subscription_id == subscription_id)
+    )
+    
+    servers_info = []
+    for sub_server, server_squad in result.fetchall():
+        servers_info.append({
+            'server_id': server_squad.id,
+            'squad_uuid': server_squad.squad_uuid,
+            'display_name': server_squad.display_name,
+            'country_code': server_squad.country_code,
+            'paid_price_kopeks': sub_server.paid_price_kopeks,
+            'connected_at': sub_server.connected_at,
+            'is_available': server_squad.is_available
+        })
+    
+    return servers_info
+
+async def create_subscription(
+    db: AsyncSession,
+    user_id: int,
+    status: str = "trial",
+    is_trial: bool = True,
+    end_date: datetime = None,
+    traffic_limit_gb: int = 10,
+    traffic_used_gb: float = 0.0,
+    device_limit: int = 1,
+    connected_squads: list = None,
+    remnawave_short_uuid: str = None,
+    subscription_url: str = ""
+) -> Subscription:
+    
+    if end_date is None:
+        end_date = datetime.utcnow() + timedelta(days=3)
+    
+    if connected_squads is None:
+        connected_squads = []
+    
+    subscription = Subscription(
+        user_id=user_id,
+        status=status,
+        is_trial=is_trial,
+        end_date=end_date,
+        traffic_limit_gb=traffic_limit_gb,
+        traffic_used_gb=traffic_used_gb,
+        device_limit=device_limit,
+        connected_squads=connected_squads,
+        remnawave_short_uuid=remnawave_short_uuid,
+        subscription_url=subscription_url
+    )
+    
+    db.add(subscription)
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"✅ Создана подписка для пользователя {user_id}")
+    return subscription

app/database/crud/transaction.py

@@ -0,0 +1,278 @@
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List
+from sqlalchemy import select, and_, or_, func, desc
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import Transaction, TransactionType, PaymentMethod, User
+
+logger = logging.getLogger(__name__)
+
+
+async def create_transaction(
+    db: AsyncSession,
+    user_id: int,
+    type: TransactionType,
+    amount_kopeks: int,
+    description: str,
+    payment_method: Optional[PaymentMethod] = None,
+    external_id: Optional[str] = None,
+    is_completed: bool = True
+) -> Transaction:
+    
+    transaction = Transaction(
+        user_id=user_id,
+        type=type.value,
+        amount_kopeks=amount_kopeks,
+        description=description,
+        payment_method=payment_method.value if payment_method else None,
+        external_id=external_id,
+        is_completed=is_completed,
+        completed_at=datetime.utcnow() if is_completed else None
+    )
+    
+    db.add(transaction)
+    await db.commit()
+    await db.refresh(transaction)
+    
+    logger.info(f"💳 Создана транзакция: {type.value} на {amount_kopeks/100}₽ для пользователя {user_id}")
+    return transaction
+
+
+async def get_transaction_by_id(db: AsyncSession, transaction_id: int) -> Optional[Transaction]:
+    result = await db.execute(
+        select(Transaction)
+        .options(selectinload(Transaction.user))
+        .where(Transaction.id == transaction_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_transaction_by_external_id(
+    db: AsyncSession, 
+    external_id: str, 
+    payment_method: PaymentMethod
+) -> Optional[Transaction]:
+    result = await db.execute(
+        select(Transaction)
+        .where(
+            and_(
+                Transaction.external_id == external_id,
+                Transaction.payment_method == payment_method.value
+            )
+        )
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_user_transactions(
+    db: AsyncSession, 
+    user_id: int, 
+    limit: int = 50,
+    offset: int = 0
+) -> List[Transaction]:
+    
+    result = await db.execute(
+        select(Transaction)
+        .where(Transaction.user_id == user_id)
+        .order_by(Transaction.created_at.desc())
+        .offset(offset)
+        .limit(limit)
+    )
+    return result.scalars().all()
+
+
+async def get_user_transactions_count(
+    db: AsyncSession,
+    user_id: int,
+    transaction_type: Optional[TransactionType] = None
+) -> int:
+    
+    query = select(func.count(Transaction.id)).where(Transaction.user_id == user_id)
+    
+    if transaction_type:
+        query = query.where(Transaction.type == transaction_type.value)
+    
+    result = await db.execute(query)
+    return result.scalar()
+
+
+async def complete_transaction(db: AsyncSession, transaction: Transaction) -> Transaction:
+    
+    transaction.is_completed = True
+    transaction.completed_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(transaction)
+    
+    logger.info(f"✅ Транзакция {transaction.id} завершена")
+    return transaction
+
+
+async def get_pending_transactions(db: AsyncSession) -> List[Transaction]:
+    
+    result = await db.execute(
+        select(Transaction)
+        .options(selectinload(Transaction.user))
+        .where(Transaction.is_completed == False)
+        .order_by(Transaction.created_at)
+    )
+    return result.scalars().all()
+
+
+async def get_transactions_statistics(
+    db: AsyncSession,
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None
+) -> dict:
+    
+    if not start_date:
+        start_date = datetime.utcnow().replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+    if not end_date:
+        end_date = datetime.utcnow()
+    
+    income_result = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(
+            and_(
+                Transaction.type == TransactionType.DEPOSIT.value,
+                Transaction.is_completed == True,
+                Transaction.created_at >= start_date,
+                Transaction.created_at <= end_date
+            )
+        )
+    )
+    total_income = income_result.scalar()
+    
+    expenses_result = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(
+            and_(
+                Transaction.type == TransactionType.WITHDRAWAL.value,
+                Transaction.is_completed == True,
+                Transaction.created_at >= start_date,
+                Transaction.created_at <= end_date
+            )
+        )
+    )
+    total_expenses = expenses_result.scalar()
+    
+    subscription_income_result = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(
+            and_(
+                Transaction.type == TransactionType.SUBSCRIPTION_PAYMENT.value,
+                Transaction.is_completed == True,
+                Transaction.created_at >= start_date,
+                Transaction.created_at <= end_date
+            )
+        )
+    )
+    subscription_income = subscription_income_result.scalar()
+    
+    transactions_count_result = await db.execute(
+        select(
+            Transaction.type,
+            func.count(Transaction.id).label('count'),
+            func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('total_amount')
+        )
+        .where(
+            and_(
+                Transaction.is_completed == True,
+                Transaction.created_at >= start_date,
+                Transaction.created_at <= end_date
+            )
+        )
+        .group_by(Transaction.type)
+    )
+    transactions_by_type = {row.type: {"count": row.count, "amount": row.total_amount} 
+                           for row in transactions_count_result}
+    
+    payment_methods_result = await db.execute(
+        select(
+            Transaction.payment_method,
+            func.count(Transaction.id).label('count'),
+            func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('total_amount')
+        )
+        .where(
+            and_(
+                Transaction.type == TransactionType.DEPOSIT.value,
+                Transaction.is_completed == True,
+                Transaction.created_at >= start_date,
+                Transaction.created_at <= end_date
+            )
+        )
+        .group_by(Transaction.payment_method)
+    )
+    payment_methods = {row.payment_method: {"count": row.count, "amount": row.total_amount} 
+                      for row in payment_methods_result}
+    
+    today = datetime.utcnow().date()
+    today_result = await db.execute(
+        select(func.count(Transaction.id))
+        .where(
+            and_(
+                Transaction.is_completed == True,
+                Transaction.created_at >= today
+            )
+        )
+    )
+    transactions_today = today_result.scalar()
+    
+    today_income_result = await db.execute(
+        select(func.coalesce(func.sum(Transaction.amount_kopeks), 0))
+        .where(
+            and_(
+                Transaction.type == TransactionType.DEPOSIT.value,
+                Transaction.is_completed == True,
+                Transaction.created_at >= today
+            )
+        )
+    )
+    income_today = today_income_result.scalar()
+    
+    return {
+        "period": {
+            "start_date": start_date,
+            "end_date": end_date
+        },
+        "totals": {
+            "income_kopeks": total_income,
+            "expenses_kopeks": total_expenses,
+            "profit_kopeks": total_income - total_expenses,
+            "subscription_income_kopeks": subscription_income
+        },
+        "today": {
+            "transactions_count": transactions_today,
+            "income_kopeks": income_today
+        },
+        "by_type": transactions_by_type,
+        "by_payment_method": payment_methods
+    }
+
+
+async def get_revenue_by_period(
+    db: AsyncSession,
+    days: int = 30
+) -> List[dict]:
+    
+    start_date = datetime.utcnow() - timedelta(days=days)
+    
+    result = await db.execute(
+        select(
+            func.date(Transaction.created_at).label('date'),
+            func.coalesce(func.sum(Transaction.amount_kopeks), 0).label('amount')
+        )
+        .where(
+            and_(
+                Transaction.type == TransactionType.DEPOSIT.value,
+                Transaction.is_completed == True,
+                Transaction.created_at >= start_date
+            )
+        )
+        .group_by(func.date(Transaction.created_at))
+        .order_by(func.date(Transaction.created_at))
+    )
+    
+    return [{"date": row.date, "amount_kopeks": row.amount} for row in result]

app/database/crud/user.py

@@ -0,0 +1,327 @@
+import logging
+import secrets
+import string
+from datetime import datetime, timedelta
+from typing import Optional, List
+from sqlalchemy import select, and_, or_, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.database.models import User, UserStatus, Subscription, Transaction
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+def generate_referral_code() -> str:
+    alphabet = string.ascii_letters + string.digits
+    code_suffix = ''.join(secrets.choice(alphabet) for _ in range(8))
+    return f"ref{code_suffix}"
+
+
+async def get_user_by_id(db: AsyncSession, user_id: int) -> Optional[User]:
+    result = await db.execute(
+        select(User)
+        .options(selectinload(User.subscription)) 
+        .where(User.id == user_id)
+    )
+    user = result.scalar_one_or_none()
+    
+    if user and user.subscription:
+        _ = user.subscription.is_active
+    
+    return user
+
+
+async def get_user_by_telegram_id(db: AsyncSession, telegram_id: int) -> Optional[User]:
+    result = await db.execute(
+        select(User)
+        .options(selectinload(User.subscription)) 
+        .where(User.telegram_id == telegram_id)
+    )
+    user = result.scalar_one_or_none()
+    
+    if user and user.subscription:
+        _ = user.subscription.is_active
+    
+    return user
+
+
+async def get_user_by_referral_code(db: AsyncSession, referral_code: str) -> Optional[User]:
+    
+    result = await db.execute(
+        select(User).where(User.referral_code == referral_code)
+    )
+    return result.scalar_one_or_none()
+
+
+async def create_unique_referral_code(db: AsyncSession) -> str:
+    max_attempts = 10
+    
+    for _ in range(max_attempts):
+        code = generate_referral_code()
+        existing_user = await get_user_by_referral_code(db, code)
+        if not existing_user:
+            return code
+    
+    timestamp = str(int(datetime.utcnow().timestamp()))[-6:]
+    return f"ref{timestamp}"
+
+
+async def create_user(
+    db: AsyncSession,
+    telegram_id: int,
+    username: str = None,
+    first_name: str = None,
+    last_name: str = None,
+    language: str = "ru",
+    referred_by_id: int = None,
+    referral_code: str = None
+) -> User:
+    
+    if not referral_code:
+        from app.utils.user_utils import generate_unique_referral_code
+        referral_code = await generate_unique_referral_code(db, telegram_id)
+    
+    user = User(
+        telegram_id=telegram_id,
+        username=username,
+        first_name=first_name,
+        last_name=last_name,
+        language=language,
+        referred_by_id=referred_by_id,
+        referral_code=referral_code,
+        balance_kopeks=0,
+        has_had_paid_subscription=False
+    )
+    
+    db.add(user)
+    await db.commit()
+    await db.refresh(user)
+    
+    logger.info(f"✅ Создан пользователь {telegram_id} с реферальным кодом {referral_code}")
+    
+    return user
+
+
+async def update_user(
+    db: AsyncSession,
+    user: User,
+    **kwargs
+) -> User:
+    
+    for field, value in kwargs.items():
+        if hasattr(user, field):
+            setattr(user, field, value)
+    
+    user.updated_at = datetime.utcnow()
+    await db.commit()
+    await db.refresh(user)
+    
+    return user
+
+
+async def add_user_balance(
+    db: AsyncSession,
+    user: User,
+    amount_kopeks: int,
+    description: str = "Пополнение баланса"
+) -> User:
+    
+    user.add_balance(amount_kopeks)
+    user.updated_at = datetime.utcnow()
+    
+    from app.database.crud.transaction import create_transaction
+    from app.database.models import TransactionType
+    
+    await create_transaction(
+        db=db,
+        user_id=user.id,
+        type=TransactionType.DEPOSIT,
+        amount_kopeks=amount_kopeks,
+        description=description
+    )
+    
+    await db.commit()
+    await db.refresh(user)
+    
+    logger.info(f"💰 Пополнен баланс пользователя {user.telegram_id}: +{amount_kopeks/100}₽")
+    return user
+
+
+async def subtract_user_balance(
+    db: AsyncSession,
+    user: User,
+    amount_kopeks: int,
+    description: str = "Списание с баланса"
+) -> bool:
+    
+    if not user.subtract_balance(amount_kopeks):
+        return False
+    
+    user.updated_at = datetime.utcnow()
+    
+    from app.database.crud.transaction import create_transaction
+    from app.database.models import TransactionType
+    
+    await create_transaction(
+        db=db,
+        user_id=user.id,
+        type=TransactionType.WITHDRAWAL,
+        amount_kopeks=amount_kopeks,
+        description=description
+    )
+    
+    await db.commit()
+    await db.refresh(user)
+    
+    logger.info(f"💸 Списан баланс пользователя {user.telegram_id}: -{amount_kopeks/100}₽")
+    return True
+
+
+async def get_users_list(
+    db: AsyncSession,
+    offset: int = 0,
+    limit: int = 50,
+    search: Optional[str] = None,
+    status: Optional[UserStatus] = None
+) -> List[User]:
+    
+    query = select(User).options(selectinload(User.subscription))
+    
+    if status:
+        query = query.where(User.status == status.value)
+    
+    if search:
+        search_term = f"%{search}%"
+        conditions = [
+            User.first_name.ilike(search_term),
+            User.last_name.ilike(search_term),
+            User.username.ilike(search_term)
+        ]
+        
+        if search.isdigit():
+            conditions.append(User.telegram_id == int(search))
+        
+        query = query.where(or_(*conditions))
+    
+    query = query.order_by(User.created_at.desc()).offset(offset).limit(limit)
+    
+    result = await db.execute(query)
+    return result.scalars().all()
+
+
+async def get_users_count(
+    db: AsyncSession,
+    status: Optional[UserStatus] = None,
+    search: Optional[str] = None
+) -> int:
+    
+    query = select(func.count(User.id))
+    
+    if status:
+        query = query.where(User.status == status.value)
+    
+    if search:
+        search_term = f"%{search}%"
+        conditions = [
+            User.first_name.ilike(search_term),
+            User.last_name.ilike(search_term),
+            User.username.ilike(search_term)
+        ]
+        
+        if search.isdigit():
+            conditions.append(User.telegram_id == int(search))
+        
+        query = query.where(or_(*conditions))
+    
+    result = await db.execute(query)
+    return result.scalar()
+
+
+async def get_referrals(db: AsyncSession, user_id: int) -> List[User]:
+    result = await db.execute(
+        select(User)
+        .options(selectinload(User.subscription))
+        .where(User.referred_by_id == user_id)
+        .order_by(User.created_at.desc())
+    )
+    return result.scalars().all()
+
+
+async def get_inactive_users(db: AsyncSession, months: int = 3) -> List[User]:
+    threshold_date = datetime.utcnow() - timedelta(days=months * 30)
+    
+    result = await db.execute(
+        select(User)
+        .options(selectinload(User.subscription))
+        .where(
+            and_(
+                User.last_activity < threshold_date,
+                User.status == UserStatus.ACTIVE.value
+            )
+        )
+    )
+    return result.scalars().all()
+
+
+async def delete_user(db: AsyncSession, user: User) -> bool:
+    user.status = UserStatus.DELETED.value
+    user.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    logger.info(f"🗑️ Пользователь {user.telegram_id} помечен как удаленный")
+    return True
+
+
+async def get_users_statistics(db: AsyncSession) -> dict:
+    
+    total_result = await db.execute(select(func.count(User.id)))
+    total_users = total_result.scalar()
+    
+    active_result = await db.execute(
+        select(func.count(User.id)).where(User.status == UserStatus.ACTIVE.value)
+    )
+    active_users = active_result.scalar()
+    
+    today = datetime.utcnow().date()
+    today_result = await db.execute(
+        select(func.count(User.id)).where(
+            and_(
+                User.created_at >= today,
+                User.status == UserStatus.ACTIVE.value
+            )
+        )
+    )
+    new_today = today_result.scalar()
+    
+    week_ago = datetime.utcnow() - timedelta(days=7)
+    week_result = await db.execute(
+        select(func.count(User.id)).where(
+            and_(
+                User.created_at >= week_ago,
+                User.status == UserStatus.ACTIVE.value
+            )
+        )
+    )
+    new_week = week_result.scalar()
+    
+    month_ago = datetime.utcnow() - timedelta(days=30)
+    month_result = await db.execute(
+        select(func.count(User.id)).where(
+            and_(
+                User.created_at >= month_ago,
+                User.status == UserStatus.ACTIVE.value
+            )
+        )
+    )
+    new_month = month_result.scalar()
+    
+    return {
+        "total_users": total_users,
+        "active_users": active_users,
+        "blocked_users": total_users - active_users,
+        "new_today": new_today,
+        "new_week": new_week,
+        "new_month": new_month
+    }

app/database/database.py

@@ -0,0 +1,51 @@
+import logging
+from typing import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
+from sqlalchemy.pool import NullPool
+
+from app.config import settings
+from app.database.models import Base
+
+logger = logging.getLogger(__name__)
+
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    poolclass=NullPool,
+    echo=settings.DEBUG,
+    future=True
+)
+
+AsyncSessionLocal = async_sessionmaker(
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autoflush=True,
+    autocommit=False
+)
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+
+async def init_db():
+    logger.info("Создание таблиц базы данных...")
+    
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    
+    logger.info("✅ База данных успешно инициализирована")
+
+
+async def close_db():
+    await engine.dispose()
+    logger.info("✅ Подключение к базе данных закрыто")

app/database/models.py

@@ -0,0 +1,421 @@
+from datetime import datetime, timedelta
+from typing import Optional, List
+from enum import Enum
+
+from sqlalchemy import (
+    Column, Integer, String, DateTime, Boolean, Text, 
+    ForeignKey, Float, JSON, BigInteger
+)
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship, Mapped
+from sqlalchemy.sql import func
+
+
+Base = declarative_base()
+
+
+class UserStatus(Enum):
+    ACTIVE = "active"
+    BLOCKED = "blocked"
+    DELETED = "deleted"
+
+
+class SubscriptionStatus(Enum):
+    TRIAL = "trial"
+    ACTIVE = "active"
+    EXPIRED = "expired"
+    DISABLED = "disabled"
+
+
+class TransactionType(Enum):
+    DEPOSIT = "deposit"  
+    WITHDRAWAL = "withdrawal"  
+    SUBSCRIPTION_PAYMENT = "subscription_payment"  
+    REFUND = "refund"  # Возврат
+    REFERRAL_REWARD = "referral_reward"  
+
+
+class PromoCodeType(Enum):
+    BALANCE = "balance" 
+    SUBSCRIPTION_DAYS = "subscription_days"  
+    TRIAL_SUBSCRIPTION = "trial_subscription"  
+
+
+class PaymentMethod(Enum):
+    TELEGRAM_STARS = "telegram_stars"
+    TRIBUTE = "tribute"
+    MANUAL = "manual"  
+
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    telegram_id = Column(BigInteger, unique=True, index=True, nullable=False)
+    username = Column(String(255), nullable=True)
+    first_name = Column(String(255), nullable=True)
+    last_name = Column(String(255), nullable=True)
+    
+    status = Column(String(20), default=UserStatus.ACTIVE.value)
+    language = Column(String(5), default="ru")
+    
+    balance_kopeks = Column(Integer, default=0)
+    
+    used_promocodes = Column(Integer, default=0) 
+
+    has_had_paid_subscription = Column(Boolean, default=False, nullable=False)
+    
+    referred_by_id = Column(Integer, ForeignKey("users.id"), nullable=True)
+    referral_code = Column(String(20), unique=True, nullable=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    last_activity = Column(DateTime, default=func.now())
+    
+    remnawave_uuid = Column(String(255), nullable=True, unique=True)
+
+    broadcasts = relationship("BroadcastHistory", back_populates="admin")
+    
+    referrals = relationship("User", backref="referrer", remote_side=[id], foreign_keys="User.referred_by_id")
+    subscription = relationship("Subscription", back_populates="user", uselist=False)
+    transactions = relationship("Transaction", back_populates="user")
+    referral_earnings = relationship("ReferralEarning", foreign_keys="ReferralEarning.user_id", back_populates="user")
+    
+    @property
+    def balance_rubles(self) -> float:
+        return self.balance_kopeks / 100
+    
+    @property
+    def full_name(self) -> str:
+        parts = [self.first_name, self.last_name]
+        return " ".join(filter(None, parts)) or self.username or f"ID{self.telegram_id}"
+    
+    def add_balance(self, kopeks: int) -> None:
+        self.balance_kopeks += kopeks
+    
+    def subtract_balance(self, kopeks: int) -> bool:
+        if self.balance_kopeks >= kopeks:
+            self.balance_kopeks -= kopeks
+            return True
+        return False
+
+
+class Subscription(Base):
+    __tablename__ = "subscriptions"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    
+    status = Column(String(20), default=SubscriptionStatus.TRIAL.value)
+    is_trial = Column(Boolean, default=True)
+    
+    start_date = Column(DateTime, default=func.now())
+    end_date = Column(DateTime, nullable=False)
+    
+    traffic_limit_gb = Column(Integer, default=0)
+    traffic_used_gb = Column(Float, default=0.0)
+
+    subscription_url = Column(String, nullable=True)
+    
+    device_limit = Column(Integer, default=1)
+    
+    connected_squads = Column(JSON, default=list)
+    
+    autopay_enabled = Column(Boolean, default=False)
+    autopay_days_before = Column(Integer, default=3)
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    
+    remnawave_short_uuid = Column(String(255), nullable=True)
+    
+    user = relationship("User", back_populates="subscription")
+    
+    @property
+    def is_active(self) -> bool:
+        return (
+            self.status == SubscriptionStatus.ACTIVE.value and 
+            self.end_date > datetime.utcnow()
+        )
+    
+    @property
+    def is_expired(self) -> bool:
+        return self.end_date <= datetime.utcnow()
+    
+    @property
+    def days_left(self) -> int:
+        if self.is_expired:
+            return 0
+        delta = self.end_date - datetime.utcnow()
+        return delta.days
+    
+    @property
+    def traffic_used_percent(self) -> float:
+        if self.traffic_limit_gb == 0: 
+            return 0.0
+        if self.traffic_limit_gb > 0:
+            return min((self.traffic_used_gb / self.traffic_limit_gb) * 100, 100.0)
+        return 0.0
+    
+    def extend_subscription(self, days: int):
+        from datetime import timedelta, datetime
+    
+        if self.end_date > datetime.utcnow():
+            self.end_date = self.end_date + timedelta(days=days)
+        else:
+            self.end_date = datetime.utcnow() + timedelta(days=days)
+    
+        if self.status == SubscriptionStatus.EXPIRED.value:
+            self.status = SubscriptionStatus.ACTIVE.value
+    
+    def add_traffic(self, gb: int):
+        if self.traffic_limit_gb == 0:  
+            return
+        self.traffic_limit_gb += gb
+
+
+class Transaction(Base):
+    __tablename__ = "transactions"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    
+    type = Column(String(50), nullable=False)
+    amount_kopeks = Column(Integer, nullable=False)
+    description = Column(Text, nullable=True)
+    
+    payment_method = Column(String(50), nullable=True)
+    external_id = Column(String(255), nullable=True)  
+    
+    is_completed = Column(Boolean, default=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    completed_at = Column(DateTime, nullable=True)
+    
+    user = relationship("User", back_populates="transactions")
+    
+    @property
+    def amount_rubles(self) -> float:
+        return self.amount_kopeks / 100
+
+
+class PromoCode(Base):
+    __tablename__ = "promocodes"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    
+    code = Column(String(50), unique=True, nullable=False, index=True)
+    type = Column(String(50), nullable=False)
+    
+    balance_bonus_kopeks = Column(Integer, default=0)  
+    subscription_days = Column(Integer, default=0) 
+    
+    max_uses = Column(Integer, default=1)  
+    current_uses = Column(Integer, default=0)
+    
+    valid_from = Column(DateTime, default=func.now())
+    valid_until = Column(DateTime, nullable=True)
+    
+    is_active = Column(Boolean, default=True)
+    
+    created_by = Column(Integer, ForeignKey("users.id"), nullable=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    
+    uses = relationship("PromoCodeUse", back_populates="promocode")
+    
+    @property
+    def is_valid(self) -> bool:
+        now = datetime.utcnow()
+        return (
+            self.is_active and
+            self.current_uses < self.max_uses and
+            self.valid_from <= now and
+            (self.valid_until is None or self.valid_until >= now)
+        )
+    
+    @property
+    def uses_left(self) -> int:
+        return max(0, self.max_uses - self.current_uses)
+
+
+class PromoCodeUse(Base):
+    __tablename__ = "promocode_uses"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    promocode_id = Column(Integer, ForeignKey("promocodes.id"), nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    
+    used_at = Column(DateTime, default=func.now())
+    
+    promocode = relationship("PromoCode", back_populates="uses")
+    user = relationship("User")
+
+
+class ReferralEarning(Base):
+    __tablename__ = "referral_earnings"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)  
+    referral_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    
+    amount_kopeks = Column(Integer, nullable=False)
+    reason = Column(String(100), nullable=False) 
+    
+    referral_transaction_id = Column(Integer, ForeignKey("transactions.id"), nullable=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    
+    user = relationship("User", foreign_keys=[user_id], back_populates="referral_earnings")
+    referral = relationship("User", foreign_keys=[referral_id])
+    referral_transaction = relationship("Transaction")
+    
+    @property
+    def amount_rubles(self) -> float:
+        return self.amount_kopeks / 100
+
+
+class Squad(Base):
+    __tablename__ = "squads"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    
+    uuid = Column(String(255), unique=True, nullable=False)
+    name = Column(String(255), nullable=False)
+    country_code = Column(String(5), nullable=True)
+    
+    is_available = Column(Boolean, default=True)
+    price_kopeks = Column(Integer, default=0) 
+    
+    description = Column(Text, nullable=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    
+    @property
+    def price_rubles(self) -> float:
+        return self.price_kopeks / 100
+
+
+class ServiceRule(Base):
+    __tablename__ = "service_rules"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    
+    order = Column(Integer, default=0)
+    title = Column(String(255), nullable=False)
+    
+    content = Column(Text, nullable=False)
+    
+    is_active = Column(Boolean, default=True)
+    
+    language = Column(String(5), default="ru")
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class SystemSetting(Base):
+    __tablename__ = "system_settings"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    key = Column(String(255), unique=True, nullable=False)
+    value = Column(Text, nullable=True)
+    description = Column(Text, nullable=True)
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class MonitoringLog(Base):
+    __tablename__ = "monitoring_logs"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    
+    event_type = Column(String(100), nullable=False)
+    
+    message = Column(Text, nullable=False)
+    data = Column(JSON, nullable=True)
+    
+    is_success = Column(Boolean, default=True)
+    
+    created_at = Column(DateTime, default=func.now())
+
+class BroadcastHistory(Base):
+    __tablename__ = "broadcast_history"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    target_type = Column(String(100), nullable=False)  
+    message_text = Column(Text, nullable=False)  
+    total_count = Column(Integer, default=0) 
+    sent_count = Column(Integer, default=0)  
+    failed_count = Column(Integer, default=0) 
+    status = Column(String(50), default="in_progress")
+    admin_id = Column(Integer, ForeignKey("users.id")) 
+    admin_name = Column(String(255)) 
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    completed_at = Column(DateTime(timezone=True), nullable=True)
+    
+    admin = relationship("User", back_populates="broadcasts")
+
+class ServerSquad(Base):
+    __tablename__ = "server_squads"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    
+    squad_uuid = Column(String(255), unique=True, nullable=False, index=True)
+    
+    display_name = Column(String(255), nullable=False)
+    
+    original_name = Column(String(255), nullable=True)
+    
+    country_code = Column(String(5), nullable=True)
+    
+    is_available = Column(Boolean, default=True)
+    
+    price_kopeks = Column(Integer, default=0)
+    
+    description = Column(Text, nullable=True)
+    
+    sort_order = Column(Integer, default=0)
+    
+    max_users = Column(Integer, nullable=True) 
+    current_users = Column(Integer, default=0) 
+    
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    
+    @property
+    def price_rubles(self) -> float:
+        return self.price_kopeks / 100
+    
+    @property
+    def is_full(self) -> bool:
+        if self.max_users is None:
+            return False
+        return self.current_users >= self.max_users
+    
+    @property
+    def availability_status(self) -> str:
+        if not self.is_available:
+            return "Недоступен"
+        elif self.is_full:
+            return "Переполнен"
+        else:
+            return "Доступен"
+
+
+class SubscriptionServer(Base):
+    __tablename__ = "subscription_servers"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    subscription_id = Column(Integer, ForeignKey("subscriptions.id"), nullable=False)
+    server_squad_id = Column(Integer, ForeignKey("server_squads.id"), nullable=False)
+    
+    connected_at = Column(DateTime, default=func.now())
+    
+    paid_price_kopeks = Column(Integer, default=0)
+    
+    subscription = relationship("Subscription", backref="subscription_servers")
+    server_squad = relationship("ServerSquad", backref="subscription_servers")

app/external/remnawave_api.py

@@ -0,0 +1,521 @@
+import asyncio
+import json
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Union, Any
+import aiohttp
+import logging
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class UserStatus(Enum):
+    ACTIVE = "ACTIVE"
+    DISABLED = "DISABLED"
+    LIMITED = "LIMITED"
+    EXPIRED = "EXPIRED"
+
+
+class TrafficLimitStrategy(Enum):
+    NO_RESET = "NO_RESET"
+    DAY = "DAY"
+    WEEK = "WEEK"
+    MONTH = "MONTH"
+
+
+@dataclass
+class RemnaWaveUser:
+    uuid: str
+    short_uuid: str
+    username: str
+    status: UserStatus
+    used_traffic_bytes: int
+    lifetime_used_traffic_bytes: int
+    traffic_limit_bytes: int
+    traffic_limit_strategy: TrafficLimitStrategy
+    expire_at: datetime
+    telegram_id: Optional[int]
+    email: Optional[str]
+    hwid_device_limit: Optional[int]
+    description: Optional[str]
+    tag: Optional[str]
+    subscription_url: str
+    active_internal_squads: List[Dict[str, str]]
+    created_at: datetime
+    updated_at: datetime
+
+
+@dataclass
+class RemnaWaveInternalSquad:
+    uuid: str
+    name: str
+    members_count: int
+    inbounds_count: int
+    inbounds: List[Dict[str, Any]]
+
+
+@dataclass
+class RemnaWaveNode:
+    uuid: str
+    name: str
+    address: str
+    country_code: str
+    is_connected: bool
+    is_disabled: bool
+    is_node_online: bool
+    is_xray_running: bool
+    users_online: Optional[int]
+    traffic_used_bytes: Optional[int]
+    traffic_limit_bytes: Optional[int]
+
+
+class RemnaWaveAPIError(Exception):
+    def __init__(self, message: str, status_code: int = None, response_data: dict = None):
+        self.message = message
+        self.status_code = status_code
+        self.response_data = response_data
+        super().__init__(self.message)
+
+
+class RemnaWaveAPI:
+    
+    def __init__(self, base_url: str, api_key: str):
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.session: Optional[aiohttp.ClientSession] = None
+        
+    async def __aenter__(self):
+        self.session = aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=30),
+            headers={
+                'Authorization': f'Bearer {self.api_key}',
+                'Content-Type': 'application/json'
+            }
+        )
+        return self
+        
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.session:
+            await self.session.close()
+            
+    async def _make_request(
+        self, 
+        method: str, 
+        endpoint: str, 
+        data: Optional[Dict] = None,
+        params: Optional[Dict] = None
+    ) -> Dict:
+        if not self.session:
+            raise RemnaWaveAPIError("Session not initialized. Use async context manager.")
+            
+        url = f"{self.base_url}{endpoint}"
+        
+        try:
+            kwargs = {
+                'url': url,
+                'params': params
+            }
+            
+            if data:
+                kwargs['json'] = data
+                
+            async with self.session.request(method, **kwargs) as response:
+                response_text = await response.text()
+                
+                try:
+                    response_data = json.loads(response_text) if response_text else {}
+                except json.JSONDecodeError:
+                    response_data = {'raw_response': response_text}
+                
+                if response.status >= 400:
+                    error_message = response_data.get('message', f'HTTP {response.status}')
+                    raise RemnaWaveAPIError(
+                        error_message, 
+                        response.status, 
+                        response_data
+                    )
+                    
+                return response_data
+                
+        except aiohttp.ClientError as e:
+            logger.error(f"Request failed: {e}")
+            raise RemnaWaveAPIError(f"Request failed: {str(e)}")
+    
+    
+    async def create_user(
+        self,
+        username: str,
+        expire_at: datetime,
+        status: UserStatus = UserStatus.ACTIVE,
+        traffic_limit_bytes: int = 0,
+        traffic_limit_strategy: TrafficLimitStrategy = TrafficLimitStrategy.NO_RESET,
+        telegram_id: Optional[int] = None,
+        email: Optional[str] = None,
+        hwid_device_limit: Optional[int] = None,
+        description: Optional[str] = None,
+        tag: Optional[str] = None,
+        active_internal_squads: Optional[List[str]] = None
+    ) -> RemnaWaveUser:
+        data = {
+            'username': username,
+            'status': status.value,
+            'expireAt': expire_at.isoformat(),
+            'trafficLimitBytes': traffic_limit_bytes,
+            'trafficLimitStrategy': traffic_limit_strategy.value
+        }
+        
+        if telegram_id:
+            data['telegramId'] = telegram_id
+        if email:
+            data['email'] = email
+        if hwid_device_limit:
+            data['hwidDeviceLimit'] = hwid_device_limit
+        if description:
+            data['description'] = description
+        if tag:
+            data['tag'] = tag
+        if active_internal_squads:
+            data['activeInternalSquads'] = active_internal_squads
+            
+        response = await self._make_request('POST', '/api/users', data)
+        return self._parse_user(response['response'])
+    
+    async def get_user_by_uuid(self, uuid: str) -> Optional[RemnaWaveUser]:
+        try:
+            response = await self._make_request('GET', f'/api/users/{uuid}')
+            return self._parse_user(response['response'])
+        except RemnaWaveAPIError as e:
+            if e.status_code == 404:
+                return None
+            raise
+    
+    async def get_user_by_telegram_id(self, telegram_id: int) -> List[RemnaWaveUser]:
+        try:
+            response = await self._make_request('GET', f'/api/users/by-telegram-id/{telegram_id}')
+            return [self._parse_user(user) for user in response['response']]
+        except RemnaWaveAPIError as e:
+            if e.status_code == 404:
+                return []
+            raise
+    
+    async def get_user_by_username(self, username: str) -> Optional[RemnaWaveUser]:
+        try:
+            response = await self._make_request('GET', f'/api/users/by-username/{username}')
+            return self._parse_user(response['response'])
+        except RemnaWaveAPIError as e:
+            if e.status_code == 404:
+                return None
+            raise
+    
+    async def update_user(
+        self,
+        uuid: str,
+        status: Optional[UserStatus] = None,
+        traffic_limit_bytes: Optional[int] = None,
+        traffic_limit_strategy: Optional[TrafficLimitStrategy] = None,
+        expire_at: Optional[datetime] = None,
+        telegram_id: Optional[int] = None,
+        email: Optional[str] = None,
+        hwid_device_limit: Optional[int] = None,
+        description: Optional[str] = None,
+        tag: Optional[str] = None,
+        active_internal_squads: Optional[List[str]] = None
+    ) -> RemnaWaveUser:
+        data = {'uuid': uuid}
+        
+        if status:
+            data['status'] = status.value
+        if traffic_limit_bytes is not None:
+            data['trafficLimitBytes'] = traffic_limit_bytes
+        if traffic_limit_strategy:
+            data['trafficLimitStrategy'] = traffic_limit_strategy.value
+        if expire_at:
+            data['expireAt'] = expire_at.isoformat()
+        if telegram_id is not None:
+            data['telegramId'] = telegram_id
+        if email is not None:
+            data['email'] = email
+        if hwid_device_limit is not None:
+            data['hwidDeviceLimit'] = hwid_device_limit
+        if description is not None:
+            data['description'] = description
+        if tag is not None:
+            data['tag'] = tag
+        if active_internal_squads is not None:
+            data['activeInternalSquads'] = active_internal_squads
+            
+        response = await self._make_request('PATCH', '/api/users', data)
+        return self._parse_user(response['response'])
+    
+    async def delete_user(self, uuid: str) -> bool:
+        response = await self._make_request('DELETE', f'/api/users/{uuid}')
+        return response['response']['isDeleted']
+    
+    async def enable_user(self, uuid: str) -> RemnaWaveUser:
+        response = await self._make_request('POST', f'/api/users/{uuid}/actions/enable')
+        return self._parse_user(response['response'])
+    
+    async def disable_user(self, uuid: str) -> RemnaWaveUser:
+        response = await self._make_request('POST', f'/api/users/{uuid}/actions/disable')
+        return self._parse_user(response['response'])
+    
+    async def reset_user_traffic(self, uuid: str) -> RemnaWaveUser:
+        response = await self._make_request('POST', f'/api/users/{uuid}/actions/reset-traffic')
+        return self._parse_user(response['response'])
+    
+    async def revoke_user_subscription(self, uuid: str, new_short_uuid: Optional[str] = None) -> RemnaWaveUser:
+        data = {}
+        if new_short_uuid:
+            data['shortUuid'] = new_short_uuid
+            
+        response = await self._make_request('POST', f'/api/users/{uuid}/actions/revoke', data)
+        return self._parse_user(response['response'])
+    
+    async def get_all_users(self, start: int = 0, size: int = 100) -> Dict[str, Any]:
+        params = {'start': start, 'size': size}
+        response = await self._make_request('GET', '/api/users', params=params)
+        
+        return {
+            'users': [self._parse_user(user) for user in response['response']['users']],
+            'total': response['response']['total']
+        }
+    
+    
+    async def get_internal_squads(self) -> List[RemnaWaveInternalSquad]:
+        response = await self._make_request('GET', '/api/internal-squads')
+        return [self._parse_internal_squad(squad) for squad in response['response']['internalSquads']]
+    
+    async def get_internal_squad_by_uuid(self, uuid: str) -> Optional[RemnaWaveInternalSquad]:
+        try:
+            response = await self._make_request('GET', f'/api/internal-squads/{uuid}')
+            return self._parse_internal_squad(response['response'])
+        except RemnaWaveAPIError as e:
+            if e.status_code == 404:
+                return None
+            raise
+    
+    async def create_internal_squad(self, name: str, inbounds: List[str]) -> RemnaWaveInternalSquad:
+        data = {
+            'name': name,
+            'inbounds': inbounds
+        }
+        response = await self._make_request('POST', '/api/internal-squads', data)
+        return self._parse_internal_squad(response['response'])
+    
+    async def update_internal_squad(
+        self, 
+        uuid: str, 
+        name: Optional[str] = None, 
+        inbounds: Optional[List[str]] = None
+    ) -> RemnaWaveInternalSquad:
+        data = {'uuid': uuid}
+        if name:
+            data['name'] = name
+        if inbounds is not None:
+            data['inbounds'] = inbounds
+            
+        response = await self._make_request('PATCH', '/api/internal-squads', data)
+        return self._parse_internal_squad(response['response'])
+    
+    async def delete_internal_squad(self, uuid: str) -> bool:
+        response = await self._make_request('DELETE', f'/api/internal-squads/{uuid}')
+        return response['response']['isDeleted']
+    
+    
+    async def get_all_nodes(self) -> List[RemnaWaveNode]:
+        response = await self._make_request('GET', '/api/nodes')
+        return [self._parse_node(node) for node in response['response']]
+    
+    async def get_node_by_uuid(self, uuid: str) -> Optional[RemnaWaveNode]:
+        try:
+            response = await self._make_request('GET', f'/api/nodes/{uuid}')
+            return self._parse_node(response['response'])
+        except RemnaWaveAPIError as e:
+            if e.status_code == 404:
+                return None
+            raise
+    
+    async def enable_node(self, uuid: str) -> RemnaWaveNode:
+        response = await self._make_request('POST', f'/api/nodes/{uuid}/actions/enable')
+        return self._parse_node(response['response'])
+    
+    async def disable_node(self, uuid: str) -> RemnaWaveNode:
+        response = await self._make_request('POST', f'/api/nodes/{uuid}/actions/disable')
+        return self._parse_node(response['response'])
+    
+    async def restart_node(self, uuid: str) -> bool:
+        response = await self._make_request('POST', f'/api/nodes/{uuid}/actions/restart')
+        return response['response']['eventSent']
+    
+    async def restart_all_nodes(self) -> bool:
+        response = await self._make_request('POST', '/api/nodes/actions/restart-all')
+        return response['response']['eventSent']
+    
+    
+    async def get_subscription_info(self, short_uuid: str) -> Dict[str, Any]:
+        response = await self._make_request('GET', f'/api/sub/{short_uuid}/info')
+        return response['response']
+    
+    
+    async def get_system_stats(self) -> Dict[str, Any]:
+        response = await self._make_request('GET', '/api/system/stats')
+        return response['response']
+    
+    async def get_bandwidth_stats(self) -> Dict[str, Any]:
+        response = await self._make_request('GET', '/api/system/stats/bandwidth')
+        return response['response']
+    
+    async def get_nodes_statistics(self) -> Dict[str, Any]:
+        response = await self._make_request('GET', '/api/system/stats/nodes')
+        return response['response']
+    
+    async def get_nodes_realtime_usage(self) -> List[Dict[str, Any]]:
+        response = await self._make_request('GET', '/api/nodes/usage/realtime')
+        return response['response']
+    
+    
+    def _parse_user(self, user_data: Dict) -> RemnaWaveUser:
+        return RemnaWaveUser(
+            uuid=user_data['uuid'],
+            short_uuid=user_data['shortUuid'],
+            username=user_data['username'],
+            status=UserStatus(user_data['status']),
+            used_traffic_bytes=int(user_data['usedTrafficBytes']),
+            lifetime_used_traffic_bytes=int(user_data['lifetimeUsedTrafficBytes']),
+            traffic_limit_bytes=user_data['trafficLimitBytes'],
+            traffic_limit_strategy=TrafficLimitStrategy(user_data['trafficLimitStrategy']),
+            expire_at=datetime.fromisoformat(user_data['expireAt'].replace('Z', '+00:00')),
+            telegram_id=user_data.get('telegramId'),
+            email=user_data.get('email'),
+            hwid_device_limit=user_data.get('hwidDeviceLimit'),
+            description=user_data.get('description'),
+            tag=user_data.get('tag'),
+            subscription_url=user_data['subscriptionUrl'],
+            active_internal_squads=user_data['activeInternalSquads'],
+            created_at=datetime.fromisoformat(user_data['createdAt'].replace('Z', '+00:00')),
+            updated_at=datetime.fromisoformat(user_data['updatedAt'].replace('Z', '+00:00'))
+        )
+    
+    def _parse_internal_squad(self, squad_data: Dict) -> RemnaWaveInternalSquad:
+        return RemnaWaveInternalSquad(
+            uuid=squad_data['uuid'],
+            name=squad_data['name'],
+            members_count=squad_data['info']['membersCount'],
+            inbounds_count=squad_data['info']['inboundsCount'],
+            inbounds=squad_data['inbounds']
+        )
+    
+    def _parse_node(self, node_data: Dict) -> RemnaWaveNode:
+        return RemnaWaveNode(
+            uuid=node_data['uuid'],
+            name=node_data['name'],
+            address=node_data['address'],
+            country_code=node_data['countryCode'],
+            is_connected=node_data['isConnected'],
+            is_disabled=node_data['isDisabled'],
+            is_node_online=node_data['isNodeOnline'],
+            is_xray_running=node_data['isXrayRunning'],
+            users_online=node_data.get('usersOnline'),
+            traffic_used_bytes=node_data.get('trafficUsedBytes'),
+            traffic_limit_bytes=node_data.get('trafficLimitBytes')
+        )
+
+
+
+def format_bytes(bytes_value: int) -> str:
+    if bytes_value == 0:
+        return "0 B"
+    
+    units = ["B", "KB", "MB", "GB", "TB"]
+    size = bytes_value
+    unit_index = 0
+    
+    while size >= 1024 and unit_index < len(units) - 1:
+        size /= 1024
+        unit_index += 1
+    
+    return f"{size:.1f} {units[unit_index]}"
+
+
+def parse_bytes(size_str: str) -> int:
+    size_str = size_str.upper().strip()
+    
+    units = {
+        'B': 1,
+        'KB': 1024,
+        'MB': 1024 ** 2,
+        'GB': 1024 ** 3,
+        'TB': 1024 ** 4
+    }
+    
+    for unit, multiplier in units.items():
+        if size_str.endswith(unit):
+            try:
+                value = float(size_str[:-len(unit)].strip())
+                return int(value * multiplier)
+            except ValueError:
+                break
+    
+    return 0
+
+
+async def test_api_connection(api: RemnaWaveAPI) -> bool:
+    try:
+        await api.get_system_stats()
+        return True
+    except Exception as e:
+        logger.error(f"API connection test failed: {e}")
+        return False
+
+async def get_user_devices(self, user_uuid: str) -> Dict[str, Any]:
+    try:
+        response = await self._make_request('GET', f'/api/hwid/devices/{user_uuid}')
+        return response['response']
+    except RemnaWaveAPIError as e:
+        if e.status_code == 404:
+            return {'total': 0, 'devices': []}
+        raise
+
+
+async def reset_user_devices(self, user_uuid: str) -> bool:
+    try:
+        devices_info = await self.get_user_devices(user_uuid)
+        devices = devices_info.get('devices', [])
+        
+        if not devices:
+            return True
+        
+        failed_count = 0
+        for device in devices:
+            device_hwid = device.get('hwid')
+            if device_hwid:
+                try:
+                    delete_data = {
+                        "userUuid": user_uuid,
+                        "hwid": device_hwid
+                    }
+                    await self._make_request('POST', '/api/hwid/devices/delete', data=delete_data)
+                except Exception as device_error:
+                    logger.error(f"Ошибка удаления устройства {device_hwid}: {device_error}")
+                    failed_count += 1
+        
+        return failed_count < len(devices) / 2
+        
+    except Exception as e:
+        logger.error(f"Ошибка при сбросе устройств: {e}")
+        return False
+
+
+
+async def remove_device(self, user_uuid: str, device_hwid: str) -> bool:
+    try:
+        delete_data = {
+            "userUuid": user_uuid,
+            "hwid": device_hwid
+        }
+        await self._make_request('POST', '/api/hwid/devices/delete', data=delete_data)
+        return True
+    except Exception as e:
+        logger.error(f"Ошибка удаления устройства {device_hwid}: {e}")
+        return False

app/external/telegram_stars.py

@@ -0,0 +1,100 @@
+import logging
+from typing import Optional, Dict, Any
+from aiogram import Bot
+from aiogram.types import LabeledPrice, InlineKeyboardMarkup, InlineKeyboardButton
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class TelegramStarsService:
+    
+    def __init__(self, bot: Bot):
+        self.bot = bot
+    
+    async def create_invoice(
+        self,
+        chat_id: int,
+        title: str,
+        description: str,
+        amount_kopeks: int,
+        payload: str,
+        start_parameter: Optional[str] = None
+    ) -> Optional[str]:
+        try:
+            stars_amount = max(1, amount_kopeks // 100)
+            
+            invoice_link = await self.bot.create_invoice_link(
+                title=title,
+                description=description,
+                payload=payload,
+                provider_token="",
+                currency="XTR",
+                prices=[LabeledPrice(label=title, amount=stars_amount)],
+                start_parameter=start_parameter
+            )
+            
+            logger.info(f"Создан Stars invoice на {stars_amount} звезд для {chat_id}")
+            return invoice_link
+            
+        except Exception as e:
+            logger.error(f"Ошибка создания Stars invoice: {e}")
+            return None
+    
+    async def send_invoice(
+        self,
+        chat_id: int,
+        title: str,
+        description: str,
+        amount_kopeks: int,
+        payload: str,
+        keyboard: Optional[InlineKeyboardMarkup] = None
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            stars_amount = max(1, amount_kopeks // 100)
+            
+            message = await self.bot.send_invoice(
+                chat_id=chat_id,
+                title=title,
+                description=description,
+                payload=payload,
+                provider_token="",
+                currency="XTR",
+                prices=[LabeledPrice(label=title, amount=stars_amount)],
+                reply_markup=keyboard
+            )
+            
+            logger.info(f"Отправлен Stars invoice {message.message_id} на {stars_amount} звезд")
+            return {
+                "message_id": message.message_id,
+                "stars_amount": stars_amount,
+                "payload": payload
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки Stars invoice: {e}")
+            return None
+    
+    async def answer_pre_checkout_query(
+        self,
+        pre_checkout_query_id: str,
+        ok: bool = True,
+        error_message: Optional[str] = None
+    ) -> bool:
+        try:
+            await self.bot.answer_pre_checkout_query(
+                pre_checkout_query_id=pre_checkout_query_id,
+                ok=ok,
+                error_message=error_message
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Ошибка ответа на pre_checkout_query: {e}")
+            return False
+    
+    def calculate_stars_amount(self, rubles: float) -> int:
+        return max(1, int(rubles))
+    
+    def calculate_rubles_from_stars(self, stars: int) -> float:
+        return float(stars)

app/external/tribute.py

@@ -0,0 +1,108 @@
+import logging
+import hashlib
+import hmac
+import json
+from typing import Optional, Dict, Any
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class TributeService:
+    
+    def __init__(self):
+        self.api_key = settings.TRIBUTE_API_KEY
+        self.webhook_secret = settings.TRIBUTE_WEBHOOK_SECRET
+        self.donate_link = settings.TRIBUTE_DONATE_LINK
+    
+    async def create_payment_link(
+        self,
+        user_id: int,
+        amount_kopeks: int = 0,
+        description: str = "Пополнение баланса"
+    ) -> Optional[str]:
+        
+        if not settings.TRIBUTE_ENABLED:
+            logger.warning("Tribute платежи отключены")
+            return None
+        
+        try:
+            
+            payment_url = f"{self.donate_link}&user_id={user_id}"
+            
+            logger.info(f"Создана ссылка Tribute для пользователя {user_id}")
+            return payment_url
+            
+        except Exception as e:
+            logger.error(f"Ошибка создания Tribute ссылки: {e}")
+            return None
+    
+    def verify_webhook_signature(self, payload: str, signature: str) -> bool:
+        
+        if not self.webhook_secret:
+            logger.warning("Webhook secret не настроен")
+            return True 
+        
+        try:
+            expected_signature = hmac.new(
+                self.webhook_secret.encode(),
+                payload.encode(),
+                hashlib.sha256
+            ).hexdigest()
+            
+            return hmac.compare_digest(signature, expected_signature)
+            
+        except Exception as e:
+            logger.error(f"Ошибка проверки подписи webhook: {e}")
+            return False
+    
+    async def process_webhook(self, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        
+        try:
+            
+            payment_id = payload.get("id") or payload.get("payment_id")
+            status = payload.get("status")
+            amount_rubles = payload.get("amount", 0)
+            telegram_user_id = payload.get("telegram_user_id") or payload.get("user_id")
+            
+            if not payment_id and "payload" in payload:
+                data = payload["payload"]
+                payment_id = data.get("id") or data.get("payment_id")
+                status = data.get("status")
+                amount_rubles = data.get("amount", 0)
+                telegram_user_id = data.get("telegram_user_id") or data.get("user_id")
+            
+            if not payment_id and "name" in payload:
+                event_name = payload.get("name")
+                data = payload.get("payload", {})
+                payment_id = str(data.get("donation_request_id")) 
+                amount_kopeks = data.get("amount", 0) 
+                telegram_user_id = data.get("telegram_user_id")
+                
+                if event_name == "new_donation":
+                    status = "paid"
+                elif event_name == "cancelled_subscription":
+                    status = "cancelled"
+                else:
+                    status = "unknown"
+            
+            logger.info(f"Обработка Tribute webhook: payment_id={payment_id}, status={status}, amount_kopeks={amount_kopeks}, user_id={telegram_user_id}")
+            
+            if not telegram_user_id:
+                logger.error("Не найден telegram_user_id в webhook данных")
+                return None
+            
+            return {
+                "event_type": "payment",
+                "payment_id": payment_id or f"tribute_{telegram_user_id}_{amount_kopeks}",
+                "user_id": int(telegram_user_id),
+                "amount_kopeks": amount_kopeks,
+                "status": status or "paid",
+                "external_id": f"donation_{payment_id}"
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка обработки Tribute webhook: {e}")
+            logger.error(f"Webhook payload: {json.dumps(payload, ensure_ascii=False)}")
+            return None

app/external/webhook_server.py

@@ -0,0 +1,98 @@
+import logging
+from typing import Optional
+
+from aiohttp import web
+from aiogram import Bot
+
+from app.config import settings
+from app.services.tribute_service import TributeService
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookServer:
+    
+    def __init__(self, bot: Bot):
+        self.bot = bot
+        self.app = None
+        self.runner = None
+        self.site = None
+        self.tribute_service = TributeService(bot)
+    
+    async def create_app(self) -> web.Application:
+        
+        self.app = web.Application()
+        
+        self.app.router.add_post(settings.TRIBUTE_WEBHOOK_PATH, self._tribute_webhook_handler)
+        self.app.router.add_get('/health', self._health_check)
+        
+        logger.info(f"Webhook сервер настроен:")
+        logger.info(f"  - Tribute webhook: {settings.TRIBUTE_WEBHOOK_PATH}")
+        logger.info(f"  - Health check: /health")
+        
+        return self.app
+    
+    async def start(self):
+        
+        try:
+            if not self.app:
+                await self.create_app()
+            
+            self.runner = web.AppRunner(self.app)
+            await self.runner.setup()
+            
+            self.site = web.TCPSite(
+                self.runner,
+                host='0.0.0.0',
+                port=settings.TRIBUTE_WEBHOOK_PORT
+            )
+            
+            await self.site.start()
+            
+            logger.info(f"✅ Webhook сервер запущен на порту {settings.TRIBUTE_WEBHOOK_PORT}")
+            logger.info(f"🎯 Tribute webhook URL: http://your-server:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка запуска webhook сервера: {e}")
+            raise
+    
+    async def stop(self):
+        
+        try:
+            if self.site:
+                await self.site.stop()
+                logger.info("Webhook сайт остановлен")
+            
+            if self.runner:
+                await self.runner.cleanup()
+                logger.info("Webhook runner очищен")
+                
+        except Exception as e:
+            logger.error(f"Ошибка остановки webhook сервера: {e}")
+    
+    async def _tribute_webhook_handler(self, request: web.Request) -> web.Response:
+        
+        try:
+            raw_body = await request.read()
+            payload = raw_body.decode('utf-8')
+            
+            signature = request.headers.get('X-Tribute-Signature')
+            
+            result = await self.tribute_service.process_webhook(payload, signature)
+            
+            return web.json_response(result, status=200)
+            
+        except Exception as e:
+            logger.error(f"Ошибка обработки Tribute webhook: {e}")
+            return web.json_response(
+                {"status": "error", "reason": "internal_error"},
+                status=500
+            )
+    
+    async def _health_check(self, request: web.Request) -> web.Response:
+        
+        return web.json_response({
+            "status": "ok",
+            "service": "tribute-webhooks",
+            "tribute_enabled": settings.TRIBUTE_ENABLED
+        })

app/handlers/admin/__init__.py

@@ -0,0 +1 @@
+# Инициализация админских обработчиков

app/handlers/admin/main.py

@@ -0,0 +1,37 @@
+import logging
+from aiogram import Dispatcher, types, F
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.admin import get_admin_main_keyboard
+from app.localization.texts import get_texts
+from app.utils.decorators import admin_required, error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_admin_panel(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    
+    admin_text = texts.ADMIN_PANEL
+    
+    await callback.message.edit_text(
+        admin_text,
+        reply_markup=get_admin_main_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_admin_panel,
+        F.data == "admin_panel"
+    )

app/handlers/admin/messages.py

@@ -0,0 +1,551 @@
+import logging
+import asyncio
+from datetime import datetime, timedelta
+from typing import Optional
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, and_, or_
+
+from app.config import settings
+from app.states import AdminStates
+from app.database.models import User, UserStatus, Subscription, BroadcastHistory
+from app.keyboards.admin import (
+    get_admin_messages_keyboard, get_broadcast_target_keyboard,
+    get_custom_criteria_keyboard, get_broadcast_history_keyboard,
+    get_admin_pagination_keyboard
+)
+from app.localization.texts import get_texts
+from app.database.crud.user import get_users_list
+from app.database.crud.subscription import get_expiring_subscriptions
+from app.utils.decorators import admin_required, error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_messages_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    text = """
+📨 <b>Управление рассылками</b>
+
+Выберите тип рассылки:
+
+- <b>Всем пользователям</b> - рассылка всем активным пользователям
+- <b>По подпискам</b> - фильтрация по типу подписки
+- <b>По критериям</b> - настраиваемые фильтры
+- <b>История</b> - просмотр предыдущих рассылок
+
+⚠️ Будьте осторожны с массовыми рассылками!
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_admin_messages_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_broadcast_targets(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    await callback.message.edit_text(
+        "🎯 <b>Выбор целевой аудитории</b>\n\n"
+        "Выберите категорию пользователей для рассылки:",
+        reply_markup=get_broadcast_target_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_messages_history(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    page = 1
+    if '_page_' in callback.data:
+        page = int(callback.data.split('_page_')[1])
+    
+    limit = 10
+    offset = (page - 1) * limit
+    
+    stmt = select(BroadcastHistory).order_by(BroadcastHistory.created_at.desc()).offset(offset).limit(limit)
+    result = await db.execute(stmt)
+    broadcasts = result.scalars().all()
+    
+    count_stmt = select(func.count(BroadcastHistory.id))
+    count_result = await db.execute(count_stmt)
+    total_count = count_result.scalar() or 0
+    total_pages = (total_count + limit - 1) // limit
+    
+    if not broadcasts:
+        text = """
+📋 <b>История рассылок</b>
+
+❌ История рассылок пуста.
+Отправьте первую рассылку, чтобы увидеть её здесь.
+"""
+        keyboard = [[types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_messages")]]
+    else:
+        text = f"📋 <b>История рассылок</b> (страница {page}/{total_pages})\n\n"
+        
+        for broadcast in broadcasts:
+            status_emoji = "✅" if broadcast.status == "completed" else "❌" if broadcast.status == "failed" else "⏳"
+            success_rate = round((broadcast.sent_count / broadcast.total_count * 100), 1) if broadcast.total_count > 0 else 0
+            
+            message_preview = broadcast.message_text[:100] + "..." if len(broadcast.message_text) > 100 else broadcast.message_text
+            
+            text += f"""
+{status_emoji} <b>{broadcast.created_at.strftime('%d.%m.%Y %H:%M')}</b>
+📊 Отправлено: {broadcast.sent_count}/{broadcast.total_count} ({success_rate}%)
+🎯 Аудитория: {get_target_name(broadcast.target_type)}
+👤 Админ: {broadcast.admin_name}
+📝 Сообщение: <i>{message_preview}</i>
+━━━━━━━━━━━━━━━━━━━━
+"""
+        
+        keyboard = get_broadcast_history_keyboard(page, total_pages, db_user.language).inline_keyboard
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_custom_broadcast(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    
+    stats = await get_users_statistics(db)
+    
+    text = f"""
+🔍 <b>Рассылка по критериям</b>
+
+📊 <b>Доступные фильтры:</b>
+
+👥 <b>По регистрации:</b>
+• Сегодня: {stats['today']} чел.
+• За неделю: {stats['week']} чел.
+• За месяц: {stats['month']} чел.
+
+💼 <b>По активности:</b>
+• Активные сегодня: {stats['active_today']} чел.
+• Неактивные 7+ дней: {stats['inactive_week']} чел.
+• Неактивные 30+ дней: {stats['inactive_month']} чел.
+
+🔗 <b>По источнику:</b>
+• Через рефералов: {stats['referrals']} чел.
+• Прямая регистрация: {stats['direct']} чел.
+
+Выберите критерий для фильтрации:
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_custom_criteria_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def select_custom_criteria(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    criteria = callback.data.replace('criteria_', '')
+    
+    criteria_names = {
+        "today": "Зарегистрированные сегодня",
+        "week": "Зарегистрированные за неделю",
+        "month": "Зарегистрированные за месяц",
+        "active_today": "Активные сегодня",
+        "inactive_week": "Неактивные 7+ дней",
+        "inactive_month": "Неактивные 30+ дней",
+        "referrals": "Пришедшие через рефералов",
+        "direct": "Прямая регистрация"
+    }
+    
+    user_count = await get_custom_users_count(db, criteria)
+    
+    await state.update_data(broadcast_target=f"custom_{criteria}")
+    
+    await callback.message.edit_text(
+        f"📨 <b>Создание рассылки</b>\n\n"
+        f"🎯 <b>Критерий:</b> {criteria_names.get(criteria, criteria)}\n"
+        f"👥 <b>Получателей:</b> {user_count}\n\n"
+        f"Введите текст сообщения для рассылки:\n\n"
+        f"<i>Поддерживается HTML разметка</i>",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_messages")]
+        ])
+    )
+    
+    await state.set_state(AdminStates.waiting_for_broadcast_message)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def select_broadcast_target(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    target = callback.data.split('_')[-1]
+    
+    target_names = {
+        "all": "Всем пользователям",
+        "active": "С активной подпиской",
+        "trial": "С триальной подпиской", 
+        "no": "Без подписки",
+        "expiring": "С истекающей подпиской"
+    }
+    
+    user_count = await get_target_users_count(db, target)
+    
+    await state.update_data(broadcast_target=target)
+    
+    await callback.message.edit_text(
+        f"📨 <b>Создание рассылки</b>\n\n"
+        f"🎯 <b>Аудитория:</b> {target_names.get(target, target)}\n"
+        f"👥 <b>Получателей:</b> {user_count}\n\n"
+        f"Введите текст сообщения для рассылки:\n\n"
+        f"<i>Поддерживается HTML разметка</i>",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_messages")]
+        ])
+    )
+    
+    await state.set_state(AdminStates.waiting_for_broadcast_message)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_broadcast_message(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    broadcast_text = message.text
+    
+    if len(broadcast_text) > 4000:
+        await message.answer("❌ Сообщение слишком длинное (максимум 4000 символов)")
+        return
+    
+    data = await state.get_data()
+    target = data.get('broadcast_target')
+    
+    user_count = await get_target_users_count(db, target) if not target.startswith('custom_') else await get_custom_users_count(db, target.replace('custom_', ''))
+    
+    await state.update_data(broadcast_message=broadcast_text)
+    
+    target_display = get_target_display_name(target)
+    
+    preview_text = f"""
+📨 <b>Предварительный просмотр рассылки</b>
+
+🎯 <b>Аудитория:</b> {target_display}
+👥 <b>Получателей:</b> {user_count}
+
+📝 <b>Сообщение:</b>
+{broadcast_text}
+
+Подтвердить отправку?
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="✅ Отправить", callback_data="admin_confirm_broadcast"),
+            types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_messages")
+        ]
+    ]
+    
+    await message.answer(
+        preview_text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await state.set_state(AdminStates.confirming_broadcast)
+
+
+@admin_required
+@error_handler
+async def confirm_broadcast(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    target = data.get('broadcast_target')
+    message_text = data.get('broadcast_message')
+    
+    await callback.message.edit_text(
+        "📨 Начинаю рассылку...\n\n"
+        "⏳ Это может занять несколько минут.",
+        reply_markup=None
+    )
+    
+    if target.startswith('custom_'):
+        users = await get_custom_users(db, target.replace('custom_', ''))
+    else:
+        users = await get_target_users(db, target)
+    
+    broadcast_history = BroadcastHistory(
+        target_type=target,
+        message_text=message_text,
+        total_count=len(users),
+        sent_count=0,
+        failed_count=0,
+        admin_id=db_user.id,
+        admin_name=db_user.full_name,
+        status="in_progress"
+    )
+    db.add(broadcast_history)
+    await db.commit()
+    await db.refresh(broadcast_history)
+    
+    sent_count = 0
+    failed_count = 0
+    
+    for user in users:
+        try:
+            await callback.bot.send_message(
+                chat_id=user.telegram_id,
+                text=message_text,
+                parse_mode="HTML"
+            )
+            sent_count += 1
+            
+            if sent_count % 20 == 0:
+                await asyncio.sleep(1)
+                
+        except Exception as e:
+            failed_count += 1
+            logger.error(f"Ошибка отправки рассылки пользователю {user.telegram_id}: {e}")
+    
+    broadcast_history.sent_count = sent_count
+    broadcast_history.failed_count = failed_count
+    broadcast_history.status = "completed" if failed_count == 0 else "partial"
+    broadcast_history.completed_at = datetime.utcnow()
+    await db.commit()
+    
+    result_text = f"""
+✅ <b>Рассылка завершена!</b>
+
+📊 <b>Результат:</b>
+- Отправлено: {sent_count}
+- Не доставлено: {failed_count}
+- Всего пользователей: {len(users)}
+- Успешность: {round(sent_count / len(users) * 100, 1) if users else 0}%
+
+<b>Администратор:</b> {db_user.full_name}
+"""
+    
+    await callback.message.edit_text(
+        result_text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="📨 К рассылкам", callback_data="admin_messages")]
+        ])
+    )
+    
+    await state.clear()
+    logger.info(f"Рассылка выполнена админом {db_user.telegram_id}: {sent_count}/{len(users)}")
+
+
+async def get_target_users_count(db: AsyncSession, target: str) -> int:
+    users = await get_target_users(db, target)
+    return len(users)
+
+
+async def get_target_users(db: AsyncSession, target: str) -> list:
+   if target == "all":
+       return await get_users_list(db, offset=0, limit=10000, status=UserStatus.ACTIVE)
+   elif target == "active":
+       users = await get_users_list(db, offset=0, limit=10000, status=UserStatus.ACTIVE)
+       return [user for user in users if user.subscription and user.subscription.is_active and not user.subscription.is_trial]
+   elif target == "trial":
+       users = await get_users_list(db, offset=0, limit=10000, status=UserStatus.ACTIVE)
+       return [user for user in users if user.subscription and user.subscription.is_trial]
+   elif target == "no":
+       users = await get_users_list(db, offset=0, limit=10000, status=UserStatus.ACTIVE)
+       return [user for user in users if not user.subscription or not user.subscription.is_active]
+   elif target == "expiring":
+       expiring_subs = await get_expiring_subscriptions(db, 3)
+       return [sub.user for sub in expiring_subs if sub.user]
+   else:
+       return []
+
+
+async def get_custom_users_count(db: AsyncSession, criteria: str) -> int:
+    users = await get_custom_users(db, criteria)
+    return len(users)
+
+
+async def get_custom_users(db: AsyncSession, criteria: str) -> list:
+    """Получение пользователей по настраиваемым критериям"""
+    now = datetime.utcnow()
+    today = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    week_ago = now - timedelta(days=7)
+    month_ago = now - timedelta(days=30)
+    
+    if criteria == "today":
+        stmt = select(User).where(
+            and_(User.status == "active", User.created_at >= today)
+        )
+    elif criteria == "week":
+        stmt = select(User).where(
+            and_(User.status == "active", User.created_at >= week_ago)
+        )
+    elif criteria == "month":
+        stmt = select(User).where(
+            and_(User.status == "active", User.created_at >= month_ago)
+        )
+    elif criteria == "active_today":
+        stmt = select(User).where(
+            and_(User.status == "active", User.last_activity >= today)
+        )
+    elif criteria == "inactive_week":
+        stmt = select(User).where(
+            and_(User.status == "active", User.last_activity < week_ago)
+        )
+    elif criteria == "inactive_month":
+        stmt = select(User).where(
+            and_(User.status == "active", User.last_activity < month_ago)
+        )
+    elif criteria == "referrals":
+        stmt = select(User).where(
+            and_(User.status == "active", User.referred_by_id.isnot(None))
+        )
+    elif criteria == "direct":
+        stmt = select(User).where(
+            and_(
+                User.status == "active", 
+                User.referred_by_id.is_(None)
+            )
+        )
+    else:
+        return []
+    
+    result = await db.execute(stmt)
+    return result.scalars().all()
+
+
+async def get_users_statistics(db: AsyncSession) -> dict:
+    """Получение статистики пользователей для отображения"""
+    now = datetime.utcnow()
+    today = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    week_ago = now - timedelta(days=7)
+    month_ago = now - timedelta(days=30)
+    
+    stats = {}
+    
+    stats['today'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(User.status == "active", User.created_at >= today)
+        )
+    ) or 0
+    
+    stats['week'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(User.status == "active", User.created_at >= week_ago)
+        )
+    ) or 0
+    
+    stats['month'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(User.status == "active", User.created_at >= month_ago)
+        )
+    ) or 0
+    
+    stats['active_today'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(User.status == "active", User.last_activity >= today)
+        )
+    ) or 0
+    
+    stats['inactive_week'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(User.status == "active", User.last_activity < week_ago)
+        )
+    ) or 0
+    
+    stats['inactive_month'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(User.status == "active", User.last_activity < month_ago)
+        )
+    ) or 0
+    
+    stats['referrals'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(User.status == "active", User.referred_by_id.isnot(None))
+        )
+    ) or 0
+    
+    stats['direct'] = await db.scalar(
+        select(func.count(User.id)).where(
+            and_(
+                User.status == "active", 
+                User.referred_by_id.is_(None)
+            )
+        )
+    ) or 0
+    
+    return stats
+
+
+def get_target_name(target_type: str) -> str:
+    names = {
+        "all": "Всем пользователям",
+        "active": "С активной подпиской",
+        "trial": "С триальной подпиской",
+        "no": "Без подписки",
+        "expiring": "С истекающей подпиской",
+        "custom_today": "Зарегистрированные сегодня",
+        "custom_week": "Зарегистрированные за неделю",
+        "custom_month": "Зарегистрированные за месяц",
+        "custom_active_today": "Активные сегодня",
+        "custom_inactive_week": "Неактивные 7+ дней",
+        "custom_inactive_month": "Неактивные 30+ дней",
+        "custom_referrals": "Через рефералов",
+        "custom_direct": "Прямая регистрация"
+    }
+    return names.get(target_type, target_type)
+
+
+def get_target_display_name(target: str) -> str:
+    return get_target_name(target)
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(show_messages_menu, F.data == "admin_messages")
+    dp.callback_query.register(show_broadcast_targets, F.data.in_(["admin_msg_all", "admin_msg_by_sub"]))
+    dp.callback_query.register(select_broadcast_target, F.data.startswith("broadcast_"))
+    dp.callback_query.register(confirm_broadcast, F.data == "admin_confirm_broadcast")
+    
+    dp.callback_query.register(show_messages_history, F.data.startswith("admin_msg_history"))
+    dp.callback_query.register(show_custom_broadcast, F.data == "admin_msg_custom")
+    dp.callback_query.register(select_custom_criteria, F.data.startswith("criteria_"))
+    
+    dp.message.register(process_broadcast_message, AdminStates.waiting_for_broadcast_message)

app/handlers/admin/monitoring.py

@@ -0,0 +1,313 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.filters import Command
+
+from app.config import settings
+from app.database.database import get_db
+from app.services.monitoring_service import monitoring_service
+from app.utils.decorators import admin_required
+from app.keyboards.admin import get_monitoring_keyboard, get_admin_main_keyboard
+from app.localization.texts import get_texts
+
+logger = logging.getLogger(__name__)
+router = Router()
+
+
+@router.callback_query(F.data == "admin_monitoring")
+@admin_required
+async def admin_monitoring_menu(callback: CallbackQuery):
+    """Главное меню мониторинга"""
+    try:
+        async for db in get_db():
+            status = await monitoring_service.get_monitoring_status(db)
+            
+            running_status = "🟢 Работает" if status['is_running'] else "🔴 Остановлен"
+            last_update = status['last_update'].strftime('%H:%M:%S') if status['last_update'] else "Никогда"
+            
+            text = f"""
+🔍 <b>Система мониторинга</b>
+
+📊 <b>Статус:</b> {running_status}
+🕐 <b>Последнее обновление:</b> {last_update}
+⚙️ <b>Интервал проверки:</b> {settings.MONITORING_INTERVAL} мин
+
+📈 <b>Статистика за 24 часа:</b>
+• Всего событий: {status['stats_24h']['total_events']}
+• Успешных: {status['stats_24h']['successful']}
+• Ошибок: {status['stats_24h']['failed']}
+• Успешность: {status['stats_24h']['success_rate']}%
+
+🔧 Выберите действие:
+"""
+            
+            keyboard = get_monitoring_keyboard()
+            await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
+            break
+            
+    except Exception as e:
+        logger.error(f"Ошибка в админ меню мониторинга: {e}")
+        await callback.answer("❌ Ошибка получения данных", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_start")
+@admin_required
+async def start_monitoring_callback(callback: CallbackQuery):
+    try:
+        if monitoring_service.is_running:
+            await callback.answer("ℹ️ Мониторинг уже запущен")
+            return
+        
+        if not monitoring_service.bot:
+            monitoring_service.bot = callback.bot
+        
+        asyncio.create_task(monitoring_service.start_monitoring())
+        
+        await callback.answer("✅ Мониторинг запущен!")
+        
+        await admin_monitoring_menu(callback)
+        
+    except Exception as e:
+        logger.error(f"Ошибка запуска мониторинга: {e}")
+        await callback.answer(f"❌ Ошибка запуска: {str(e)}", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_stop")
+@admin_required
+async def stop_monitoring_callback(callback: CallbackQuery):
+    try:
+        if not monitoring_service.is_running:
+            await callback.answer("ℹ️ Мониторинг уже остановлен")
+            return
+        
+        monitoring_service.stop_monitoring()
+        await callback.answer("⏹️ Мониторинг остановлен!")
+        
+        await admin_monitoring_menu(callback)
+        
+    except Exception as e:
+        logger.error(f"Ошибка остановки мониторинга: {e}")
+        await callback.answer(f"❌ Ошибка остановки: {str(e)}", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_force_check")
+@admin_required
+async def force_check_callback(callback: CallbackQuery):
+    try:
+        await callback.answer("⏳ Выполняем проверку подписок...")
+        
+        async for db in get_db():
+            results = await monitoring_service.force_check_subscriptions(db)
+            
+            text = f"""
+✅ <b>Принудительная проверка завершена</b>
+
+📊 <b>Результаты проверки:</b>
+• Истекших подписок: {results['expired']}
+• Истекающих подписок: {results['expiring']}
+• Готовых к автооплате: {results['autopay_ready']}
+
+🕐 <b>Время проверки:</b> {datetime.now().strftime('%H:%M:%S')}
+
+Нажмите "Назад" для возврата в меню мониторинга.
+"""
+            
+            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_monitoring")]
+            ])
+            
+            await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
+            break
+            
+    except Exception as e:
+        logger.error(f"Ошибка принудительной проверки: {e}")
+        await callback.answer(f"❌ Ошибка проверки: {str(e)}", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_logs")
+@admin_required
+async def monitoring_logs_callback(callback: CallbackQuery):
+    try:
+        async for db in get_db():
+            logs = await monitoring_service.get_monitoring_logs(db, limit=15)
+            
+            if not logs:
+                text = "📝 <b>Логи мониторинга пусты</b>\n\nСистема еще не выполняла проверки."
+            else:
+                text = "📝 <b>Последние логи мониторинга:</b>\n\n"
+                
+                for log in logs:
+                    icon = "✅" if log['is_success'] else "❌"
+                    time_str = log['created_at'].strftime('%m-%d %H:%M')
+                    event_type = log['event_type'].replace('_', ' ').title()
+                    
+                    text += f"{icon} <code>{time_str}</code> {event_type}\n"
+                    
+                    message = log['message']
+                    if len(message) > 60:
+                        message = message[:60] + "..."
+                    
+                    text += f"   📄 {message}\n\n"
+                    
+                    if len(text) > 3500:
+                        text += "...\n\n<i>Показаны последние записи. Для просмотра всех логов используйте файл логов.</i>"
+                        break
+            
+            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [
+                    InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_mon_logs"),
+                    InlineKeyboardButton(text="🗑️ Очистить", callback_data="admin_mon_clear_logs")
+                ],
+                [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_monitoring")]
+            ])
+            
+            await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
+            break
+            
+    except Exception as e:
+        logger.error(f"Ошибка получения логов: {e}")
+        await callback.answer(f"❌ Ошибка получения логов: {str(e)}", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_clear_logs")
+@admin_required
+async def clear_logs_callback(callback: CallbackQuery):
+    try:
+        async for db in get_db():
+            deleted_count = await monitoring_service.cleanup_old_logs(db, days=7)
+            
+            if deleted_count > 0:
+                await callback.answer(f"🗑️ Удалено {deleted_count} старых записей логов")
+            else:
+                await callback.answer("ℹ️ Нет старых логов для удаления")
+            
+            await monitoring_logs_callback(callback)
+            break
+            
+    except Exception as e:
+        logger.error(f"Ошибка очистки логов: {e}")
+        await callback.answer(f"❌ Ошибка очистки: {str(e)}", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_test_notifications")
+@admin_required
+async def test_notifications_callback(callback: CallbackQuery):
+    """Тест системы уведомлений"""
+    try:
+        test_message = f"""
+🧪 <b>Тестовое уведомление системы мониторинга</b>
+
+Это тестовое сообщение для проверки работы системы уведомлений.
+
+📊 <b>Статус системы:</b>
+• Мониторинг: {'🟢 Работает' if monitoring_service.is_running else '🔴 Остановлен'}
+• Уведомления: {'🟢 Включены' if settings.ENABLE_NOTIFICATIONS else '🔴 Отключены'}
+• Время теста: {datetime.now().strftime('%H:%M:%S %d.%m.%Y')}
+
+✅ Если вы получили это сообщение, система уведомлений работает корректно!
+"""
+        
+        await callback.bot.send_message(
+            callback.from_user.id,
+            test_message,
+            parse_mode="HTML"
+        )
+        
+        await callback.answer("✅ Тестовое уведомление отправлено!")
+        
+    except Exception as e:
+        logger.error(f"Ошибка отправки тестового уведомления: {e}")
+        await callback.answer(f"❌ Ошибка отправки: {str(e)}", show_alert=True)
+
+
+@router.callback_query(F.data == "admin_mon_statistics")
+@admin_required
+async def monitoring_statistics_callback(callback: CallbackQuery):
+    try:
+        async for db in get_db():
+            from app.database.crud.subscription import get_subscriptions_statistics
+            sub_stats = await get_subscriptions_statistics(db)
+            
+            mon_status = await monitoring_service.get_monitoring_status(db)
+            
+            week_ago = datetime.now() - timedelta(days=7)
+            week_logs = await monitoring_service.get_monitoring_logs(db, limit=1000)
+            week_logs = [log for log in week_logs if log['created_at'] >= week_ago]
+            
+            week_success = sum(1 for log in week_logs if log['is_success'])
+            week_errors = len(week_logs) - week_success
+            
+            text = f"""
+📊 <b>Статистика мониторинга</b>
+
+📱 <b>Подписки:</b>
+• Всего: {sub_stats['total_subscriptions']}
+• Активных: {sub_stats['active_subscriptions']}
+• Тестовых: {sub_stats['trial_subscriptions']}
+• Платных: {sub_stats['paid_subscriptions']}
+
+📈 <b>За сегодня:</b>
+• Успешных операций: {mon_status['stats_24h']['successful']}
+• Ошибок: {mon_status['stats_24h']['failed']}
+• Успешность: {mon_status['stats_24h']['success_rate']}%
+
+📊 <b>За неделю:</b>
+• Всего событий: {len(week_logs)}
+• Успешных: {week_success}
+• Ошибок: {week_errors}
+• Успешность: {round(week_success/len(week_logs)*100, 1) if week_logs else 0}%
+
+🔧 <b>Система:</b>
+• Интервал: {settings.MONITORING_INTERVAL} мин
+• Уведомления: {'🟢 Вкл' if getattr(settings, 'ENABLE_NOTIFICATIONS', True) else '🔴 Выкл'}
+• Автооплата: {', '.join(map(str, settings.get_autopay_warning_days()))} дней
+"""
+            
+            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_monitoring")]
+            ])
+            
+            await callback.message.edit_text(text, parse_mode="HTML", reply_markup=keyboard)
+            break
+            
+    except Exception as e:
+        logger.error(f"Ошибка получения статистики: {e}")
+        await callback.answer(f"❌ Ошибка получения статистики: {str(e)}", show_alert=True)
+
+
+@router.message(Command("monitoring"))
+@admin_required
+async def monitoring_command(message: Message):
+    """Команда /monitoring для быстрого доступа"""
+    try:
+        async for db in get_db():
+            status = await monitoring_service.get_monitoring_status(db)
+            
+            running_status = "🟢 Работает" if status['is_running'] else "🔴 Остановлен"
+            
+            text = f"""
+🔍 <b>Быстрый статус мониторинга</b>
+
+📊 <b>Статус:</b> {running_status}
+📈 <b>События за 24ч:</b> {status['stats_24h']['total_events']}
+✅ <b>Успешность:</b> {status['stats_24h']['success_rate']}%
+
+Для подробного управления используйте админ-панель.
+"""
+            
+            await message.answer(text, parse_mode="HTML")
+            break
+            
+    except Exception as e:
+        logger.error(f"Ошибка команды /monitoring: {e}")
+        await message.answer(f"❌ Ошибка: {str(e)}")
+
+
+def register_handlers(dp):
+    """Регистрация обработчиков мониторинга"""
+    dp.include_router(router)

app/handlers/admin/promocodes.py

@@ -0,0 +1,562 @@
+import logging
+from datetime import datetime, timedelta
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.states import AdminStates
+from app.database.models import User, PromoCodeType
+from app.keyboards.admin import (
+    get_admin_promocodes_keyboard, get_promocode_type_keyboard,
+    get_admin_pagination_keyboard, get_confirmation_keyboard
+)
+from app.localization.texts import get_texts
+from app.database.crud.promocode import (
+    get_promocodes_list, get_promocodes_count, create_promocode,
+    get_promocode_statistics, get_promocode_by_code, update_promocode,
+    delete_promocode
+)
+from app.utils.decorators import admin_required, error_handler
+from app.utils.formatters import format_datetime
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_promocodes_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    total_codes = await get_promocodes_count(db)
+    active_codes = await get_promocodes_count(db, is_active=True)
+    
+    text = f"""
+🎫 <b>Управление промокодами</b>
+
+📊 <b>Статистика:</b>
+- Всего промокодов: {total_codes}
+- Активных: {active_codes}
+- Неактивных: {total_codes - active_codes}
+
+Выберите действие:
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_admin_promocodes_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_promocodes_list(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    page: int = 1
+):
+    limit = 10
+    offset = (page - 1) * limit
+    
+    promocodes = await get_promocodes_list(db, offset=offset, limit=limit)
+    total_count = await get_promocodes_count(db)
+    total_pages = (total_count + limit - 1) // limit
+    
+    if not promocodes:
+        await callback.message.edit_text(
+            "🎫 Промокоды не найдены",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_promocodes")]
+            ])
+        )
+        await callback.answer()
+        return
+    
+    text = f"🎫 <b>Список промокодов</b> (стр. {page}/{total_pages})\n\n"
+    
+    for promo in promocodes:
+        status_emoji = "✅" if promo.is_active else "❌"
+        type_emoji = {"balance": "💰", "subscription_days": "📅", "trial_subscription": "🎁"}.get(promo.type, "🎫")
+        
+        text += f"{status_emoji} {type_emoji} <code>{promo.code}</code>\n"
+        text += f"📊 Использований: {promo.current_uses}/{promo.max_uses}\n"
+        
+        if promo.type == PromoCodeType.BALANCE.value:
+            text += f"💰 Бонус: {settings.format_price(promo.balance_bonus_kopeks)}\n"
+        elif promo.type == PromoCodeType.SUBSCRIPTION_DAYS.value:
+            text += f"📅 Дней: {promo.subscription_days}\n"
+        
+        if promo.valid_until:
+            text += f"⏰ До: {format_datetime(promo.valid_until)}\n"
+        
+        text += f"🔧 Управление: /promo_{promo.id}\n\n"
+    
+    keyboard = []
+    
+    if total_pages > 1:
+        pagination_row = get_admin_pagination_keyboard(
+            page, total_pages, "admin_promo_list", "admin_promocodes", db_user.language
+        ).inline_keyboard[0]
+        keyboard.append(pagination_row)
+    
+    keyboard.extend([
+        [types.InlineKeyboardButton(text="➕ Создать", callback_data="admin_promo_create")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_promocodes")]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_promocode_management(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    promo_id = int(callback.data.split('_')[-1])
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    status_emoji = "✅" if promo.is_active else "❌"
+    type_emoji = {"balance": "💰", "subscription_days": "📅", "trial_subscription": "🎁"}.get(promo.type, "🎫")
+    
+    text = f"""
+🎫 <b>Управление промокодом</b>
+
+{type_emoji} <b>Код:</b> <code>{promo.code}</code>
+{status_emoji} <b>Статус:</b> {'Активен' if promo.is_active else 'Неактивен'}
+📊 <b>Использований:</b> {promo.current_uses}/{promo.max_uses}
+"""
+    
+    if promo.type == PromoCodeType.BALANCE.value:
+        text += f"💰 <b>Бонус:</b> {settings.format_price(promo.balance_bonus_kopeks)}\n"
+    elif promo.type == PromoCodeType.SUBSCRIPTION_DAYS.value:
+        text += f"📅 <b>Дней:</b> {promo.subscription_days}\n"
+    
+    if promo.valid_until:
+        text += f"⏰ <b>Действует до:</b> {format_datetime(promo.valid_until)}\n"
+    
+    text += f"📅 <b>Создан:</b> {format_datetime(promo.created_at)}\n"
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(
+                text="✏️ Редактировать", 
+                callback_data=f"promo_edit_{promo.id}"
+            ),
+            types.InlineKeyboardButton(
+                text="🔄 Переключить статус", 
+                callback_data=f"promo_toggle_{promo.id}"
+            )
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="📊 Статистика", 
+                callback_data=f"promo_stats_{promo.id}"
+            ),
+            types.InlineKeyboardButton(
+                text="🗑️ Удалить", 
+                callback_data=f"promo_delete_{promo.id}"
+            )
+        ],
+        [
+            types.InlineKeyboardButton(text="⬅️ К списку", callback_data="admin_promo_list")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def toggle_promocode_status(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    promo_id = int(callback.data.split('_')[-1])
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    new_status = not promo.is_active
+    await update_promocode(db, promo, is_active=new_status)
+    
+    status_text = "активирован" if new_status else "деактивирован"
+    await callback.answer(f"✅ Промокод {status_text}", show_alert=True)
+    
+    await show_promocode_management(callback, db_user, db)
+
+
+@admin_required
+@error_handler
+async def confirm_delete_promocode(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    promo_id = int(callback.data.split('_')[-1])
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    text = f"""
+⚠️ <b>Подтверждение удаления</b>
+
+Вы действительно хотите удалить промокод <code>{promo.code}</code>?
+
+<b>Внимание:</b> Это действие нельзя отменить!
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [
+            types.InlineKeyboardButton(
+                text="✅ Да, удалить", 
+                callback_data=f"promo_delete_confirm_{promo.id}"
+            ),
+            types.InlineKeyboardButton(
+                text="❌ Отмена", 
+                callback_data=f"promo_manage_{promo.id}"
+            )
+        ]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def delete_promocode_confirmed(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    promo_id = int(callback.data.split('_')[-1])
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    code = promo.code
+    success = await delete_promocode(db, promo)
+    
+    if success:
+        await callback.answer(f"✅ Промокод {code} удален", show_alert=True)
+        await show_promocodes_list(callback, db_user, db)
+    else:
+        await callback.answer("❌ Ошибка удаления промокода", show_alert=True)
+
+
+@admin_required
+@error_handler
+async def show_promocode_stats(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    promo_id = int(callback.data.split('_')[-1])
+    
+    promo = await db.get(PromoCode, promo_id)
+    if not promo:
+        await callback.answer("❌ Промокод не найден", show_alert=True)
+        return
+    
+    stats = await get_promocode_statistics(db, promo_id)
+    
+    text = f"""
+📊 <b>Статистика промокода</b> <code>{promo.code}</code>
+
+📈 <b>Общая статистика:</b>
+- Всего использований: {stats['total_uses']}
+- Использований сегодня: {stats['today_uses']}
+- Осталось использований: {promo.max_uses - promo.current_uses}
+
+📅 <b>Последние использования:</b>
+"""
+    
+    for use in stats['recent_uses'][:5]:
+        use_date = format_datetime(use.used_at)
+        text += f"- {use_date} (ID: {use.user_id})\n"
+    
+    if not stats['recent_uses']:
+        text += "- Пока не было использований\n"
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [
+            types.InlineKeyboardButton(
+                text="⬅️ Назад", 
+                callback_data=f"promo_manage_{promo.id}"
+            )
+        ]
+    ])
+    
+    await callback.message.edit_text(text, reply_markup=keyboard)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_promocode_creation(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    await callback.message.edit_text(
+        "🎫 <b>Создание промокода</b>\n\n"
+        "Выберите тип промокода:",
+        reply_markup=get_promocode_type_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def select_promocode_type(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    promo_type = callback.data.split('_')[-1]
+    
+    type_names = {
+        "balance": "💰 Пополнение баланса",
+        "days": "📅 Дни подписки", 
+        "trial": "🎁 Тестовая подписка"
+    }
+    
+    await state.update_data(promocode_type=promo_type)
+    
+    await callback.message.edit_text(
+        f"🎫 <b>Создание промокода</b>\n\n"
+        f"Тип: {type_names.get(promo_type, promo_type)}\n\n"
+        f"Введите код промокода (только латинские буквы и цифры):",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_promocodes")]
+        ])
+    )
+    
+    await state.set_state(AdminStates.creating_promocode)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_promocode_code(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    code = message.text.strip().upper()
+    
+    if not code.isalnum() or len(code) < 3 or len(code) > 20:
+        await message.answer("❌ Код должен содержать только латинские буквы и цифры (3-20 символов)")
+        return
+    
+    from app.database.crud.promocode import get_promocode_by_code
+    existing = await get_promocode_by_code(db, code)
+    if existing:
+        await message.answer("❌ Промокод с таким кодом уже существует")
+        return
+    
+    await state.update_data(promocode_code=code)
+    
+    data = await state.get_data()
+    promo_type = data.get('promocode_type')
+    
+    if promo_type == "balance":
+        await message.answer(
+            f"💰 <b>Промокод:</b> <code>{code}</code>\n\n"
+            f"Введите сумму пополнения баланса (в рублях):"
+        )
+        await state.set_state(AdminStates.setting_promocode_value)
+    elif promo_type == "days":
+        await message.answer(
+            f"📅 <b>Промокод:</b> <code>{code}</code>\n\n"
+            f"Введите количество дней подписки:"
+        )
+        await state.set_state(AdminStates.setting_promocode_value)
+    elif promo_type == "trial":
+        await message.answer(
+            f"🎁 <b>Промокод:</b> <code>{code}</code>\n\n"
+            f"Введите количество дней тестовой подписки:"
+        )
+        await state.set_state(AdminStates.setting_promocode_value)
+
+
+@admin_required
+@error_handler
+async def process_promocode_value(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext
+):
+    try:
+        value = int(message.text.strip())
+        
+        data = await state.get_data()
+        promo_type = data.get('promocode_type')
+        
+        if promo_type == "balance" and (value < 1 or value > 10000):
+            await message.answer("❌ Сумма должна быть от 1 до 10,000 рублей")
+            return
+        elif promo_type in ["days", "trial"] and (value < 1 or value > 3650):
+            await message.answer("❌ Количество дней должно быть от 1 до 3650")
+            return
+        
+        await state.update_data(promocode_value=value)
+        
+        await message.answer(
+            f"📊 Введите количество использований промокода (или 0 для безлимита):"
+        )
+        await state.set_state(AdminStates.setting_promocode_uses)
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число")
+
+
+@admin_required
+@error_handler
+async def process_promocode_uses(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext
+):
+    try:
+        max_uses = int(message.text.strip())
+        
+        if max_uses < 0 or max_uses > 100000:
+            await message.answer("❌ Количество использований должно быть от 0 до 100,000")
+            return
+        
+        if max_uses == 0:
+            max_uses = 999999
+        
+        await state.update_data(promocode_max_uses=max_uses)
+        
+        await message.answer(
+            f"⏰ Введите срок действия промокода в днях (или 0 для бессрочного):"
+        )
+        await state.set_state(AdminStates.setting_promocode_expiry)
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число")
+
+
+@admin_required
+@error_handler
+async def process_promocode_expiry(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    try:
+        expiry_days = int(message.text.strip())
+        
+        if expiry_days < 0 or expiry_days > 3650:
+            await message.answer("❌ Срок действия должен быть от 0 до 3650 дней")
+            return
+        
+        data = await state.get_data()
+        code = data.get('promocode_code')
+        promo_type = data.get('promocode_type')
+        value = data.get('promocode_value', 0)
+        max_uses = data.get('promocode_max_uses', 1)
+        
+        valid_until = None
+        if expiry_days > 0:
+            valid_until = datetime.utcnow() + timedelta(days=expiry_days)
+        
+        type_map = {
+            "balance": PromoCodeType.BALANCE,
+            "days": PromoCodeType.SUBSCRIPTION_DAYS,
+            "trial": PromoCodeType.TRIAL_SUBSCRIPTION
+        }
+        
+        promocode = await create_promocode(
+            db=db,
+            code=code,
+            type=type_map[promo_type],
+            balance_bonus_kopeks=value * 100 if promo_type == "balance" else 0,
+            subscription_days=value if promo_type in ["days", "trial"] else 0,
+            max_uses=max_uses,
+            valid_until=valid_until,
+            created_by=db_user.id
+        )
+        
+        type_names = {
+            "balance": "Пополнение баланса", 
+            "days": "Дни подписки", 
+            "trial": "Тестовая подписка"
+        }
+        
+        summary_text = f"""
+✅ <b>Промокод создан!</b>
+
+🎫 <b>Код:</b> <code>{promocode.code}</code>
+📝 <b>Тип:</b> {type_names.get(promo_type)}
+"""
+        
+        if promo_type == "balance":
+            summary_text += f"💰 <b>Сумма:</b> {settings.format_price(promocode.balance_bonus_kopeks)}\n"
+        elif promo_type in ["days", "trial"]:
+            summary_text += f"📅 <b>Дней:</b> {promocode.subscription_days}\n"
+        
+        summary_text += f"📊 <b>Использований:</b> {promocode.max_uses}\n"
+        
+        if promocode.valid_until:
+            summary_text += f"⏰ <b>Действует до:</b> {format_datetime(promocode.valid_until)}\n"
+        
+        await message.answer(
+            summary_text,
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🎫 К промокодам", callback_data="admin_promocodes")]
+            ])
+        )
+        
+        await state.clear()
+        logger.info(f"Создан промокод {code} администратором {db_user.telegram_id}")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число дней")
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(show_promocodes_menu, F.data == "admin_promocodes")
+    dp.callback_query.register(show_promocodes_list, F.data == "admin_promo_list")
+    dp.callback_query.register(start_promocode_creation, F.data == "admin_promo_create")
+    dp.callback_query.register(select_promocode_type, F.data.startswith("promo_type_"))
+    
+    dp.callback_query.register(show_promocode_management, F.data.startswith("promo_manage_"))
+    dp.callback_query.register(toggle_promocode_status, F.data.startswith("promo_toggle_"))
+    dp.callback_query.register(confirm_delete_promocode, F.data.startswith("promo_delete_"))
+    dp.callback_query.register(delete_promocode_confirmed, F.data.startswith("promo_delete_confirm_"))
+    dp.callback_query.register(show_promocode_stats, F.data.startswith("promo_stats_"))
+    
+    dp.message.register(process_promocode_code, AdminStates.creating_promocode)
+    dp.message.register(process_promocode_value, AdminStates.setting_promocode_value)
+    dp.message.register(process_promocode_uses, AdminStates.setting_promocode_uses)
+    dp.message.register(process_promocode_expiry, AdminStates.setting_promocode_expiry)

app/handlers/admin/referrals.py

@@ -0,0 +1,72 @@
+import logging
+from aiogram import Dispatcher, types, F
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.localization.texts import get_texts
+from app.database.crud.referral import get_referral_statistics, get_user_referral_stats
+from app.database.crud.user import get_user_by_id
+from app.utils.decorators import admin_required, error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_referral_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    stats = await get_referral_statistics(db)
+    
+    avg_per_referrer = 0
+    if stats['active_referrers'] > 0:
+        avg_per_referrer = stats['total_paid_kopeks'] / stats['active_referrers']
+    
+    text = f"""
+🤝 <b>Реферальная статистика</b>
+
+<b>Общие показатели:</b>
+- Пользователей с рефералами: {stats['users_with_referrals']}
+- Активных рефереров: {stats['active_referrers']}
+- Выплачено всего: {settings.format_price(stats['total_paid_kopeks'])}
+
+<b>За период:</b>
+- Сегодня: {settings.format_price(stats['today_earnings_kopeks'])}
+- За неделю: {settings.format_price(stats['week_earnings_kopeks'])}
+- За месяц: {settings.format_price(stats['month_earnings_kopeks'])}
+
+<b>Средние показатели:</b>
+- На одного реферера: {settings.format_price(int(avg_per_referrer))}
+
+<b>Топ-5 рефереров:</b>
+"""
+    
+    for i, referrer in enumerate(stats['top_referrers'][:5], 1):
+        text += f"{i}. ID {referrer['user_id']}: {settings.format_price(referrer['total_earned_kopeks'])} ({referrer['referrals_count']} реф.)\n"
+    
+    if not stats['top_referrers']:
+        text += "Нет данных\n"
+    
+    text += f"""
+
+<b>Настройки:</b>
+- Бонус за регистрацию: {settings.format_price(settings.REFERRAL_REGISTRATION_REWARD)}
+- Бонус новому пользователю: {settings.format_price(settings.REFERRED_USER_REWARD)}
+- Комиссия: {settings.REFERRAL_COMMISSION_PERCENT}%
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_referrals")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")]
+        ])
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(show_referral_statistics, F.data == "admin_referrals")

app/handlers/admin/rules.py

@@ -0,0 +1,168 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.states import AdminStates
+from app.database.models import User
+from app.localization.texts import get_texts
+from app.utils.decorators import admin_required, error_handler
+from app.database.crud.rules import get_current_rules_content, create_or_update_rules
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_rules_management(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    text = """
+📋 <b>Управление правилами сервиса</b>
+
+Текущие правила показываются пользователям при регистрации и в главном меню.
+
+Выберите действие:
+"""
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="📝 Редактировать правила", callback_data="admin_edit_rules")],
+        [types.InlineKeyboardButton(text="👀 Просмотр правил", callback_data="admin_view_rules")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def view_current_rules(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    current_rules = await get_current_rules_content(db, db_user.language)
+    
+    await callback.message.edit_text(
+        f"📋 <b>Текущие правила сервиса</b>\n\n{current_rules}",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="✏️ Редактировать", callback_data="admin_edit_rules")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_rules")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_edit_rules(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    current_rules = await get_current_rules_content(db, db_user.language)
+    
+    await callback.message.edit_text(
+        "✏️ <b>Редактирование правил</b>\n\n"
+        f"<b>Текущие правила:</b>\n{current_rules[:500]}{'...' if len(current_rules) > 500 else ''}\n\n"
+        "Отправьте новый текст правил сервиса.\n\n"
+        "<i>Поддерживается HTML разметка</i>",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_rules")]
+        ])
+    )
+    
+    await state.set_state(AdminStates.editing_rules_page)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_rules_edit(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    new_rules = message.text
+    
+    if len(new_rules) > 4000:
+        await message.answer("❌ Текст правил слишком длинный (максимум 4000 символов)")
+        return
+    
+    await message.answer(
+        f"📋 <b>Предварительный просмотр новых правил:</b>\n\n{new_rules}\n\n"
+        f"⚠️ <b>Внимание!</b> Новые правила будут показываться всем пользователям.\n\n"
+        f"Сохранить изменения?",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [
+                types.InlineKeyboardButton(text="✅ Сохранить", callback_data="admin_save_rules"),
+                types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_rules")
+            ]
+        ])
+    )
+    
+    await state.update_data(new_rules=new_rules)
+
+
+@admin_required
+@error_handler
+async def save_rules(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    new_rules = data.get('new_rules')
+    
+    if not new_rules:
+        await callback.answer("❌ Ошибка: текст правил не найден", show_alert=True)
+        return
+    
+    try:
+        await create_or_update_rules(
+            db=db,
+            content=new_rules,
+            language=db_user.language
+        )
+        
+        from app.localization.texts import clear_rules_cache
+        clear_rules_cache()
+        
+        from app.localization.texts import refresh_rules_cache
+        await refresh_rules_cache(db_user.language)
+        
+        await callback.message.edit_text(
+            "✅ <b>Правила сервиса обновлены!</b>\n\n"
+            "Новые правила сохранены в базе данных и будут показываться пользователям.\n\n"
+            "Кеш правил очищен и обновлен.",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📋 К правилам", callback_data="admin_rules")]
+            ])
+        )
+        
+        await state.clear()
+        logger.info(f"Правила сервиса обновлены администратором {db_user.telegram_id}")
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"Ошибка сохранения правил: {e}")
+        await callback.answer("❌ Ошибка сохранения правил", show_alert=True)
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(show_rules_management, F.data == "admin_rules")
+    dp.callback_query.register(view_current_rules, F.data == "admin_view_rules")
+    dp.callback_query.register(start_edit_rules, F.data == "admin_edit_rules")
+    dp.callback_query.register(save_rules, F.data == "admin_save_rules")
+    
+    dp.message.register(process_rules_edit, AdminStates.editing_rules_page)

app/handlers/admin/servers.py

@@ -0,0 +1,962 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.states import AdminStates
+from app.database.models import User
+from app.database.crud.server_squad import (
+    get_all_server_squads, get_server_squad_by_id, update_server_squad,
+    delete_server_squad, sync_with_remnawave, get_server_statistics,
+    create_server_squad, get_available_server_squads
+)
+from app.services.remnawave_service import RemnaWaveService
+from app.utils.decorators import admin_required, error_handler
+from app.utils.cache import cache
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_servers_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    stats = await get_server_statistics(db)
+    
+    text = f"""
+🌐 <b>Управление серверами</b>
+
+📊 <b>Статистика:</b>
+• Всего серверов: {stats['total_servers']}
+• Доступные: {stats['available_servers']}
+• Недоступные: {stats['unavailable_servers']}
+• С подключениями: {stats['servers_with_connections']}
+
+💰 <b>Выручка от серверов:</b>
+• Общая: {stats['total_revenue_rubles']:.2f} ₽
+
+Выберите действие:
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="📋 Список серверов", callback_data="admin_servers_list"),
+            types.InlineKeyboardButton(text="🔄 Синхронизация", callback_data="admin_servers_sync")
+        ],
+        [
+            types.InlineKeyboardButton(text="📊 Синхронизировать счетчики", callback_data="admin_servers_sync_counts"),
+            types.InlineKeyboardButton(text="📈 Подробная статистика", callback_data="admin_servers_stats")
+        ],
+        [
+            types.InlineKeyboardButton(text="➕ Добавить сервер", callback_data="admin_servers_add")
+        ],
+        [
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_servers_list(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    page: int = 1
+):
+    
+    servers, total_count = await get_all_server_squads(db, page=page, limit=10)
+    total_pages = (total_count + 9) // 10
+    
+    if not servers:
+        text = "🌐 <b>Список серверов</b>\n\n❌ Серверы не найдены."
+    else:
+        text = f"🌐 <b>Список серверов</b>\n\n"
+        text += f"📊 Всего: {total_count} | Страница: {page}/{total_pages}\n\n"
+        
+        for i, server in enumerate(servers, 1 + (page - 1) * 10):
+            status_emoji = "✅" if server.is_available else "❌"
+            price_text = f"{server.price_rubles:.2f} ₽" if server.price_kopeks > 0 else "Бесплатно"
+            
+            text += f"{i}. {status_emoji} {server.display_name}\n"
+            text += f"   💰 Цена: {price_text}"
+            
+            if server.max_users:
+                text += f" | 👥 {server.current_users}/{server.max_users}"
+            
+            text += f"\n   UUID: <code>{server.squad_uuid}</code>\n\n"
+    
+    keyboard = []
+    
+    for i, server in enumerate(servers):
+        row_num = i // 2 
+        if len(keyboard) <= row_num:
+            keyboard.append([])
+        
+        status_emoji = "✅" if server.is_available else "❌"
+        keyboard[row_num].append(
+            types.InlineKeyboardButton(
+                text=f"{status_emoji} {server.display_name[:15]}...",
+                callback_data=f"admin_server_edit_{server.id}"
+            )
+        )
+    
+    if total_pages > 1:
+        nav_row = []
+        if page > 1:
+            nav_row.append(types.InlineKeyboardButton(
+                text="⬅️", callback_data=f"admin_servers_list_page_{page-1}"
+            ))
+        
+        nav_row.append(types.InlineKeyboardButton(
+            text=f"{page}/{total_pages}", callback_data="current_page"
+        ))
+        
+        if page < total_pages:
+            nav_row.append(types.InlineKeyboardButton(
+                text="➡️", callback_data=f"admin_servers_list_page_{page+1}"
+            ))
+        
+        keyboard.append(nav_row)
+    
+    keyboard.extend([
+        [
+            types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_servers_list"),
+            types.InlineKeyboardButton(text="➕ Добавить", callback_data="admin_servers_add")
+        ],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def sync_servers_with_remnawave(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    await callback.message.edit_text(
+        "🔄 Синхронизация с RemnaWave...\n\nПодождите, это может занять время.",
+        reply_markup=None
+    )
+    
+    try:
+        remnawave_service = RemnaWaveService()
+        squads = await remnawave_service.get_all_squads()
+        
+        if not squads:
+            await callback.message.edit_text(
+                "❌ Не удалось получить данные о сквадах из RemnaWave.\n\nПроверьте настройки API.",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
+                ])
+            )
+            return
+        
+        created, updated, disabled = await sync_with_remnawave(db, squads)
+        
+        await cache.delete("available_countries")
+        
+        text = f"""
+✅ <b>Синхронизация завершена</b>
+
+📊 <b>Результаты:</b>
+• Создано новых серверов: {created}
+• Обновлено существующих: {updated}
+• Отключено неактивных: {disabled}
+• Всего обработано: {len(squads)}
+
+ℹ️ Новые серверы созданы как недоступные.
+Настройте их в списке серверов.
+"""
+        
+        keyboard = [
+            [
+                types.InlineKeyboardButton(text="📋 Список серверов", callback_data="admin_servers_list"),
+                types.InlineKeyboardButton(text="🔄 Повторить", callback_data="admin_servers_sync")
+            ],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
+        ]
+        
+        await callback.message.edit_text(
+            text,
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        )
+        
+    except Exception as e:
+        logger.error(f"Ошибка синхронизации серверов: {e}")
+        await callback.message.edit_text(
+            f"❌ Ошибка синхронизации: {str(e)}",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_server_edit_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    status_emoji = "✅ Доступен" if server.is_available else "❌ Недоступен"
+    price_text = f"{server.price_rubles:.2f} ₽" if server.price_kopeks > 0 else "Бесплатно"
+    
+    text = f"""
+🌐 <b>Редактирование сервера</b>
+
+<b>Информация:</b>
+• ID: {server.id}
+• UUID: <code>{server.squad_uuid}</code>
+• Название: {server.display_name}
+• Оригинальное: {server.original_name or 'Не указано'}
+• Статус: {status_emoji}
+
+<b>Настройки:</b>
+• Цена: {price_text}
+• Код страны: {server.country_code or 'Не указан'}
+• Лимит пользователей: {server.max_users or 'Без лимита'}
+• Текущих пользователей: {server.current_users}
+
+<b>Описание:</b>
+{server.description or 'Не указано'}
+
+Выберите что изменить:
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="✏️ Название", callback_data=f"admin_server_edit_name_{server.id}"),
+            types.InlineKeyboardButton(text="💰 Цена", callback_data=f"admin_server_edit_price_{server.id}")
+        ],
+        [
+            types.InlineKeyboardButton(text="🌍 Страна", callback_data=f"admin_server_edit_country_{server.id}"),
+            types.InlineKeyboardButton(text="👥 Лимит", callback_data=f"admin_server_edit_limit_{server.id}")
+        ],
+        [
+            types.InlineKeyboardButton(text="📝 Описание", callback_data=f"admin_server_edit_desc_{server.id}")
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="❌ Отключить" if server.is_available else "✅ Включить",
+                callback_data=f"admin_server_toggle_{server.id}"
+            )
+        ],
+        [
+            types.InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_server_delete_{server.id}"),
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers_list")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def toggle_server_availability(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    new_status = not server.is_available
+    await update_server_squad(db, server_id, is_available=new_status)
+    
+    await cache.delete("available_countries")
+    
+    status_text = "включен" if new_status else "отключен"
+    await callback.answer(f"✅ Сервер {status_text}!")
+    
+    server = await get_server_squad_by_id(db, server_id)
+    
+    status_emoji = "✅ Доступен" if server.is_available else "❌ Недоступен"
+    price_text = f"{server.price_rubles:.2f} ₽" if server.price_kopeks > 0 else "Бесплатно"
+    
+    text = f"""
+🌐 <b>Редактирование сервера</b>
+
+<b>Информация:</b>
+• ID: {server.id}
+• UUID: <code>{server.squad_uuid}</code>
+• Название: {server.display_name}
+• Оригинальное: {server.original_name or 'Не указано'}
+• Статус: {status_emoji}
+
+<b>Настройки:</b>
+• Цена: {price_text}
+• Код страны: {server.country_code or 'Не указан'}
+• Лимит пользователей: {server.max_users or 'Без лимита'}
+• Текущих пользователей: {server.current_users}
+
+<b>Описание:</b>
+{server.description or 'Не указано'}
+
+Выберите что изменить:
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="✏️ Название", callback_data=f"admin_server_edit_name_{server.id}"),
+            types.InlineKeyboardButton(text="💰 Цена", callback_data=f"admin_server_edit_price_{server.id}")
+        ],
+        [
+            types.InlineKeyboardButton(text="🌍 Страна", callback_data=f"admin_server_edit_country_{server.id}"),
+            types.InlineKeyboardButton(text="👥 Лимит", callback_data=f"admin_server_edit_limit_{server.id}")
+        ],
+        [
+            types.InlineKeyboardButton(text="📝 Описание", callback_data=f"admin_server_edit_desc_{server.id}")
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="❌ Отключить" if server.is_available else "✅ Включить",
+                callback_data=f"admin_server_toggle_{server.id}"
+            )
+        ],
+        [
+            types.InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_server_delete_{server.id}"),
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers_list")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
+    )
+
+
+@admin_required
+@error_handler
+async def start_server_edit_price(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    await state.set_data({'server_id': server_id})
+    await state.set_state(AdminStates.editing_server_price)
+    
+    current_price = f"{server.price_rubles:.2f} ₽" if server.price_kopeks > 0 else "Бесплатно"
+    
+    await callback.message.edit_text(
+        f"💰 <b>Редактирование цены</b>\n\n"
+        f"Текущая цена: <b>{current_price}</b>\n\n"
+        f"Отправьте новую цену в рублях (например: 15.50) или 0 для бесплатного доступа:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_server_edit_{server_id}")]
+        ]),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_server_price_edit(
+    message: types.Message,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    data = await state.get_data()
+    server_id = data.get('server_id')
+    
+    try:
+        price_rubles = float(message.text.replace(',', '.'))
+        
+        if price_rubles < 0:
+            await message.answer("❌ Цена не может быть отрицательной")
+            return
+        
+        if price_rubles > 10000:
+            await message.answer("❌ Слишком высокая цена (максимум 10,000 ₽)")
+            return
+        
+        price_kopeks = int(price_rubles * 100)
+        
+        server = await update_server_squad(db, server_id, price_kopeks=price_kopeks)
+        
+        if server:
+            await state.clear()
+            
+            await cache.delete("available_countries")
+            
+            price_text = f"{price_rubles:.2f} ₽" if price_kopeks > 0 else "Бесплатно"
+            await message.answer(
+                f"✅ Цена сервера изменена на: <b>{price_text}</b>",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🔙 К серверу", callback_data=f"admin_server_edit_{server_id}")]
+                ]),
+                parse_mode="HTML"
+            )
+        else:
+            await message.answer("❌ Ошибка при обновлении сервера")
+    
+    except ValueError:
+        await message.answer("❌ Неверный формат цены. Используйте числа (например: 15.50)")
+
+
+@admin_required
+@error_handler
+async def start_server_edit_name(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    await state.set_data({'server_id': server_id})
+    await state.set_state(AdminStates.editing_server_name)
+    
+    await callback.message.edit_text(
+        f"✏️ <b>Редактирование названия</b>\n\n"
+        f"Текущее название: <b>{server.display_name}</b>\n\n"
+        f"Отправьте новое название для сервера:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_server_edit_{server_id}")]
+        ]),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_server_name_edit(
+    message: types.Message,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    data = await state.get_data()
+    server_id = data.get('server_id')
+    
+    new_name = message.text.strip()
+    
+    if len(new_name) > 255:
+        await message.answer("❌ Название слишком длинное (максимум 255 символов)")
+        return
+    
+    if len(new_name) < 3:
+        await message.answer("❌ Название слишком короткое (минимум 3 символа)")
+        return
+    
+    server = await update_server_squad(db, server_id, display_name=new_name)
+    
+    if server:
+        await state.clear()
+        
+        await cache.delete("available_countries")
+        
+        await message.answer(
+            f"✅ Название сервера изменено на: <b>{new_name}</b>",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🔙 К серверу", callback_data=f"admin_server_edit_{server_id}")]
+            ]),
+            parse_mode="HTML"
+        )
+    else:
+        await message.answer("❌ Ошибка при обновлении сервера")
+
+
+@admin_required
+@error_handler
+async def delete_server_confirm(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    text = f"""
+🗑️ <b>Удаление сервера</b>
+
+Вы действительно хотите удалить сервер:
+<b>{server.display_name}</b>
+
+⚠️ <b>Внимание!</b>
+Сервер можно удалить только если к нему нет активных подключений.
+
+Это действие нельзя отменить!
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="🗑️ Да, удалить", callback_data=f"admin_server_delete_confirm_{server_id}"),
+            types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_server_edit_{server_id}")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def delete_server_execute(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    success = await delete_server_squad(db, server_id)
+    
+    if success:
+        await cache.delete("available_countries")
+        
+        await callback.message.edit_text(
+            f"✅ Сервер <b>{server.display_name}</b> успешно удален!",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📋 К списку серверов", callback_data="admin_servers_list")]
+            ]),
+            parse_mode="HTML"
+        )
+    else:
+        await callback.message.edit_text(
+            f"❌ Не удалось удалить сервер <b>{server.display_name}</b>\n\n"
+            f"Возможно, к нему есть активные подключения.",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🔙 К серверу", callback_data=f"admin_server_edit_{server_id}")]
+            ]),
+            parse_mode="HTML"
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_server_detailed_stats(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    stats = await get_server_statistics(db)
+    available_servers = await get_available_server_squads(db)
+    
+    text = f"""
+📊 <b>Подробная статистика серверов</b>
+
+<b>🌐 Общая информация:</b>
+• Всего серверов: {stats['total_servers']}
+• Доступные: {stats['available_servers']}
+• Недоступные: {stats['unavailable_servers']}
+• С активными подключениями: {stats['servers_with_connections']}
+
+<b>💰 Финансовая статистика:</b>
+• Общая выручка: {stats['total_revenue_rubles']:.2f} ₽
+• Средняя цена за сервер: {(stats['total_revenue_rubles'] / max(stats['servers_with_connections'], 1)):.2f} ₽
+
+<b>🔥 Топ серверов по цене:</b>
+"""
+    
+    sorted_servers = sorted(available_servers, key=lambda x: x.price_kopeks, reverse=True)
+    
+    for i, server in enumerate(sorted_servers[:5], 1):
+        price_text = f"{server.price_rubles:.2f} ₽" if server.price_kopeks > 0 else "Бесплатно"
+        text += f"{i}. {server.display_name} - {price_text}\n"
+    
+    if not sorted_servers:
+        text += "Нет доступных серверов\n"
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_servers_stats"),
+            types.InlineKeyboardButton(text="📋 Список", callback_data="admin_servers_list")
+        ],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_server_edit_country(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    await state.set_data({'server_id': server_id})
+    await state.set_state(AdminStates.editing_server_country)
+    
+    current_country = server.country_code or "Не указан"
+    
+    await callback.message.edit_text(
+        f"🌍 <b>Редактирование кода страны</b>\n\n"
+        f"Текущий код страны: <b>{current_country}</b>\n\n"
+        f"Отправьте новый код страны (например: RU, US, DE) или '-' для удаления:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_server_edit_{server_id}")]
+        ]),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_server_country_edit(
+    message: types.Message,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    data = await state.get_data()
+    server_id = data.get('server_id')
+    
+    new_country = message.text.strip().upper()
+    
+    if new_country == "-":
+        new_country = None
+    elif len(new_country) > 5:
+        await message.answer("❌ Код страны слишком длинный (максимум 5 символов)")
+        return
+    
+    server = await update_server_squad(db, server_id, country_code=new_country)
+    
+    if server:
+        await state.clear()
+        
+        await cache.delete("available_countries")
+        
+        country_text = new_country or "Удален"
+        await message.answer(
+            f"✅ Код страны изменен на: <b>{country_text}</b>",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🔙 К серверу", callback_data=f"admin_server_edit_{server_id}")]
+            ]),
+            parse_mode="HTML"
+        )
+    else:
+        await message.answer("❌ Ошибка при обновлении сервера")
+
+
+@admin_required
+@error_handler
+async def start_server_edit_limit(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    await state.set_data({'server_id': server_id})
+    await state.set_state(AdminStates.editing_server_limit)
+    
+    current_limit = server.max_users or "Без лимита"
+    
+    await callback.message.edit_text(
+        f"👥 <b>Редактирование лимита пользователей</b>\n\n"
+        f"Текущий лимит: <b>{current_limit}</b>\n\n"
+        f"Отправьте новый лимит пользователей (число) или 0 для безлимитного доступа:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_server_edit_{server_id}")]
+        ]),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_server_limit_edit(
+    message: types.Message,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    data = await state.get_data()
+    server_id = data.get('server_id')
+    
+    try:
+        limit = int(message.text.strip())
+        
+        if limit < 0:
+            await message.answer("❌ Лимит не может быть отрицательным")
+            return
+        
+        if limit > 10000:
+            await message.answer("❌ Слишком большой лимит (максимум 10,000)")
+            return
+        
+        max_users = limit if limit > 0 else None
+        
+        server = await update_server_squad(db, server_id, max_users=max_users)
+        
+        if server:
+            await state.clear()
+            
+            limit_text = f"{limit} пользователей" if limit > 0 else "Без лимита"
+            await message.answer(
+                f"✅ Лимит пользователей изменен на: <b>{limit_text}</b>",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="🔙 К серверу", callback_data=f"admin_server_edit_{server_id}")]
+                ]),
+                parse_mode="HTML"
+            )
+        else:
+            await message.answer("❌ Ошибка при обновлении сервера")
+    
+    except ValueError:
+        await message.answer("❌ Неверный формат числа. Введите целое число.")
+
+
+@admin_required
+@error_handler
+async def start_server_edit_description(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    server_id = int(callback.data.split('_')[-1])
+    server = await get_server_squad_by_id(db, server_id)
+    
+    if not server:
+        await callback.answer("❌ Сервер не найден!", show_alert=True)
+        return
+    
+    await state.set_data({'server_id': server_id})
+    await state.set_state(AdminStates.editing_server_description)
+    
+    current_desc = server.description or "Не указано"
+    
+    await callback.message.edit_text(
+        f"📝 <b>Редактирование описания</b>\n\n"
+        f"Текущее описание:\n<i>{current_desc}</i>\n\n"
+        f"Отправьте новое описание сервера или '-' для удаления:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_server_edit_{server_id}")]
+        ]),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_server_description_edit(
+    message: types.Message,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    data = await state.get_data()
+    server_id = data.get('server_id')
+    
+    new_description = message.text.strip()
+    
+    if new_description == "-":
+        new_description = None
+    elif len(new_description) > 1000:
+        await message.answer("❌ Описание слишком длинное (максимум 1000 символов)")
+        return
+    
+    server = await update_server_squad(db, server_id, description=new_description)
+    
+    if server:
+        await state.clear()
+        
+        desc_text = new_description or "Удалено"
+        await message.answer(
+            f"✅ Описание сервера изменено:\n\n<i>{desc_text}</i>",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="🔙 К серверу", callback_data=f"admin_server_edit_{server_id}")]
+            ]),
+            parse_mode="HTML"
+        )
+    else:
+        await message.answer("❌ Ошибка при обновлении сервера")
+
+@admin_required
+@error_handler
+async def sync_server_user_counts_handler(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    await callback.message.edit_text(
+        "🔄 Синхронизация счетчиков пользователей...",
+        reply_markup=None
+    )
+    
+    try:
+        from app.database.crud.server_squad import sync_server_user_counts
+        
+        updated_count = await sync_server_user_counts(db)
+        
+        text = f"""
+✅ <b>Синхронизация завершена</b>
+
+📊 <b>Результат:</b>
+• Обновлено серверов: {updated_count}
+
+Счетчики пользователей синхронизированы с реальными данными.
+"""
+        
+        keyboard = [
+            [
+                types.InlineKeyboardButton(text="📋 Список серверов", callback_data="admin_servers_list"),
+                types.InlineKeyboardButton(text="🔄 Повторить", callback_data="admin_servers_sync_counts")
+            ],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
+        ]
+        
+        await callback.message.edit_text(
+            text,
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        )
+        
+    except Exception as e:
+        logger.error(f"Ошибка синхронизации счетчиков: {e}")
+        await callback.message.edit_text(
+            f"❌ Ошибка синхронизации: {str(e)}",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler  
+async def handle_servers_pagination(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    page = int(callback.data.split('_')[-1])
+    await show_servers_list(callback, db_user, db, page)
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(show_servers_menu, F.data == "admin_servers")
+    dp.callback_query.register(show_servers_list, F.data == "admin_servers_list")
+    dp.callback_query.register(sync_servers_with_remnawave, F.data == "admin_servers_sync")
+    dp.callback_query.register(sync_server_user_counts_handler, F.data == "admin_servers_sync_counts")
+    dp.callback_query.register(show_server_detailed_stats, F.data == "admin_servers_stats")
+    
+    dp.callback_query.register(show_server_edit_menu, F.data.startswith("admin_server_edit_") & ~F.data.contains("name") & ~F.data.contains("price") & ~F.data.contains("country") & ~F.data.contains("limit") & ~F.data.contains("desc"))
+    dp.callback_query.register(toggle_server_availability, F.data.startswith("admin_server_toggle_"))
+    
+    dp.callback_query.register(start_server_edit_name, F.data.startswith("admin_server_edit_name_"))
+    dp.callback_query.register(start_server_edit_price, F.data.startswith("admin_server_edit_price_"))
+    dp.callback_query.register(start_server_edit_country, F.data.startswith("admin_server_edit_country_"))      
+    dp.callback_query.register(start_server_edit_limit, F.data.startswith("admin_server_edit_limit_"))         
+    dp.callback_query.register(start_server_edit_description, F.data.startswith("admin_server_edit_desc_"))     
+    
+    dp.message.register(process_server_name_edit, AdminStates.editing_server_name)
+    dp.message.register(process_server_price_edit, AdminStates.editing_server_price)
+    dp.message.register(process_server_country_edit, AdminStates.editing_server_country)            
+    dp.message.register(process_server_limit_edit, AdminStates.editing_server_limit)                
+    dp.message.register(process_server_description_edit, AdminStates.editing_server_description)    
+    
+    dp.callback_query.register(delete_server_confirm, F.data.startswith("admin_server_delete_") & ~F.data.contains("confirm"))
+    dp.callback_query.register(delete_server_execute, F.data.startswith("admin_server_delete_confirm_"))
+    
+    dp.callback_query.register(handle_servers_pagination, F.data.startswith("admin_servers_list_page_"))

app/handlers/admin/statistics.py

@@ -0,0 +1,350 @@
+import logging
+from datetime import datetime, timedelta
+from aiogram import Dispatcher, types, F
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.admin import get_admin_statistics_keyboard, get_period_selection_keyboard
+from app.localization.texts import get_texts
+from app.services.user_service import UserService
+from app.database.crud.subscription import get_subscriptions_statistics
+from app.database.crud.transaction import get_transactions_statistics, get_revenue_by_period
+from app.database.crud.referral import get_referral_statistics
+from app.utils.decorators import admin_required, error_handler
+from app.utils.formatters import format_datetime, format_percentage
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_statistics_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    text = """
+📊 <b>Статистика системы</b>
+
+Выберите раздел для просмотра статистики:
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_admin_statistics_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_users_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_service = UserService()
+    stats = await user_service.get_user_statistics(db)
+    
+    total_users = stats['total_users']
+    active_rate = format_percentage(stats['active_users'] / total_users * 100 if total_users > 0 else 0)
+    
+    text = f"""
+👥 <b>Статистика пользователей</b>
+
+<b>Общие показатели:</b>
+- Всего зарегистрировано: {stats['total_users']}
+- Активных: {stats['active_users']} ({active_rate})
+- Заблокированных: {stats['blocked_users']}
+
+<b>Новые регистрации:</b>
+- Сегодня: {stats['new_today']}
+- За неделю: {stats['new_week']}
+- За месяц: {stats['new_month']}
+
+<b>Активность:</b>
+- Коэффициент активности: {active_rate}
+- Рост за месяц: +{stats['new_month']} ({format_percentage(stats['new_month'] / total_users * 100 if total_users > 0 else 0)})
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_users")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_subscriptions_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    stats = await get_subscriptions_statistics(db)
+    
+    total_subs = stats['total_subscriptions']
+    conversion_rate = format_percentage(stats['paid_subscriptions'] / total_subs * 100 if total_subs > 0 else 0)
+    
+    text = f"""
+📱 <b>Статистика подписок</b>
+
+<b>Общие показатели:</b>
+- Всего подписок: {stats['total_subscriptions']}
+- Активных: {stats['active_subscriptions']}
+- Платных: {stats['paid_subscriptions']}
+- Триальных: {stats['trial_subscriptions']}
+
+<b>Конверсия:</b>
+- Из триала в платную: {conversion_rate}
+- Активных платных: {stats['paid_subscriptions']}
+
+<b>Продажи:</b>
+- Сегодня: {stats['purchased_today']}
+- За неделю: {stats['purchased_week']}
+- За месяц: {stats['purchased_month']}
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_subs")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_revenue_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    now = datetime.utcnow()
+    month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+    
+    month_stats = await get_transactions_statistics(db, month_start, now)
+    all_time_stats = await get_transactions_statistics(db)
+    
+    text = f"""
+💰 <b>Статистика доходов</b>
+
+<b>За текущий месяц:</b>
+- Доходы: {settings.format_price(month_stats['totals']['income_kopeks'])}
+- Расходы: {settings.format_price(month_stats['totals']['expenses_kopeks'])}
+- Прибыль: {settings.format_price(month_stats['totals']['profit_kopeks'])}
+- От подписок: {settings.format_price(month_stats['totals']['subscription_income_kopeks'])}
+
+<b>Сегодня:</b>
+- Транзакций: {month_stats['today']['transactions_count']}
+- Доходы: {settings.format_price(month_stats['today']['income_kopeks'])}
+
+<b>За все время:</b>
+- Общий доход: {settings.format_price(all_time_stats['totals']['income_kopeks'])}
+- Общая прибыль: {settings.format_price(all_time_stats['totals']['profit_kopeks'])}
+
+<b>Способы оплаты:</b>
+"""
+    
+    for method, data in month_stats['by_payment_method'].items():
+        if method and data['count'] > 0:
+            text += f"• {method}: {data['count']} ({settings.format_price(data['amount'])})\n"
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="📈 Период", callback_data="admin_revenue_period")],
+            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_revenue")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_referral_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    stats = await get_referral_statistics(db)
+    
+    avg_per_referrer = 0
+    if stats['active_referrers'] > 0:
+        avg_per_referrer = stats['total_paid_kopeks'] / stats['active_referrers']
+    
+    text = f"""
+🤝 <b>Реферальная статистика</b>
+
+<b>Общие показатели:</b>
+- Пользователей с рефералами: {stats['users_with_referrals']}
+- Активных рефереров: {stats['active_referrers']}
+- Выплачено всего: {settings.format_price(stats['total_paid_kopeks'])}
+
+<b>За период:</b>
+- Сегодня: {settings.format_price(stats['today_earnings_kopeks'])}
+- За неделю: {settings.format_price(stats['week_earnings_kopeks'])}
+- За месяц: {settings.format_price(stats['month_earnings_kopeks'])}
+
+<b>Средние показатели:</b>
+- На одного реферера: {settings.format_price(int(avg_per_referrer))}
+
+<b>Топ рефереры:</b>
+"""
+    
+    if stats['top_referrers']:
+        for i, referrer in enumerate(stats['top_referrers'][:5], 1):
+            name = referrer['display_name']
+            earned = settings.format_price(referrer['total_earned_kopeks'])
+            count = referrer['referrals_count']
+            text += f"{i}. {name}: {earned} ({count} реф.)\n"
+    else:
+        text += "Пока нет активных рефереров"
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_referrals")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_summary_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_service = UserService()
+    user_stats = await user_service.get_user_statistics(db)
+    sub_stats = await get_subscriptions_statistics(db)
+    
+    now = datetime.utcnow()
+    month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+    revenue_stats = await get_transactions_statistics(db, month_start, now)
+    
+    conversion_rate = 0
+    if user_stats['total_users'] > 0:
+        conversion_rate = sub_stats['paid_subscriptions'] / user_stats['total_users'] * 100
+    
+    arpu = 0
+    if user_stats['active_users'] > 0:
+        arpu = revenue_stats['totals']['income_kopeks'] / user_stats['active_users']
+    
+    text = f"""
+📊 <b>Общая сводка системы</b>
+
+<b>Пользователи:</b>
+- Всего: {user_stats['total_users']}
+- Активных: {user_stats['active_users']}
+- Новых за месяц: {user_stats['new_month']}
+
+<b>Подписки:</b>
+- Активных: {sub_stats['active_subscriptions']}
+- Платных: {sub_stats['paid_subscriptions']}
+- Конверсия: {format_percentage(conversion_rate)}
+
+<b>Финансы (месяц):</b>
+- Доходы: {settings.format_price(revenue_stats['totals']['income_kopeks'])}
+- ARPU: {settings.format_price(int(arpu))}
+- Транзакций: {sum(data['count'] for data in revenue_stats['by_type'].values())}
+
+<b>Рост:</b>
+- Пользователи: +{user_stats['new_month']} за месяц
+- Продажи: +{sub_stats['purchased_month']} за месяц
+
+<b>Обновлено:</b> {format_datetime(datetime.utcnow())}
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_stats_summary")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_revenue_by_period(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    period = callback.data.split('_')[-1]
+    
+    period_map = {
+        "today": 1,
+        "yesterday": 1,
+        "week": 7,
+        "month": 30,
+        "all": 365
+    }
+    
+    days = period_map.get(period, 30)
+    revenue_data = await get_revenue_by_period(db, days)
+    
+    if period == "yesterday":
+        yesterday = datetime.utcnow().date() - timedelta(days=1)
+        revenue_data = [r for r in revenue_data if r['date'] == yesterday]
+    elif period == "today":
+        today = datetime.utcnow().date()
+        revenue_data = [r for r in revenue_data if r['date'] == today]
+    
+    total_revenue = sum(r['amount_kopeks'] for r in revenue_data)
+    avg_daily = total_revenue / len(revenue_data) if revenue_data else 0
+    
+    text = f"""
+📈 <b>Доходы за период: {period}</b>
+
+<b>Сводка:</b>
+- Общий доход: {settings.format_price(total_revenue)}
+- Дней с данными: {len(revenue_data)}
+- Средний доход в день: {settings.format_price(int(avg_daily))}
+
+<b>По дням:</b>
+"""
+    
+    for revenue in revenue_data[-10:]:
+        text += f"• {revenue['date'].strftime('%d.%m')}: {settings.format_price(revenue['amount_kopeks'])}\n"
+    
+    if len(revenue_data) > 10:
+        text += f"... и еще {len(revenue_data) - 10} дней"
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="📊 Другой период", callback_data="admin_revenue_period")],
+            [types.InlineKeyboardButton(text="⬅️ К доходам", callback_data="admin_stats_revenue")]
+        ])
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(show_statistics_menu, F.data == "admin_statistics")
+    dp.callback_query.register(show_users_statistics, F.data == "admin_stats_users")
+    dp.callback_query.register(show_subscriptions_statistics, F.data == "admin_stats_subs")
+    dp.callback_query.register(show_revenue_statistics, F.data == "admin_stats_revenue")
+    dp.callback_query.register(show_referral_statistics, F.data == "admin_stats_referrals")
+    dp.callback_query.register(show_summary_statistics, F.data == "admin_stats_summary")
+    dp.callback_query.register(show_revenue_by_period, F.data.startswith("period_"))
+    
+    periods = ["today", "yesterday", "week", "month", "all"]
+    for period in periods:
+        dp.callback_query.register(
+            show_revenue_by_period,
+            F.data == f"period_{period}"
+        )

app/handlers/admin/subscriptions.py

@@ -0,0 +1,498 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func
+
+from app.config import settings
+from app.states import AdminStates
+from app.database.models import User
+from app.keyboards.admin import get_admin_subscriptions_keyboard
+from app.localization.texts import get_texts
+from app.database.crud.subscription import (
+    get_expiring_subscriptions, get_subscriptions_statistics, get_expired_subscriptions,
+    get_all_subscriptions
+)
+from app.services.subscription_service import SubscriptionService
+from app.utils.decorators import admin_required, error_handler
+from app.utils.formatters import format_datetime, format_time_ago
+
+
+def get_country_flag(country_name: str) -> str:
+    flags = {
+        'USA': '🇺🇸', 'United States': '🇺🇸', 'US': '🇺🇸',
+        'Germany': '🇩🇪', 'DE': '🇩🇪', 'Deutschland': '🇩🇪',
+        'Netherlands': '🇳🇱', 'NL': '🇳🇱', 'Holland': '🇳🇱',
+        'United Kingdom': '🇬🇧', 'UK': '🇬🇧', 'GB': '🇬🇧',
+        'Japan': '🇯🇵', 'JP': '🇯🇵',
+        'France': '🇫🇷', 'FR': '🇫🇷',
+        'Canada': '🇨🇦', 'CA': '🇨🇦',
+        'Russia': '🇷🇺', 'RU': '🇷🇺',
+        'Singapore': '🇸🇬', 'SG': '🇸🇬',
+    }
+    return flags.get(country_name, '🌍')
+
+
+async def get_users_by_countries(db: AsyncSession) -> dict:
+    try:
+        result = await db.execute(
+            select(User.preferred_location, func.count(User.id))
+            .where(User.preferred_location.isnot(None))
+            .group_by(User.preferred_location)
+        )
+        
+        stats = {}
+        for location, count in result.fetchall():
+            if location:
+                stats[location] = count
+        
+        return stats
+    except Exception as e:
+        logger.error(f"Ошибка получения статистики по странам: {e}")
+        return {}
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_subscriptions_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    stats = await get_subscriptions_statistics(db)
+    
+    text = f"""
+📱 <b>Управление подписками</b>
+
+📊 <b>Статистика:</b>
+- Всего: {stats['total_subscriptions']}
+- Активных: {stats['active_subscriptions']}
+- Платных: {stats['paid_subscriptions']}
+- Триальных: {stats['trial_subscriptions']}
+
+📈 <b>Продажи:</b>
+- Сегодня: {stats['purchased_today']}
+- За неделю: {stats['purchased_week']}
+- За месяц: {stats['purchased_month']}
+
+Выберите действие:
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="📋 Список подписок", callback_data="admin_subs_list"),
+            types.InlineKeyboardButton(text="⏰ Истекающие", callback_data="admin_subs_expiring")
+        ],
+        [
+            types.InlineKeyboardButton(text="📊 Статистика", callback_data="admin_subs_stats"),
+            types.InlineKeyboardButton(text="💰 Настройки цен", callback_data="admin_subs_pricing")
+        ],
+        [
+            types.InlineKeyboardButton(text="🌐 Управление серверами", callback_data="admin_servers"),
+            types.InlineKeyboardButton(text="🌍 География", callback_data="admin_subs_countries")
+        ],
+        [
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_subscriptions_list(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    page: int = 1
+):
+    
+    subscriptions, total_count = await get_all_subscriptions(db, page=page, limit=10)
+    total_pages = (total_count + 9) // 10 
+    
+    if not subscriptions:
+        text = "📱 <b>Список подписок</b>\n\n❌ Подписки не найдены."
+    else:
+        text = f"📱 <b>Список подписок</b>\n\n"
+        text += f"📊 Всего: {total_count} | Страница: {page}/{total_pages}\n\n"
+        
+        for i, sub in enumerate(subscriptions, 1 + (page - 1) * 10):
+            user_info = f"ID{sub.user.telegram_id}" if sub.user else "Неизвестно"
+            sub_type = "🎁" if sub.is_trial else "💎"
+            status = "✅ Активна" if sub.is_active else "❌ Неактивна"
+            
+            text += f"{i}. {sub_type} {user_info}\n"
+            text += f"   {status} | До: {format_datetime(sub.end_date)}\n"
+            if sub.device_limit > 0:
+                text += f"   📱 Устройств: {sub.device_limit}\n"
+            text += "\n"
+    
+    keyboard = []
+    
+    if total_pages > 1:
+        nav_row = []
+        if page > 1:
+            nav_row.append(types.InlineKeyboardButton(
+                text="⬅️", callback_data=f"admin_subs_list_page_{page-1}"
+            ))
+        
+        nav_row.append(types.InlineKeyboardButton(
+            text=f"{page}/{total_pages}", callback_data="current_page"
+        ))
+        
+        if page < total_pages:
+            nav_row.append(types.InlineKeyboardButton(
+                text="➡️", callback_data=f"admin_subs_list_page_{page+1}"
+            ))
+        
+        keyboard.append(nav_row)
+    
+    keyboard.extend([
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_list")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_expiring_subscriptions(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    expiring_3d = await get_expiring_subscriptions(db, 3)
+    expiring_1d = await get_expiring_subscriptions(db, 1)
+    expired = await get_expired_subscriptions(db)
+    
+    text = f"""
+⏰ <b>Истекающие подписки</b>
+
+📊 <b>Статистика:</b>
+- Истекают через 3 дня: {len(expiring_3d)}
+- Истекают завтра: {len(expiring_1d)}
+- Уже истекли: {len(expired)}
+
+<b>Истекают через 3 дня:</b>
+"""
+    
+    for sub in expiring_3d[:5]:
+        user_info = f"ID{sub.user.telegram_id}" if sub.user else "Неизвестно"
+        sub_type = "🎁" if sub.is_trial else "💎"
+        text += f"{sub_type} {user_info} - {format_datetime(sub.end_date)}\n"
+    
+    if len(expiring_3d) > 5:
+        text += f"... и еще {len(expiring_3d) - 5}\n"
+    
+    text += f"\n<b>Истекают завтра:</b>\n"
+    for sub in expiring_1d[:5]:
+        user_info = f"ID{sub.user.telegram_id}" if sub.user else "Неизвестно"
+        sub_type = "🎁" if sub.is_trial else "💎"
+        text += f"{sub_type} {user_info} - {format_datetime(sub.end_date)}\n"
+    
+    if len(expiring_1d) > 5:
+        text += f"... и еще {len(expiring_1d) - 5}\n"
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="📨 Отправить напоминания", callback_data="admin_send_expiry_reminders")],
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_expiring")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_subscriptions_stats(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    stats = await get_subscriptions_statistics(db)
+    
+    expiring_3d = await get_expiring_subscriptions(db, 3)
+    expiring_7d = await get_expiring_subscriptions(db, 7)
+    expired = await get_expired_subscriptions(db)
+    
+    text = f"""
+📊 <b>Детальная статистика подписок</b>
+
+<b>📱 Общая информация:</b>
+• Всего подписок: {stats['total_subscriptions']}
+• Активных: {stats['active_subscriptions']}
+• Неактивных: {stats['total_subscriptions'] - stats['active_subscriptions']}
+
+<b>💎 По типам:</b>
+• Платных: {stats['paid_subscriptions']}
+• Триальных: {stats['trial_subscriptions']}
+
+<b>📈 Продажи:</b>
+• Сегодня: {stats['purchased_today']}
+• За неделю: {stats['purchased_week']}  
+• За месяц: {stats['purchased_month']}
+
+<b>⏰ Истечение:</b>
+• Истекают через 3 дня: {len(expiring_3d)}
+• Истекают через 7 дней: {len(expiring_7d)}
+• Уже истекли: {len(expired)}
+
+<b>💰 Конверсия:</b>
+• Из триала в платную: {stats.get('trial_to_paid_conversion', 0)}%
+• Продлений: {stats.get('renewals_count', 0)}
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="📊 Экспорт данных", callback_data="admin_subs_export"),
+            types.InlineKeyboardButton(text="📈 Графики", callback_data="admin_subs_charts")
+        ],
+        [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_stats")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_pricing_settings(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    text = f"""
+⚙️ <b>Настройки цен</b>
+
+<b>Периоды подписки:</b>
+- 14 дней: {settings.format_price(settings.PRICE_14_DAYS)}
+- 30 дней: {settings.format_price(settings.PRICE_30_DAYS)}
+- 60 дней: {settings.format_price(settings.PRICE_60_DAYS)}
+- 90 дней: {settings.format_price(settings.PRICE_90_DAYS)}
+- 180 дней: {settings.format_price(settings.PRICE_180_DAYS)}
+- 360 дней: {settings.format_price(settings.PRICE_360_DAYS)}
+
+<b>Трафик-пакеты:</b>
+- 5 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_5GB)}
+- 10 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_10GB)}
+- 25 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_25GB)}
+- 50 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_50GB)}
+- 100 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_100GB)}
+- 250 ГБ: {settings.format_price(settings.PRICE_TRAFFIC_250GB)}
+
+<b>Дополнительно:</b>
+- За устройство: {settings.format_price(settings.PRICE_PER_DEVICE)}
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="📅 Периоды", callback_data="admin_edit_period_prices"),
+            types.InlineKeyboardButton(text="📈 Трафик", callback_data="admin_edit_traffic_prices")
+        ],
+        [
+            types.InlineKeyboardButton(text="📱 Устройства", callback_data="admin_edit_device_price")
+        ],
+        [
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")
+        ]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required  
+@error_handler
+async def show_countries_management(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    try:
+        from app.services.remnawave_service import RemnaWaveService
+        remnawave_service = RemnaWaveService()
+        
+        nodes_data = await remnawave_service.get_all_nodes()
+        squads_data = await remnawave_service.get_all_squads() 
+        
+        text = "🌍 <b>Управление странами</b>\n\n"
+        
+        if nodes_data:
+            text += "<b>Доступные серверы:</b>\n"
+            countries = {}
+            
+            for node in nodes_data:
+                country_code = node.get('country_code', 'XX')  
+                country_name = country_code
+                
+                if country_name not in countries:
+                    countries[country_name] = []
+                countries[country_name].append(node)
+            
+            for country, nodes in countries.items():
+                active_nodes = len([n for n in nodes if n.get('is_connected') and n.get('is_node_online')])
+                total_nodes = len(nodes)
+                
+                country_flag = get_country_flag(country)
+                text += f"{country_flag} {country}: {active_nodes}/{total_nodes} серверов\n"
+                
+                total_users_online = sum(n.get('users_online', 0) or 0 for n in nodes)
+                if total_users_online > 0:
+                    text += f"   👥 Пользователей онлайн: {total_users_online}\n"
+        else:
+            text += "❌ Не удалось загрузить данные о серверах\n"
+        
+        if squads_data:
+            text += f"\n<b>Всего сквадов:</b> {len(squads_data)}\n"
+            
+            total_members = sum(squad.get('members_count', 0) for squad in squads_data)
+            text += f"<b>Участников в сквадах:</b> {total_members}\n"
+            
+            text += "\n<b>Сквады:</b>\n"
+            for squad in squads_data[:5]: 
+                name = squad.get('name', 'Неизвестно')
+                members = squad.get('members_count', 0)
+                inbounds = squad.get('inbounds_count', 0)
+                text += f"• {name}: {members} участников, {inbounds} inbound(s)\n"
+            
+            if len(squads_data) > 5:
+                text += f"... и еще {len(squads_data) - 5} сквадов\n"
+        
+        user_stats = await get_users_by_countries(db)
+        if user_stats:
+            text += "\n<b>Пользователи по регионам:</b>\n"
+            for country, count in user_stats.items():
+                country_flag = get_country_flag(country)
+                text += f"{country_flag} {country}: {count} пользователей\n"
+        
+    except Exception as e:
+        logger.error(f"Ошибка получения данных о странах: {e}")
+        text = f"""
+🌍 <b>Управление странами</b>
+
+❌ <b>Ошибка загрузки данных</b>
+Не удалось получить информацию о серверах.
+
+Проверьте подключение к RemnaWave API.
+
+<b>Детали ошибки:</b> {str(e)}
+"""
+    
+    keyboard = [
+        [
+            types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_subs_countries"),
+            types.InlineKeyboardButton(text="⚙️ API настройки", callback_data="admin_rw_api")
+        ],
+        [
+            types.InlineKeyboardButton(text="📊 Статистика нод", callback_data="admin_rw_nodes"),
+            types.InlineKeyboardButton(text="🔧 Сквады", callback_data="admin_rw_squads")
+        ],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def send_expiry_reminders(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    await callback.message.edit_text(
+        "📨 Отправка напоминаний...\n\nПодождите, это может занять время.",
+        reply_markup=None
+    )
+    
+    expiring_subs = await get_expiring_subscriptions(db, 1)
+    sent_count = 0
+    
+    for subscription in expiring_subs:
+        if subscription.user:
+            try:
+                user = subscription.user
+                days_left = max(1, subscription.days_left)
+                
+                reminder_text = f"""
+⚠️ <b>Подписка истекает!</b>
+
+Ваша подписка истекает через {days_left} день(а).
+
+Не забудьте продлить подписку, чтобы не потерять доступ к серверам.
+
+💎 Продлить подписку можно в главном меню.
+"""
+                
+                await callback.bot.send_message(
+                    chat_id=user.telegram_id,
+                    text=reminder_text
+                )
+                sent_count += 1
+                
+            except Exception as e:
+                logger.error(f"Ошибка отправки напоминания пользователю {subscription.user_id}: {e}")
+    
+    await callback.message.edit_text(
+        f"✅ Напоминания отправлены: {sent_count} из {len(expiring_subs)}",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subs_expiring")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler  
+async def handle_subscriptions_pagination(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    page = int(callback.data.split('_')[-1])
+    await show_subscriptions_list(callback, db_user, db, page)
+
+
+def register_handlers(dp: Dispatcher):
+    dp.callback_query.register(show_subscriptions_menu, F.data == "admin_subscriptions")
+    dp.callback_query.register(show_subscriptions_list, F.data == "admin_subs_list")
+    dp.callback_query.register(show_expiring_subscriptions, F.data == "admin_subs_expiring")
+    dp.callback_query.register(show_subscriptions_stats, F.data == "admin_subs_stats")
+    dp.callback_query.register(show_pricing_settings, F.data == "admin_subs_pricing")
+    dp.callback_query.register(show_countries_management, F.data == "admin_subs_countries")
+    dp.callback_query.register(send_expiry_reminders, F.data == "admin_send_expiry_reminders")
+    
+    dp.callback_query.register(
+        handle_subscriptions_pagination, 
+        F.data.startswith("admin_subs_list_page_")
+    )

app/handlers/admin/users.py

@@ -0,0 +1,856 @@
+import logging
+from datetime import datetime
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.states import AdminStates
+from app.database.models import User, UserStatus, Subscription 
+from app.database.crud.user import get_user_by_id 
+from app.keyboards.admin import (
+    get_admin_users_keyboard, get_user_management_keyboard,
+    get_admin_pagination_keyboard, get_confirmation_keyboard
+)
+from app.localization.texts import get_texts
+from app.services.user_service import UserService
+from app.utils.decorators import admin_required, error_handler
+from app.utils.formatters import format_datetime, format_time_ago
+
+logger = logging.getLogger(__name__)
+
+
+@admin_required
+@error_handler
+async def show_users_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_service = UserService()
+    stats = await user_service.get_user_statistics(db)
+    
+    text = f"""
+👥 <b>Управление пользователями</b>
+
+📊 <b>Статистика:</b>
+• Всего: {stats['total_users']}
+• Активных: {stats['active_users']}
+• Заблокированных: {stats['blocked_users']}
+
+📈 <b>Новые пользователи:</b>
+• Сегодня: {stats['new_today']}
+• За неделю: {stats['new_week']}
+• За месяц: {stats['new_month']}
+
+Выберите действие:
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_admin_users_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_users_list(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    page: int = 1
+):
+    
+    user_service = UserService()
+    users_data = await user_service.get_users_page(db, page=page, limit=10)
+    
+    if not users_data["users"]:
+        await callback.message.edit_text(
+            "👥 Пользователи не найдены",
+            reply_markup=get_admin_users_keyboard(db_user.language)
+        )
+        await callback.answer()
+        return
+    
+    text = f"👥 <b>Список пользователей</b> (стр. {page}/{users_data['total_pages']})\n\n"
+    
+    for user in users_data["users"]:
+        status_emoji = "✅" if user.status == UserStatus.ACTIVE.value else "❌"
+        subscription_info = ""
+        
+        if user.subscription:
+            if user.subscription.is_trial:
+                subscription_info = "🎁"
+            elif user.subscription.is_active:
+                subscription_info = "💎"
+            else:
+                subscription_info = "⏰"
+        
+        text += f"{status_emoji} {subscription_info} <b>{user.full_name}</b>\n"
+        text += f"🆔 <code>{user.telegram_id}</code>\n"
+        text += f"💰 {settings.format_price(user.balance_kopeks)}\n"
+        text += f"📅 {format_time_ago(user.created_at)}\n\n"
+    
+    keyboard = []
+    
+    if users_data["total_pages"] > 1:
+        pagination_row = get_admin_pagination_keyboard(
+            users_data["current_page"],
+            users_data["total_pages"],
+            "admin_users_list",
+            "admin_users",
+            db_user.language
+        ).inline_keyboard[0]
+        keyboard.append(pagination_row)
+    
+    keyboard.extend([
+        [
+            types.InlineKeyboardButton(text="🔍 Поиск", callback_data="admin_users_search"),
+            types.InlineKeyboardButton(text="📊 Статистика", callback_data="admin_users_stats")
+        ],
+        [
+            types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")
+        ]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def handle_users_list_pagination_fixed(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    try:
+        callback_parts = callback.data.split('_')
+        page = int(callback_parts[-1]) 
+        await show_users_list(callback, db_user, db, page)
+    except (ValueError, IndexError) as e:
+        logger.error(f"Ошибка парсинга номера страницы: {e}")
+        await show_users_list(callback, db_user, db, 1)
+
+
+@admin_required
+@error_handler
+async def start_user_search(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    
+    await callback.message.edit_text(
+        "🔍 <b>Поиск пользователя</b>\n\n"
+        "Введите для поиска:\n"
+        "• Telegram ID\n"
+        "• Username (без @)\n"
+        "• Имя или фамилию\n\n"
+        "Или нажмите /cancel для отмены",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_users")]
+        ])
+    )
+    
+    await state.set_state(AdminStates.waiting_for_user_search)
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def show_users_statistics(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_service = UserService()
+    stats = await user_service.get_user_statistics(db)
+    
+    from sqlalchemy import select, func, and_
+    
+    with_sub_result = await db.execute(
+        select(func.count(User.id))
+        .join(Subscription)
+        .where(
+            and_(
+                User.status == UserStatus.ACTIVE.value,
+                Subscription.is_active == True
+            )
+        )
+    )
+    users_with_subscription = with_sub_result.scalar() or 0
+    
+    trial_result = await db.execute(
+        select(func.count(User.id))
+        .join(Subscription)
+        .where(
+            and_(
+                User.status == UserStatus.ACTIVE.value,
+                Subscription.is_trial == True,
+                Subscription.is_active == True
+            )
+        )
+    )
+    trial_users = trial_result.scalar() or 0
+    
+    avg_balance_result = await db.execute(
+        select(func.avg(User.balance_kopeks))
+        .where(User.status == UserStatus.ACTIVE.value)
+    )
+    avg_balance = avg_balance_result.scalar() or 0
+    
+    text = f"""
+📊 <b>Детальная статистика пользователей</b>
+
+👥 <b>Общие показатели:</b>
+• Всего: {stats['total_users']}
+• Активных: {stats['active_users']}
+• Заблокированных: {stats['blocked_users']}
+
+📱 <b>Подписки:</b>
+• С активной подпиской: {users_with_subscription}
+• На триале: {trial_users}
+• Без подписки: {stats['active_users'] - users_with_subscription}
+
+💰 <b>Финансы:</b>
+• Средний баланс: {settings.format_price(int(avg_balance))}
+
+📈 <b>Регистрации:</b>
+• Сегодня: {stats['new_today']}
+• За неделю: {stats['new_week']}
+• За месяц: {stats['new_month']}
+
+📊 <b>Активность:</b>
+• Конверсия в подписку: {(users_with_subscription / max(stats['active_users'], 1) * 100):.1f}%
+• Доля триальных: {(trial_users / max(users_with_subscription, 1) * 100):.1f}%
+"""
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_users_stats")],
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_user_subscription(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    profile = await user_service.get_user_profile(db, user_id)
+    
+    if not profile:
+        await callback.answer("❌ Пользователь не найден", show_alert=True)
+        return
+    
+    user = profile["user"]
+    subscription = profile["subscription"]
+    
+    text = f"📱 <b>Подписка пользователя</b>\n\n"
+    text += f"👤 {user.full_name} (ID: <code>{user.telegram_id}</code>)\n\n"
+    
+    if subscription:
+        status_emoji = "✅" if subscription.is_active else "❌"
+        type_emoji = "🎁" if subscription.is_trial else "💎"
+        
+        text += f"<b>Статус:</b> {status_emoji} {'Активна' if subscription.is_active else 'Неактивна'}\n"
+        text += f"<b>Тип:</b> {type_emoji} {'Триал' if subscription.is_trial else 'Платная'}\n"
+        text += f"<b>Начало:</b> {format_datetime(subscription.start_date)}\n"
+        text += f"<b>Окончание:</b> {format_datetime(subscription.end_date)}\n"
+        text += f"<b>Трафик:</b> {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ\n"
+        text += f"<b>Устройства:</b> {subscription.device_limit}\n"
+        text += f"<b>Подключенных устройств:</b> {len(subscription.connected_devices) if subscription.connected_devices else 0}\n"
+        
+        if subscription.is_active:
+            days_left = (subscription.end_date - datetime.utcnow()).days
+            text += f"<b>Осталось дней:</b> {days_left}\n"
+        
+        keyboard = [
+            [
+                types.InlineKeyboardButton(
+                    text="⏰ Продлить", 
+                    callback_data=f"admin_sub_extend_{user_id}"
+                ),
+                types.InlineKeyboardButton(
+                    text="📊 Трафик", 
+                    callback_data=f"admin_sub_traffic_{user_id}"
+                )
+            ]
+        ]
+        
+        if subscription.is_active:
+            keyboard.append([
+                types.InlineKeyboardButton(
+                    text="🚫 Деактивировать", 
+                    callback_data=f"admin_sub_deactivate_{user_id}"
+                )
+            ])
+        else:
+            keyboard.append([
+                types.InlineKeyboardButton(
+                    text="✅ Активировать", 
+                    callback_data=f"admin_sub_activate_{user_id}"
+                )
+            ])
+    else:
+        text += "❌ <b>Подписка отсутствует</b>\n\n"
+        text += "Пользователь еще не активировал подписку."
+        
+        keyboard = [
+            [
+                types.InlineKeyboardButton(
+                    text="🎁 Выдать триал", 
+                    callback_data=f"admin_sub_grant_trial_{user_id}"
+                ),
+                types.InlineKeyboardButton(
+                    text="💎 Выдать подписку", 
+                    callback_data=f"admin_sub_grant_{user_id}"
+                )
+            ]
+        ]
+    
+    keyboard.append([
+        types.InlineKeyboardButton(text="⬅️ К пользователю", callback_data=f"admin_user_manage_{user_id}")
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_user_transactions(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    from app.database.crud.transaction import get_user_transactions
+    
+    user = await get_user_by_id(db, user_id)
+    if not user:
+        await callback.answer("❌ Пользователь не найден", show_alert=True)
+        return
+    
+    transactions = await get_user_transactions(db, user_id, limit=10)
+    
+    text = f"💳 <b>Транзакции пользователя</b>\n\n"
+    text += f"👤 {user.full_name} (ID: <code>{user.telegram_id}</code>)\n"
+    text += f"💰 Текущий баланс: {settings.format_price(user.balance_kopeks)}\n\n"
+    
+    if transactions:
+        text += "<b>Последние транзакции:</b>\n\n"
+        
+        for transaction in transactions:
+            type_emoji = "📈" if transaction.amount_kopeks > 0 else "📉"
+            text += f"{type_emoji} {settings.format_price(abs(transaction.amount_kopeks))}\n"
+            text += f"📋 {transaction.description}\n"
+            text += f"📅 {format_datetime(transaction.created_at)}\n\n"
+    else:
+        text += "📭 <b>Транзакции отсутствуют</b>"
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⬅️ К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+        ])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def confirm_user_delete(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    await callback.message.edit_text(
+        "🗑️ <b>Удаление пользователя</b>\n\n"
+        "⚠️ <b>ВНИМАНИЕ!</b>\n"
+        "Вы уверены, что хотите удалить этого пользователя?\n\n"
+        "Это действие:\n"
+        "• Пометит пользователя как удаленного\n"
+        "• Деактивирует его подписку\n"
+        "• Заблокирует доступ к боту\n\n"
+        "Данное действие необратимо!",
+        reply_markup=get_confirmation_keyboard(
+            f"admin_user_delete_confirm_{user_id}",
+            f"admin_user_manage_{user_id}",
+            db_user.language
+        )
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def delete_user_account(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    success = await user_service.delete_user_account(db, user_id, db_user.id)
+    
+    if success:
+        await callback.message.edit_text(
+            "✅ Пользователь успешно удален",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="👥 К списку пользователей", callback_data="admin_users_list")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка удаления пользователя",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_user_search(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    
+    query = message.text.strip()
+    
+    if not query:
+        await message.answer("❌ Введите корректный запрос для поиска")
+        return
+    
+    user_service = UserService()
+    search_results = await user_service.search_users(db, query, page=1, limit=10)
+    
+    if not search_results["users"]:
+        await message.answer(
+            f"🔍 По запросу '<b>{query}</b>' ничего не найдено",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
+            ])
+        )
+        await state.clear()
+        return
+    
+    text = f"🔍 <b>Результаты поиска:</b> '{query}'\n\n"
+    keyboard = []
+    
+    for user in search_results["users"]:
+        status_emoji = "✅" if user.status == UserStatus.ACTIVE.value else "❌"
+        subscription_info = ""
+        
+        if user.subscription:
+            if user.subscription.is_trial:
+                subscription_info = "🎁"
+            elif user.subscription.is_active:
+                subscription_info = "💎"
+            else:
+                subscription_info = "⏰"
+        
+        text += f"{status_emoji} {subscription_info} <b>{user.full_name}</b>\n"
+        text += f"🆔 <code>{user.telegram_id}</code>\n"
+        text += f"💰 {settings.format_price(user.balance_kopeks)}\n\n"
+        
+        keyboard.append([
+            types.InlineKeyboardButton(
+                text=f"👤 {user.full_name}",
+                callback_data=f"admin_user_manage_{user.id}"
+            )
+        ])
+    
+    keyboard.append([
+        types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")
+    ])
+    
+    await message.answer(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await state.clear()
+
+
+@admin_required
+@error_handler
+async def show_user_management(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    profile = await user_service.get_user_profile(db, user_id)
+    
+    if not profile:
+        await callback.answer("❌ Пользователь не найден", show_alert=True)
+        return
+    
+    user = profile["user"]
+    subscription = profile["subscription"]
+    
+    status_text = "✅ Активен" if user.status == UserStatus.ACTIVE.value else "❌ Заблокирован"
+    
+    text = f"""
+👤 <b>Управление пользователем</b>
+
+<b>Основная информация:</b>
+• Имя: {user.full_name}
+• ID: <code>{user.telegram_id}</code>
+• Username: @{user.username or 'не указан'}
+• Статус: {status_text}
+• Язык: {user.language}
+
+<b>Финансы:</b>
+• Баланс: {settings.format_price(user.balance_kopeks)}
+• Транзакций: {profile['transactions_count']}
+
+<b>Активность:</b>
+• Регистрация: {format_datetime(user.created_at)}
+• Последняя активность: {format_time_ago(user.last_activity) if user.last_activity else 'Неизвестно'}
+• Дней с регистрации: {profile['registration_days']}
+"""
+    
+    if subscription:
+        text += f"""
+<b>Подписка:</b>
+• Тип: {'🎁 Триал' if subscription.is_trial else '💎 Платная'}
+• Статус: {'✅ Активна' if subscription.is_active else '❌ Неактивна'}
+• До: {format_datetime(subscription.end_date)}
+• Трафик: {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ
+• Устройства: {subscription.device_limit}
+• Стран: {len(subscription.connected_squads)}
+"""
+    else:
+        text += "\n<b>Подписка:</b> Отсутствует"
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=get_user_management_keyboard(user.id, db_user.language)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def start_balance_edit(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    await state.update_data(editing_user_id=user_id)
+    
+    await callback.message.edit_text(
+        "💰 <b>Изменение баланса</b>\n\n"
+        "Введите сумму для изменения баланса:\n"
+        "• Положительное число для пополнения\n"
+        "• Отрицательное число для списания\n"
+        "• Примеры: 100, -50, 25.5\n\n"
+        "Или нажмите /cancel для отмены",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_manage_{user_id}")]
+        ])
+    )
+    
+    await state.set_state(AdminStates.editing_user_balance)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_balance_edit(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    
+    data = await state.get_data()
+    user_id = data.get("editing_user_id")
+    
+    if not user_id:
+        await message.answer("❌ Ошибка: пользователь не найден")
+        await state.clear()
+        return
+    
+    try:
+        amount_rubles = float(message.text.replace(',', '.'))
+        amount_kopeks = int(amount_rubles * 100)
+        
+        if abs(amount_kopeks) > 10000000: 
+            await message.answer("❌ Слишком большая сумма (максимум 100,000 ₽)")
+            return
+        
+        user_service = UserService()
+        
+        description = f"Изменение баланса администратором {db_user.full_name}"
+        if amount_kopeks > 0:
+            description = f"Пополнение администратором: +{amount_rubles} ₽"
+        else:
+            description = f"Списание администратором: {amount_rubles} ₽"
+        
+        success = await user_service.update_user_balance(
+            db, user_id, amount_kopeks, description, db_user.id
+        )
+        
+        if success:
+            action = "пополнен" if amount_kopeks > 0 else "списан"
+            await message.answer(
+                f"✅ Баланс пользователя {action} на {settings.format_price(abs(amount_kopeks))}",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+                ])
+            )
+        else:
+            await message.answer("❌ Ошибка изменения баланса (возможно, недостаточно средств для списания)")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректную сумму (например: 100 или -50)")
+        return
+    
+    await state.clear()
+
+
+@admin_required
+@error_handler
+async def confirm_user_block(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    await callback.message.edit_text(
+        "🚫 <b>Блокировка пользователя</b>\n\n"
+        "Вы уверены, что хотите заблокировать этого пользователя?\n"
+        "Пользователь потеряет доступ к боту.",
+        reply_markup=get_confirmation_keyboard(
+            f"admin_user_block_confirm_{user_id}",
+            f"admin_user_manage_{user_id}",
+            db_user.language
+        )
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def block_user(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    success = await user_service.block_user(
+        db, user_id, db_user.id, "Заблокирован администратором"
+    )
+    
+    if success:
+        await callback.message.edit_text(
+            "✅ Пользователь заблокирован",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка блокировки пользователя",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_manage_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def show_inactive_users(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_service = UserService()
+    
+    from app.database.crud.user import get_inactive_users
+    inactive_users = await get_inactive_users(db, settings.INACTIVE_USER_DELETE_MONTHS)
+    
+    if not inactive_users:
+        await callback.message.edit_text(
+            f"✅ Неактивных пользователей (более {settings.INACTIVE_USER_DELETE_MONTHS} месяцев) не найдено",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
+            ])
+        )
+        await callback.answer()
+        return
+    
+    text = f"🗑️ <b>Неактивные пользователи</b>\n"
+    text += f"Без активности более {settings.INACTIVE_USER_DELETE_MONTHS} месяцев: {len(inactive_users)}\n\n"
+    
+    for user in inactive_users[:10]: 
+        text += f"👤 {user.full_name}\n"
+        text += f"🆔 <code>{user.telegram_id}</code>\n"
+        text += f"📅 {format_time_ago(user.last_activity) if user.last_activity else 'Никогда'}\n\n"
+    
+    if len(inactive_users) > 10:
+        text += f"... и еще {len(inactive_users) - 10} пользователей"
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="🗑️ Очистить всех", callback_data="admin_cleanup_inactive")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def cleanup_inactive_users(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_service = UserService()
+    deleted_count = await user_service.cleanup_inactive_users(db)
+    
+    await callback.message.edit_text(
+        f"✅ Очистка завершена\n\n"
+        f"Удалено неактивных пользователей: {deleted_count}",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users")]
+        ])
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_users_menu,
+        F.data == "admin_users"
+    )
+    
+    dp.callback_query.register(
+        show_users_list,
+        F.data == "admin_users_list"
+    )
+    
+    dp.callback_query.register(
+        show_users_statistics,
+        F.data == "admin_users_stats"
+    )
+    
+    dp.callback_query.register(
+        show_user_subscription,
+        F.data.startswith("admin_user_sub_")
+    )
+    
+    dp.callback_query.register(
+        show_user_transactions,
+        F.data.startswith("admin_user_trans_")
+    )
+    
+    dp.callback_query.register(
+        confirm_user_delete,
+        F.data.startswith("admin_user_delete_")
+    )
+    
+    dp.callback_query.register(
+        delete_user_account,
+        F.data.startswith("admin_user_delete_confirm_")
+    )
+    
+    dp.callback_query.register(
+        handle_users_list_pagination_fixed,
+        F.data.startswith("admin_users_list_page_")
+    )
+    
+    dp.callback_query.register(
+        start_user_search,
+        F.data == "admin_users_search"
+    )
+    
+    dp.message.register(
+        process_user_search,
+        AdminStates.waiting_for_user_search
+    )
+    
+    dp.callback_query.register(
+        show_user_management,
+        F.data.startswith("admin_user_manage_")
+    )
+    
+    dp.callback_query.register(
+        start_balance_edit,
+        F.data.startswith("admin_user_balance_")
+    )
+    
+    dp.message.register(
+        process_balance_edit,
+        AdminStates.editing_user_balance
+    )
+    
+    dp.callback_query.register(
+        confirm_user_block,
+        F.data.startswith("admin_user_block_")
+    )
+    
+    dp.callback_query.register(
+        block_user,
+        F.data.startswith("admin_user_block_confirm_")
+    )
+    
+    dp.callback_query.register(
+        show_inactive_users,
+        F.data == "admin_users_inactive"
+    )
+    
+    dp.callback_query.register(
+        cleanup_inactive_users,
+        F.data == "admin_cleanup_inactive"
+    )

app/handlers/balance.py

@@ -0,0 +1,341 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.states import BalanceStates
+from app.database.crud.user import add_user_balance
+from app.database.crud.transaction import (
+    get_user_transactions, get_user_transactions_count,
+    create_transaction
+)
+from app.database.models import User, TransactionType, PaymentMethod
+from app.keyboards.inline import (
+    get_balance_keyboard, get_payment_methods_keyboard,
+    get_back_keyboard, get_pagination_keyboard
+)
+from app.localization.texts import get_texts
+from app.services.payment_service import PaymentService
+from app.utils.pagination import paginate_list
+from app.utils.decorators import error_handler
+
+logger = logging.getLogger(__name__)
+
+TRANSACTIONS_PER_PAGE = 10
+
+
+@error_handler
+async def show_balance_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    
+    balance_text = texts.BALANCE_INFO.format(
+        balance=texts.format_price(db_user.balance_kopeks)
+    )
+    
+    await callback.message.edit_text(
+        balance_text,
+        reply_markup=get_balance_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+@error_handler
+async def show_balance_history(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    page: int = 1
+):
+    texts = get_texts(db_user.language)
+    
+    offset = (page - 1) * TRANSACTIONS_PER_PAGE
+    
+    transactions = await get_user_transactions(
+        db, db_user.id, 
+        limit=TRANSACTIONS_PER_PAGE,
+        offset=offset
+    )
+    
+    total_count = await get_user_transactions_count(db, db_user.id)
+    
+    if not transactions:
+        await callback.message.edit_text(
+            "📊 История операций пуста",
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+        await callback.answer()
+        return
+    
+    text = "📊 <b>История операций</b>\n\n"
+    
+    for transaction in transactions:
+        emoji = "💰" if transaction.type == TransactionType.DEPOSIT.value else "💸"
+        amount_text = f"+{texts.format_price(transaction.amount_kopeks)}" if transaction.type == TransactionType.DEPOSIT.value else f"-{texts.format_price(transaction.amount_kopeks)}"
+        
+        text += f"{emoji} {amount_text}\n"
+        text += f"📝 {transaction.description}\n"
+        text += f"📅 {transaction.created_at.strftime('%d.%m.%Y %H:%M')}\n\n"
+    
+    keyboard = []
+    total_pages = (total_count + TRANSACTIONS_PER_PAGE - 1) // TRANSACTIONS_PER_PAGE
+    
+    if total_pages > 1:
+        pagination_row = get_pagination_keyboard(
+            page, total_pages, "balance_history", db_user.language
+        )
+        keyboard.extend(pagination_row)
+    
+    keyboard.append([
+        types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@error_handler
+async def handle_balance_history_pagination(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    page = int(callback.data.split('_')[-1])
+    await show_balance_history(callback, db_user, db, page)
+
+
+@error_handler
+async def start_balance_topup(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    """Начать пополнение - только для Telegram Stars"""
+    texts = get_texts(db_user.language)
+    
+    if not settings.TELEGRAM_STARS_ENABLED:
+        await callback.answer("❌ Пополнение временно недоступно", show_alert=True)
+        return
+    
+    await callback.message.edit_text(
+        texts.TOP_UP_AMOUNT,
+        reply_markup=get_back_keyboard(db_user.language)
+    )
+    
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await callback.answer()
+
+
+@error_handler
+async def process_topup_amount(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext
+):
+    """Обработка введенной суммы - только для Telegram Stars"""
+    texts = get_texts(db_user.language)
+    
+    try:
+        amount_rubles = float(message.text.replace(',', '.'))
+        
+        if amount_rubles < 1:
+            await message.answer("❌ Минимальная сумма пополнения: 1 ₽")
+            return
+        
+        if amount_rubles > 50000:
+            await message.answer("❌ Максимальная сумма пополнения: 50,000 ₽")
+            return
+        
+        amount_kopeks = int(amount_rubles * 100)
+        
+        await state.update_data(amount_kopeks=amount_kopeks)
+        
+        payment_text = texts.TOP_UP_METHODS.format(
+            amount=texts.format_price(amount_kopeks)
+        )
+        
+        await message.answer(
+            payment_text,
+            reply_markup=get_payment_methods_keyboard(amount_kopeks, db_user.language)
+        )
+        
+    except ValueError:
+        await message.answer(
+            texts.INVALID_AMOUNT,
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+
+
+@error_handler
+async def process_stars_payment(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.TELEGRAM_STARS_ENABLED:
+        await callback.answer("❌ Оплата Stars временно недоступна", show_alert=True)
+        return
+    
+    amount_kopeks = int(callback.data.split('_')[-1])
+    
+    try:
+        payment_service = PaymentService(callback.bot)
+        invoice_link = await payment_service.create_stars_invoice(
+            amount_kopeks=amount_kopeks,
+            description=f"Пополнение баланса на {texts.format_price(amount_kopeks)}",
+            payload=f"balance_{db_user.id}_{amount_kopeks}"
+        )
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⭐ Оплатить", url=invoice_link)],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
+        ])
+        
+        await callback.message.edit_text(
+            f"⭐ <b>Оплата через Telegram Stars</b>\n\n"
+            f"Сумма: {texts.format_price(amount_kopeks)}\n\n"
+            f"Нажмите кнопку ниже для оплаты:",
+            reply_markup=keyboard
+        )
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания Stars invoice: {e}")
+        await callback.answer("❌ Ошибка создания платежа", show_alert=True)
+    
+    await callback.answer()
+
+
+@error_handler  
+async def process_tribute_quick_payment(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    """Быстрое пополнение через Tribute - без выбора суммы"""
+    texts = get_texts(db_user.language)
+    
+    if not settings.TRIBUTE_ENABLED:
+        await callback.answer("❌ Оплата картой временно недоступна", show_alert=True)
+        return
+    
+    try:
+        from app.services.tribute_service import TributeService
+        
+        tribute_service = TributeService(callback.bot)
+        payment_url = await tribute_service.create_payment_link(
+            user_id=db_user.telegram_id,
+            amount_kopeks=0,
+            description="Пополнение баланса VPN"
+        )
+        
+        if not payment_url:
+            await callback.answer("❌ Ошибка создания платежа", show_alert=True)
+            return
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="💳 Перейти к оплате", url=payment_url)],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")]
+        ])
+        
+        await callback.message.edit_text(
+            f"💳 <b>Пополнение банковской картой</b>\n\n"
+            f"• Введите любую сумму от 50 ₽\n"
+            f"• Безопасная оплата через Tribute\n"
+            f"• Мгновенное зачисление на баланс\n"
+            f"• Принимаем карты Visa, MasterCard, МИР\n\n"
+            f"Нажмите кнопку для перехода к оплате:",
+            reply_markup=keyboard
+        )
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания Tribute платежа: {e}")
+        await callback.answer("❌ Ошибка создания платежа", show_alert=True)
+    
+    await callback.answer()
+
+
+@error_handler
+async def request_support_topup(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    texts = get_texts(db_user.language)
+    
+    support_text = f"""
+🛠️ <b>Пополнение через поддержку</b>
+
+Для пополнения баланса обратитесь в техподдержку:
+{settings.SUPPORT_USERNAME}
+
+Укажите:
+• ID: {db_user.telegram_id}
+• Сумму пополнения
+• Способ оплаты
+
+⏰ Время обработки: 1-24 часа
+"""
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [types.InlineKeyboardButton(
+            text="💬 Написать в поддержку", 
+            url=f"https://t.me/{settings.SUPPORT_USERNAME.lstrip('@')}"
+        )],
+        [types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")]
+    ])
+    
+    await callback.message.edit_text(
+        support_text,
+        reply_markup=keyboard
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_balance_menu,
+        F.data == "menu_balance"
+    )
+    
+    dp.callback_query.register(
+        show_balance_history,
+        F.data == "balance_history"
+    )
+    
+    dp.callback_query.register(
+        handle_balance_history_pagination,
+        F.data.startswith("balance_history_page_")
+    )
+    
+    dp.callback_query.register(
+        start_balance_topup,
+        F.data == "balance_topup"
+    )
+    
+    dp.callback_query.register(
+        process_stars_payment,
+        F.data.startswith("pay_stars_")
+    )
+    
+    dp.callback_query.register(
+        process_tribute_quick_payment,
+        F.data == "tribute_quick_pay"
+    )
+    
+    dp.callback_query.register(
+        request_support_topup,
+        F.data == "balance_support"
+    )
+    
+    dp.message.register(
+        process_topup_amount,
+        BalanceStates.waiting_for_amount
+    )

app/handlers/common.py

@@ -0,0 +1,85 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.models import User
+from app.localization.texts import get_texts
+from app.keyboards.inline import get_back_keyboard
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_unknown_callback(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    
+    texts = get_texts(db_user.language if db_user else "ru")
+    
+    await callback.answer(
+        "❓ Неизвестная команда. Попробуйте ещё раз.",
+        show_alert=True
+    )
+    
+    logger.warning(f"Неизвестный callback: {callback.data} от пользователя {callback.from_user.id}")
+
+
+async def handle_cancel(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User
+):
+    
+    texts = get_texts(db_user.language)
+    
+    await state.clear()
+    await callback.message.edit_text(
+        texts.OPERATION_CANCELLED,
+        reply_markup=get_back_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+async def handle_unknown_message(
+    message: types.Message,
+    db_user: User
+):
+    
+    texts = get_texts(db_user.language if db_user else "ru")
+    
+    await message.answer(
+        "❓ Не понимаю эту команду. Используйте кнопки меню.",
+        reply_markup=get_back_keyboard(db_user.language if db_user else "ru")
+    )
+
+
+async def show_rules(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    texts = get_texts(db_user.language)
+    
+    rules_text = texts.RULES_TEXT
+    
+    await callback.message.edit_text(
+        rules_text,
+        reply_markup=get_back_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_rules,
+        F.data == "menu_rules"
+    )
+    
+    dp.callback_query.register(
+        handle_cancel,
+        F.data.in_(["cancel", "subscription_cancel"])
+    )
+    

app/handlers/menu.py

@@ -0,0 +1,132 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.user import get_user_by_telegram_id, update_user
+from app.keyboards.inline import get_main_menu_keyboard
+from app.localization.texts import get_texts
+from app.database.models import User
+from app.utils.user_utils import mark_user_as_had_paid_subscription
+
+logger = logging.getLogger(__name__)
+
+
+async def show_main_menu(
+    callback: types.CallbackQuery, 
+    db_user: User, 
+    db: AsyncSession
+):
+    
+    texts = get_texts(db_user.language)
+    
+    from datetime import datetime
+    db_user.last_activity = datetime.utcnow()
+    await db.commit()
+    
+    has_active_subscription = bool(db_user.subscription)
+    subscription_is_active = False
+    
+    if db_user.subscription:
+        subscription_is_active = db_user.subscription.is_active
+    
+    menu_text = texts.MAIN_MENU.format(
+        user_name=db_user.full_name,
+        balance=texts.format_price(db_user.balance_kopeks),
+        subscription_status=_get_subscription_status(db_user, texts)
+    )
+    
+    await callback.message.edit_text(
+        menu_text,
+        reply_markup=get_main_menu_keyboard(
+            language=db_user.language,
+            is_admin=settings.is_admin(db_user.telegram_id),
+            has_had_paid_subscription=db_user.has_had_paid_subscription,
+            has_active_subscription=has_active_subscription,
+            subscription_is_active=subscription_is_active  
+        )
+    )
+    await callback.answer()
+
+async def mark_user_as_had_paid_subscription(
+    db: AsyncSession,
+    user: User
+) -> None:
+    if not user.has_had_paid_subscription:
+        user.has_had_paid_subscription = True
+        user.updated_at = datetime.utcnow()
+        await db.commit()
+        logger.info(f"🎯 Пользователь {user.telegram_id} отмечен как имевший платную подписку")
+
+
+async def show_service_rules(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    from app.database.crud.rules import get_current_rules_content
+    
+    rules_text = await get_current_rules_content(db, db_user.language)
+    
+    if not rules_text:
+        texts = get_texts(db_user.language)
+        rules_text = texts._get_default_rules(db_user.language) if hasattr(texts, '_get_default_rules') else """
+📋 <b>Правила использования сервиса</b>
+
+1. Запрещается использование сервиса для незаконной деятельности
+2. Запрещается нарушение авторских прав
+3. Запрещается спам и рассылка вредоносного ПО
+4. Запрещается использование сервиса для DDoS атак
+5. Один аккаунт - один пользователь
+6. Возврат средств производится только в исключительных случаях
+7. Администрация оставляет за собой право заблокировать аккаунт при нарушении правил
+
+<b>Принимая правила, вы соглашаетесь соблюдать их.</b>
+"""
+    
+    await callback.message.edit_text(
+        f"📋 <b>Правила сервиса</b>\n\n{rules_text}",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="back_to_menu")]
+        ])
+    )
+    await callback.answer()
+
+
+async def handle_back_to_menu(
+    callback: types.CallbackQuery,
+    state: FSMContext,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    await state.clear()
+    
+    await show_main_menu(callback, db_user, db)
+
+
+def _get_subscription_status(user: User, texts) -> str:
+    if not user.subscription:
+        return texts.SUBSCRIPTION_NONE
+    
+    if user.subscription.is_trial:
+        return f"{texts.SUBSCRIPTION_TRIAL} (до {user.subscription.end_date.strftime('%d.%m.%Y')})"
+    elif user.subscription.is_active:
+        days_left = user.subscription.days_left
+        return f"{texts.SUBSCRIPTION_ACTIVE} ({days_left} дн.)"
+    else:
+        return texts.SUBSCRIPTION_EXPIRED
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        handle_back_to_menu,
+        F.data == "back_to_menu"
+    )
+    
+    dp.callback_query.register(
+        show_service_rules,
+        F.data == "menu_rules"
+    )

app/handlers/promocode.py

@@ -0,0 +1,89 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.states import PromoCodeStates
+from app.database.models import User
+from app.keyboards.inline import get_back_keyboard
+from app.localization.texts import get_texts
+from app.services.promocode_service import PromoCodeService
+from app.utils.decorators import error_handler
+
+logger = logging.getLogger(__name__)
+
+
+@error_handler
+async def show_promocode_menu(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    await callback.message.edit_text(
+        texts.PROMOCODE_ENTER,
+        reply_markup=get_back_keyboard(db_user.language)
+    )
+    
+    await state.set_state(PromoCodeStates.waiting_for_code)
+    await callback.answer()
+
+
+@error_handler
+async def process_promocode(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    
+    code = message.text.strip()
+    
+    if not code:
+        await message.answer(
+            "❌ Введите корректный промокод",
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+        return
+    
+    promocode_service = PromoCodeService()
+    result = await promocode_service.activate_promocode(db, db_user.id, code)
+    
+    if result["success"]:
+        await message.answer(
+            texts.PROMOCODE_SUCCESS.format(description=result["description"]),
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+        logger.info(f"✅ Пользователь {db_user.telegram_id} активировал промокод {code}")
+    else:
+        error_messages = {
+            "not_found": texts.PROMOCODE_INVALID,
+            "expired": texts.PROMOCODE_EXPIRED,
+            "used": texts.PROMOCODE_USED,
+            "already_used_by_user": texts.PROMOCODE_USED,
+            "server_error": texts.ERROR
+        }
+        
+        error_text = error_messages.get(result["error"], texts.PROMOCODE_INVALID)
+        await message.answer(
+            error_text,
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+    
+    await state.clear()
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_promocode_menu,
+        F.data == "menu_promocode"
+    )
+    
+    dp.message.register(
+        process_promocode,
+        PromoCodeStates.waiting_for_code
+    )

app/handlers/referral.py

@@ -0,0 +1,144 @@
+import logging
+from aiogram import Dispatcher, types, F
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.referral import get_referral_earnings_sum
+from app.database.models import User
+from app.keyboards.inline import get_referral_keyboard, get_back_keyboard
+from app.localization.texts import get_texts
+from app.utils.user_utils import get_user_referral_summary
+
+logger = logging.getLogger(__name__)
+
+
+async def show_referral_info(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    texts = get_texts(db_user.language)
+    
+    summary = await get_user_referral_summary(db, db_user.id)
+    
+    bot_username = (await callback.bot.get_me()).username
+    referral_link = f"https://t.me/{bot_username}?start={db_user.referral_code}"
+    
+    referral_text = f"👥 <b>Реферальная программа</b>\n\n"
+    
+    referral_text += f"📊 <b>Ваша статистика:</b>\n"
+    referral_text += f"• Приглашено пользователей: {summary['invited_count']}\n"
+    referral_text += f"• Купили подписку: {summary['paid_referrals_count']}\n"
+    referral_text += f"• Заработано всего: {texts.format_price(summary['total_earned_kopeks'])}\n"
+    referral_text += f"• За последний месяц: {texts.format_price(summary['month_earned_kopeks'])}\n\n"
+    
+    referral_text += f"🎁 <b>Как работают награды:</b>\n"
+    referral_text += f"• Новый пользователь получает: {texts.format_price(settings.REFERRED_USER_REWARD)}\n"
+    referral_text += f"• Вы получаете при первой покупке реферала: {texts.format_price(settings.REFERRAL_REGISTRATION_REWARD)}\n"
+    referral_text += f"• Комиссия с каждой покупки реферала: {settings.REFERRAL_COMMISSION_PERCENT}%\n\n"
+    
+    referral_text += f"🔗 <b>Ваша реферальная ссылка:</b>\n"
+    referral_text += f"<code>{referral_link}</code>\n\n"
+    referral_text += f"🆔 <b>Ваш код:</b> <code>{db_user.referral_code}</code>\n\n"
+    
+    if summary['recent_earnings']:
+        referral_text += f"💰 <b>Последние начисления:</b>\n"
+        for earning in summary['recent_earnings'][:3]: 
+            reason_text = {
+                "referral_first_purchase": "🎉 Первая покупка",
+                "referral_commission": "💰 Комиссия",
+                "referral_registration_pending": "⏳ Ожидание покупки"
+            }.get(earning['reason'], earning['reason'])
+            
+            referral_text += f"• {reason_text}: {texts.format_price(earning['amount_kopeks'])} от {earning['referral_name']}\n"
+        referral_text += "\n"
+    
+    referral_text += "📢 Приглашайте друзей и зарабатывайте!"
+    
+    await callback.message.edit_text(
+        referral_text,
+        reply_markup=get_referral_keyboard(db_user.language),
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+async def create_invite_message(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    
+    texts = get_texts(db_user.language)
+    
+    bot_username = (await callback.bot.get_me()).username
+    referral_link = f"https://t.me/{bot_username}?start={db_user.referral_code}"
+    
+    invite_text = f"🎉 Присоединяйся к VPN сервису!\n\n"
+    invite_text += f"💎 При регистрации по моей ссылке ты получишь {texts.format_price(settings.REFERRED_USER_REWARD)} на баланс!\n\n"
+    invite_text += f"🚀 Быстрое подключение\n"
+    invite_text += f"🌍 Серверы по всему миру\n"
+    invite_text += f"🔒 Надежная защита\n\n"
+    invite_text += f"👇 Переходи по ссылке:\n{referral_link}"
+    
+    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+        [
+            types.InlineKeyboardButton(
+                text="📤 Поделиться",
+                switch_inline_query=invite_text
+            )
+        ],
+        [
+            types.InlineKeyboardButton(
+                text="📋 Скопировать ссылку",
+                callback_data="copy_referral_link"
+            )
+        ],
+        [
+            types.InlineKeyboardButton(
+                text=texts.BACK,
+                callback_data="menu_referrals"
+            )
+        ]
+    ])
+    
+    await callback.message.edit_text(
+        f"📝 <b>Приглашение создано!</b>\n\n"
+        f"Используйте кнопку ниже для отправки приглашения или скопируйте текст:\n\n"
+        f"<code>{invite_text}</code>",
+        reply_markup=keyboard,
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+async def copy_referral_link(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    
+    bot_username = (await callback.bot.get_me()).username
+    referral_link = f"https://t.me/{bot_username}?start={db_user.referral_code}"
+    
+    await callback.answer(
+        f"Ссылка скопирована: {referral_link}",
+        show_alert=True
+    )
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_referral_info,
+        F.data == "menu_referrals"
+    )
+    
+    dp.callback_query.register(
+        create_invite_message,
+        F.data == "referral_create_invite"
+    )
+    
+    dp.callback_query.register(
+        copy_referral_link,
+        F.data == "copy_referral_link"
+    )

app/handlers/start.py

@@ -0,0 +1,507 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.filters import Command, StateFilter
+from aiogram.fsm.context import FSMContext
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.states import RegistrationStates
+from app.database.crud.user import (
+    get_user_by_telegram_id, create_user, get_user_by_referral_code
+)
+from app.keyboards.inline import (
+    get_rules_keyboard, get_main_menu_keyboard
+)
+from app.localization.texts import get_texts
+from app.services.referral_service import process_referral_registration
+from app.utils.user_utils import generate_unique_referral_code
+
+logger = logging.getLogger(__name__)
+
+
+async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession):
+    logger.info(f"🚀 START: Обработка /start от {message.from_user.id}")
+    
+    referral_code = None
+    if len(message.text.split()) > 1:
+        potential_code = message.text.split()[1]
+        referral_code = potential_code
+        logger.info(f"🔎 Найден реферальный код: {referral_code}")
+    
+    if referral_code:
+        await state.set_data({'referral_code': referral_code})
+    
+    user = await get_user_by_telegram_id(db, message.from_user.id)
+    
+    if user:
+        logger.info(f"✅ Пользователь найден: {user.telegram_id}")
+        texts = get_texts(user.language)
+        
+        if referral_code and not user.referred_by_id:
+            await message.answer("ℹ️ Вы уже зарегистрированы в системе. Реферальная ссылка не может быть применена.")
+        
+        has_active_subscription = user.subscription is not None
+        subscription_is_active = False
+        
+        if user.subscription:
+            subscription_is_active = user.subscription.is_active
+        
+        await message.answer(
+            texts.MAIN_MENU.format(
+                user_name=user.full_name,
+                balance=texts.format_price(user.balance_kopeks),
+                subscription_status=_get_subscription_status(user, texts)
+            ),
+            reply_markup=get_main_menu_keyboard(
+                language=user.language,
+                is_admin=settings.is_admin(user.telegram_id),
+                has_had_paid_subscription=user.has_had_paid_subscription,
+                has_active_subscription=has_active_subscription,
+                subscription_is_active=subscription_is_active
+            )
+        )
+    else:
+        logger.info(f"🆕 Новый пользователь, начинаем регистрацию")
+        
+        language = 'ru'
+        texts = get_texts(language)
+        
+        data = await state.get_data() or {}
+        data['language'] = language
+        await state.set_data(data)
+        logger.info(f"💾 Установлен русский язык по умолчанию")
+        
+        await message.answer(
+            texts.RULES_TEXT,
+            reply_markup=get_rules_keyboard(language)
+        )
+        logger.info(f"📋 Правила отправлены")
+        
+        await state.set_state(RegistrationStates.waiting_for_rules_accept)
+        current_state = await state.get_state()
+        logger.info(f"📊 Установлено состояние: {current_state}")
+
+
+async def process_rules_accept(
+    callback: types.CallbackQuery, 
+    state: FSMContext, 
+    db: AsyncSession
+):
+    
+    logger.info(f"📋 RULES: Начало обработки правил")
+    logger.info(f"📊 Callback data: {callback.data}")
+    logger.info(f"👤 User: {callback.from_user.id}")
+    
+    current_state = await state.get_state()
+    logger.info(f"📊 Текущее состояние: {current_state}")
+    
+    try:
+        await callback.answer()
+        
+        data = await state.get_data()
+        language = data.get('language', 'ru')
+        texts = get_texts(language)
+        
+        if callback.data == 'rules_accept':
+            logger.info(f"✅ Правила приняты пользователем {callback.from_user.id}")
+            
+            try:
+                await callback.message.delete()
+                logger.info(f"🗑️ Сообщение с правилами удалено")
+            except Exception as e:
+                logger.warning(f"⚠️ Не удалось удалить сообщение с правилами: {e}")
+                try:
+                    await callback.message.edit_text(
+                        "✅ Правила приняты! Завершаем регистрацию...",
+                        reply_markup=None
+                    )
+                except:
+                    pass
+            
+            if data.get('referral_code'):
+                logger.info(f"🎫 Найден реферальный код из deep link: {data['referral_code']}")
+                
+                referrer = await get_user_by_referral_code(db, data['referral_code'])
+                if referrer:
+                    data['referrer_id'] = referrer.id
+                    await state.set_data(data)
+                    logger.info(f"✅ Референс найден: {referrer.id}")
+                
+                await complete_registration_from_callback(callback, state, db)
+            else:
+                try:
+                    await callback.message.answer(
+                        "У вас есть реферальный код? Введите его или нажмите 'Пропустить'",
+                        reply_markup=get_referral_code_keyboard(language)
+                    )
+                    await state.set_state(RegistrationStates.waiting_for_referral_code)
+                    logger.info(f"🔍 Ожидание ввода реферального кода")
+                except Exception as e:
+                    logger.error(f"Ошибка при показе вопроса о реферальном коде: {e}")
+                    await complete_registration_from_callback(callback, state, db)
+                    
+        else:
+            logger.info(f"❌ Правила отклонены пользователем {callback.from_user.id}")
+            
+            try:
+                rules_required_text = getattr(texts, 'RULES_REQUIRED', 
+                                             "Для использования бота необходимо принять правила сервиса.")
+                await callback.message.edit_text(
+                    rules_required_text,
+                    reply_markup=get_rules_keyboard(language)
+                )
+            except Exception as e:
+                logger.error(f"Ошибка при показе сообщения об отклонении правил: {e}")
+                await callback.message.edit_text(
+                    "Для использования бота необходимо принять правила сервиса.",
+                    reply_markup=get_rules_keyboard(language)
+                )
+        
+        logger.info(f"✅ Правила обработаны для пользователя {callback.from_user.id}")
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка обработки правил: {e}", exc_info=True)
+        await callback.answer("❌ Произошла ошибка. Попробуйте еще раз.", show_alert=True)
+        
+        try:
+            data = await state.get_data()
+            language = data.get('language', 'ru')
+            await callback.message.answer(
+                "Произошла ошибка. Попробуйте принять правила еще раз:",
+                reply_markup=get_rules_keyboard(language)
+            )
+            await state.set_state(RegistrationStates.waiting_for_rules_accept)
+        except:
+            pass
+
+
+async def process_referral_code_input(
+    message: types.Message, 
+    state: FSMContext, 
+    db: AsyncSession
+):
+    
+    logger.info(f"🎫 REFERRAL: Обработка реферального кода: {message.text}")
+    
+    data = await state.get_data()
+    language = data.get('language', 'ru')
+    texts = get_texts(language)
+    
+    referral_code = message.text.strip()
+    
+    referrer = await get_user_by_referral_code(db, referral_code)
+    if referrer:
+        data['referrer_id'] = referrer.id
+        await state.set_data(data)
+        await message.answer("✅ Реферальный код применен!")
+        logger.info(f"✅ Реферальный код применен")
+    else:
+        await message.answer("❌ Неверный реферальный код")
+        logger.info(f"❌ Неверный реферальный код")
+        return
+    
+    await complete_registration(message, state, db)
+
+
+async def process_referral_code_skip(
+    callback: types.CallbackQuery, 
+    state: FSMContext, 
+    db: AsyncSession
+):
+    
+    logger.info(f"⭐️ SKIP: Пропуск реферального кода от пользователя {callback.from_user.id}")
+    await callback.answer()
+    
+    try:
+        await callback.message.delete()
+        logger.info(f"🗑️ Сообщение с вопросом о реферальном коде удалено")
+    except Exception as e:
+        logger.warning(f"⚠️ Не удалось удалить сообщение с вопросом о реферальном коде: {e}")
+        try:
+            await callback.message.edit_text(
+                "✅ Завершаем регистрацию...",
+                reply_markup=None
+            )
+        except:
+            pass
+    
+    await complete_registration_from_callback(callback, state, db)
+
+
+async def complete_registration_from_callback(
+    callback: types.CallbackQuery,
+    state: FSMContext, 
+    db: AsyncSession
+):
+    
+    logger.info(f"🏁 COMPLETE: Завершение регистрации для пользователя {callback.from_user.id}")
+    
+    existing_user = await get_user_by_telegram_id(db, callback.from_user.id)
+    if existing_user:
+        logger.warning(f"⚠️ Пользователь {callback.from_user.id} уже существует! Показываем главное меню.")
+        texts = get_texts(existing_user.language)
+        
+        has_active_subscription = existing_user.subscription is not None
+        subscription_is_active = False
+        
+        if existing_user.subscription:
+            subscription_is_active = existing_user.subscription.is_active
+        
+        user_name = existing_user.full_name
+        balance_kopeks = existing_user.balance_kopeks
+        
+        try:
+            await callback.message.answer(
+                texts.MAIN_MENU.format(
+                    user_name=user_name,
+                    balance=texts.format_price(balance_kopeks),
+                    subscription_status=_get_subscription_status(existing_user, texts)
+                ),
+                reply_markup=get_main_menu_keyboard(
+                    language=existing_user.language,
+                    is_admin=settings.is_admin(existing_user.telegram_id),
+                    has_had_paid_subscription=existing_user.has_had_paid_subscription,
+                    has_active_subscription=has_active_subscription,
+                    subscription_is_active=subscription_is_active
+                )
+            )
+        except Exception as e:
+            logger.error(f"Ошибка при показе главного меню существующему пользователю: {e}")
+            await callback.message.answer(f"Добро пожаловать, {user_name}!")
+        
+        await state.clear()
+        return
+    
+    data = await state.get_data()
+    language = data.get('language', 'ru')
+    texts = get_texts(language)
+    
+    referrer_id = data.get('referrer_id')
+    if not referrer_id and data.get('referral_code'):
+        referrer = await get_user_by_referral_code(db, data['referral_code'])
+        if referrer:
+            referrer_id = referrer.id
+    
+    referral_code = await generate_unique_referral_code(db, callback.from_user.id)
+    
+    user = await create_user(
+        db=db,
+        telegram_id=callback.from_user.id,
+        username=callback.from_user.username,
+        first_name=callback.from_user.first_name,
+        last_name=callback.from_user.last_name,
+        language=language,
+        referred_by_id=referrer_id,
+        referral_code=referral_code 
+    )
+    
+    if referrer_id:
+        try:
+            await process_referral_registration(db, user.id, referrer_id)
+            bonus_message = f"🎉 Вы получили {settings.REFERRED_USER_REWARD/100}₽ за регистрацию по реферальной ссылке!"
+            await callback.message.answer(bonus_message)
+        except Exception as e:
+            logger.error(f"Ошибка при обработке реферальной регистрации: {e}")
+    
+    await state.clear()
+    
+    has_active_subscription = False 
+    subscription_is_active = False
+    
+    user_name = user.full_name
+    balance_kopeks = user.balance_kopeks
+    user_telegram_id = user.telegram_id
+    user_language = user.language
+    has_had_paid_subscription = user.has_had_paid_subscription
+    
+    try:
+        await callback.message.answer(
+            texts.MAIN_MENU.format(
+                user_name=user_name,
+                balance=texts.format_price(balance_kopeks),
+                subscription_status=_get_subscription_status_simple(texts)
+            ),
+            reply_markup=get_main_menu_keyboard(
+                language=user_language,
+                is_admin=settings.is_admin(user_telegram_id),
+                has_had_paid_subscription=has_had_paid_subscription,
+                has_active_subscription=has_active_subscription,
+                subscription_is_active=subscription_is_active
+            )
+        )
+        logger.info(f"✅ Главное меню отправлено для пользователя {user_telegram_id}")
+    except Exception as e:
+        logger.error(f"Ошибка при отправке главного меню: {e}")
+        try:
+            balance_rubles = balance_kopeks / 100
+            await callback.message.answer(
+                f"Добро пожаловать, {user_name}!\n"
+                f"Баланс: {balance_rubles} ₽\n"
+                f"Подписка: Нет активной подписки",
+                reply_markup=get_main_menu_keyboard(
+                    language=user_language,
+                    is_admin=settings.is_admin(user_telegram_id),
+                    has_had_paid_subscription=has_had_paid_subscription,
+                    has_active_subscription=has_active_subscription,
+                    subscription_is_active=subscription_is_active
+                )
+            )
+            logger.info(f"✅ Fallback главное меню отправлено для пользователя {user_telegram_id}")
+        except Exception as fallback_error:
+            logger.error(f"❌ Критическая ошибка при отправке fallback меню: {fallback_error}")
+            try:
+                await callback.message.answer(f"Добро пожаловать, {user_name}! Регистрация завершена.")
+                logger.info(f"✅ Простое приветствие отправлено для пользователя {user_telegram_id}")
+            except Exception as final_error:
+                logger.error(f"❌ Критическая ошибка при отправке простого сообщения: {final_error}")
+    
+    logger.info(f"✅ Зарегистрирован новый пользователь: {user_telegram_id}")
+
+
+async def complete_registration(
+    message: types.Message, 
+    state: FSMContext, 
+    db: AsyncSession
+):
+    
+    logger.info(f"🏁 COMPLETE: Завершение регистрации для пользователя {message.from_user.id}")
+    
+    data = await state.get_data()
+    language = data.get('language', 'ru')
+    texts = get_texts(language)
+    
+    referrer_id = data.get('referrer_id')
+    if not referrer_id and data.get('referral_code'):
+        referrer = await get_user_by_referral_code(db, data['referral_code'])
+        if referrer:
+            referrer_id = referrer.id
+    
+    referral_code = await generate_unique_referral_code(db, message.from_user.id)
+    
+    user = await create_user(
+        db=db,
+        telegram_id=message.from_user.id,
+        username=message.from_user.username,
+        first_name=message.from_user.first_name,
+        last_name=message.from_user.last_name,
+        language=language,
+        referred_by_id=referrer_id,
+        referral_code=referral_code
+    )
+    
+    if referrer_id:
+        try:
+            await process_referral_registration(db, user.id, referrer_id)
+            bonus_message = f"🎉 Вы получили {settings.REFERRED_USER_REWARD/100}₽ за регистрацию по реферальной ссылке!"
+            await message.answer(bonus_message)
+        except Exception as e:
+            logger.error(f"Ошибка при обработке реферальной регистрации: {e}")
+    
+    await state.clear()
+    
+    has_active_subscription = False
+    subscription_is_active = False
+    
+    user_name = user.full_name
+    balance_kopeks = user.balance_kopeks
+    user_telegram_id = user.telegram_id
+    user_language = user.language
+    has_had_paid_subscription = user.has_had_paid_subscription
+    
+    try:
+        await message.answer(
+            texts.MAIN_MENU.format(
+                user_name=user_name,
+                balance=texts.format_price(balance_kopeks),
+                subscription_status=_get_subscription_status_simple(texts)
+            ),
+            reply_markup=get_main_menu_keyboard(
+                language=user_language,
+                is_admin=settings.is_admin(user_telegram_id),
+                has_had_paid_subscription=has_had_paid_subscription,
+                has_active_subscription=has_active_subscription,
+                subscription_is_active=subscription_is_active
+            )
+        )
+        logger.info(f"✅ Главное меню отправлено для пользователя {user_telegram_id}")
+    except Exception as e:
+        logger.error(f"Ошибка при отправке главного меню: {e}")
+        try:
+            balance_rubles = balance_kopeks / 100
+            await message.answer(
+                f"Добро пожаловать, {user_name}!\n"
+                f"Баланс: {balance_rubles} ₽\n"
+                f"Подписка: Нет активной подписки",
+                reply_markup=get_main_menu_keyboard(
+                    language=user_language,
+                    is_admin=settings.is_admin(user_telegram_id),
+                    has_had_paid_subscription=has_had_paid_subscription,
+                    has_active_subscription=has_active_subscription,
+                    subscription_is_active=subscription_is_active
+                )
+            )
+            logger.info(f"✅ Fallback главное меню отправлено для пользователя {user_telegram_id}")
+        except Exception as fallback_error:
+            logger.error(f"❌ Критическая ошибка при отправке fallback меню: {fallback_error}")
+            try:
+                await message.answer(f"Добро пожаловать, {user_name}! Регистрация завершена.")
+                logger.info(f"✅ Простое приветствие отправлено для пользователя {user_telegram_id}")
+            except:
+                pass
+    
+    logger.info(f"✅ Зарегистрирован новый пользователь: {user_telegram_id}")
+
+
+def _get_subscription_status(user, texts):
+    if user.subscription and user.subscription.is_active:
+        return getattr(texts, 'SUBSCRIPTION_ACTIVE', 'Активна')
+    return getattr(texts, 'SUBSCRIPTION_NONE', 'Нет активной подписки')
+
+
+def _get_subscription_status_simple(texts):
+    return getattr(texts, 'SUBSCRIPTION_NONE', 'Нет активной подписки')
+
+
+def get_referral_code_keyboard(language: str):
+    from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+    
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(
+            text="⭐️ Пропустить",
+            callback_data="referral_skip"
+        )]
+    ])
+
+
+def register_handlers(dp: Dispatcher):
+    
+    logger.info("🔧 === НАЧАЛО регистрации обработчиков start.py ===")
+    
+    dp.message.register(
+        cmd_start,
+        Command("start")
+    )
+    logger.info("✅ Зарегистрирован cmd_start")
+    
+    dp.callback_query.register(
+        process_rules_accept,
+        F.data.in_(["rules_accept", "rules_decline"]),
+        StateFilter(RegistrationStates.waiting_for_rules_accept)
+    )
+    logger.info("✅ Зарегистрирован process_rules_accept")
+    
+    dp.callback_query.register(
+        process_referral_code_skip,
+        F.data == "referral_skip",
+        StateFilter(RegistrationStates.waiting_for_referral_code)
+    )
+    logger.info("✅ Зарегистрирован process_referral_code_skip")
+    
+    dp.message.register(
+        process_referral_code_input,
+        StateFilter(RegistrationStates.waiting_for_referral_code)
+    )
+    logger.info("✅ Зарегистрирован process_referral_code_input")
+    
+    logger.info("🔧 === КОНЕЦ регистрации обработчиков start.py ===")

app/handlers/support.py

@@ -0,0 +1,32 @@
+import logging
+from aiogram import Dispatcher, types, F
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.keyboards.inline import get_support_keyboard
+from app.localization.texts import get_texts
+
+logger = logging.getLogger(__name__)
+
+
+async def show_support_info(
+    callback: types.CallbackQuery,
+    db_user: User
+):
+    
+    texts = get_texts(db_user.language)
+    
+    await callback.message.edit_text(
+        texts.SUPPORT_INFO,
+        reply_markup=get_support_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_support_info,
+        F.data == "menu_support"
+    )

app/handlers/webhooks.py

@@ -0,0 +1,139 @@
+import logging
+from aiogram import types
+from aiohttp import web
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.database import get_db
+from app.database.crud.user import get_user_by_id, add_user_balance
+from app.database.crud.transaction import create_transaction, get_transaction_by_external_id
+from app.database.models import TransactionType, PaymentMethod
+from app.external.tribute import TributeService
+
+logger = logging.getLogger(__name__)
+
+
+async def tribute_webhook(request):
+    try:
+        signature = request.headers.get('X-Signature', '')
+        payload = await request.text()
+        
+        tribute_service = TributeService()
+        
+        if not tribute_service.verify_webhook_signature(payload, signature):
+            logger.warning("Неверная подпись Tribute webhook")
+            return web.Response(status=400, text="Invalid signature")
+        
+        webhook_data = await request.json()
+        processed_data = await tribute_service.process_webhook(webhook_data)
+        
+        if not processed_data:
+            logger.error("Ошибка обработки Tribute webhook")
+            return web.Response(status=400, text="Invalid webhook data")
+        
+        async for db in get_db():
+            try:
+                existing_transaction = await get_transaction_by_external_id(
+                    db, processed_data['payment_id'], PaymentMethod.TRIBUTE
+                )
+                
+                if existing_transaction:
+                    logger.info(f"Платеж {processed_data['payment_id']} уже обработан")
+                    return web.Response(status=200, text="Already processed")
+                
+                if processed_data['status'] == 'completed':
+                    user = await get_user_by_id(db, processed_data['user_id'])
+                    
+                    if user:
+                        await add_user_balance(
+                            db, user, processed_data['amount_kopeks'],
+                            f"Пополнение через Tribute: {processed_data['payment_id']}"
+                        )
+                        
+                        await create_transaction(
+                            db=db,
+                            user_id=user.id,
+                            type=TransactionType.DEPOSIT,
+                            amount_kopeks=processed_data['amount_kopeks'],
+                            description=f"Пополнение через Tribute",
+                            payment_method=PaymentMethod.TRIBUTE,
+                            external_id=processed_data['payment_id']
+                        )
+                        
+                        logger.info(f"✅ Обработан Tribute платеж: {processed_data['payment_id']}")
+                
+                return web.Response(status=200, text="OK")
+                
+            except Exception as e:
+                logger.error(f"Ошибка обработки Tribute webhook: {e}")
+                await db.rollback()
+                return web.Response(status=500, text="Internal error")
+            finally:
+                break
+        
+    except Exception as e:
+        logger.error(f"Ошибка в Tribute webhook: {e}")
+        return web.Response(status=500, text="Internal error")
+
+
+async def handle_successful_payment(message: types.Message):
+    try:
+        payment = message.successful_payment
+        
+        payload_parts = payment.invoice_payload.split('_')
+        if len(payload_parts) >= 3 and payload_parts[0] == 'balance':
+            user_id = int(payload_parts[1])
+            amount_kopeks = int(payload_parts[2])
+            
+            async for db in get_db():
+                try:
+                    existing_transaction = await get_transaction_by_external_id(
+                        db, payment.telegram_payment_charge_id, PaymentMethod.TELEGRAM_STARS
+                    )
+                    
+                    if existing_transaction:
+                        logger.info(f"Stars платеж {payment.telegram_payment_charge_id} уже обработан")
+                        return
+                    
+                    user = await get_user_by_id(db, user_id)
+                    
+                    if user:
+                        await add_user_balance(
+                            db, user, amount_kopeks,
+                            f"Пополнение через Telegram Stars"
+                        )
+                        
+                        await create_transaction(
+                            db=db,
+                            user_id=user.id,
+                            type=TransactionType.DEPOSIT,
+                            amount_kopeks=amount_kopeks,
+                            description=f"Пополнение через Telegram Stars",
+                            payment_method=PaymentMethod.TELEGRAM_STARS,
+                            external_id=payment.telegram_payment_charge_id
+                        )
+                        
+                        await message.answer(
+                            f"✅ Баланс успешно пополнен на {settings.format_price(amount_kopeks)}!"
+                        )
+                        
+                        logger.info(f"✅ Обработан Stars платеж: {payment.telegram_payment_charge_id}")
+                
+                except Exception as e:
+                    logger.error(f"Ошибка обработки Stars платежа: {e}")
+                    await db.rollback()
+                finally:
+                    break
+        
+    except Exception as e:
+        logger.error(f"Ошибка в обработчике Stars платежа: {e}")
+
+
+async def handle_pre_checkout_query(pre_checkout_query: types.PreCheckoutQuery):
+    try:
+        await pre_checkout_query.answer(ok=True)
+        logger.info(f"Pre-checkout query принят: {pre_checkout_query.id}")
+        
+    except Exception as e:
+        logger.error(f"Ошибка в pre-checkout query: {e}")
+        await pre_checkout_query.answer(ok=False, error_message="Ошибка обработки платежа")

app/keyboards/admin.py

@@ -0,0 +1,563 @@
+from typing import List, Optional
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+from app.localization.texts import get_texts
+
+
+def get_admin_main_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text=texts.ADMIN_USERS, callback_data="admin_users"),
+            InlineKeyboardButton(text=texts.ADMIN_SUBSCRIPTIONS, callback_data="admin_subscriptions")
+        ],
+        [
+            InlineKeyboardButton(text=texts.ADMIN_PROMOCODES, callback_data="admin_promocodes"),
+            InlineKeyboardButton(text=texts.ADMIN_MESSAGES, callback_data="admin_messages")
+        ],
+        [
+            InlineKeyboardButton(text=texts.ADMIN_MONITORING, callback_data="admin_monitoring"),
+            InlineKeyboardButton(text=texts.ADMIN_REFERRALS, callback_data="admin_referrals")
+        ],
+        [
+            InlineKeyboardButton(text=texts.ADMIN_RULES, callback_data="admin_rules"),
+            InlineKeyboardButton(text=texts.ADMIN_REMNAWAVE, callback_data="admin_remnawave")
+        ],
+        [
+            InlineKeyboardButton(text=texts.ADMIN_STATISTICS, callback_data="admin_statistics")
+        ],
+        [
+            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+        ]
+    ])
+
+
+def get_admin_users_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="👥 Все пользователи", callback_data="admin_users_list"),
+            InlineKeyboardButton(text="🔍 Поиск", callback_data="admin_users_search")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_users_stats"),
+            InlineKeyboardButton(text="🗑️ Неактивные", callback_data="admin_users_inactive")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_admin_subscriptions_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="📱 Все подписки", callback_data="admin_subs_list"),
+            InlineKeyboardButton(text="⏰ Истекающие", callback_data="admin_subs_expiring")
+        ],
+        [
+            InlineKeyboardButton(text="⚙️ Настройки цен", callback_data="admin_subs_pricing"),
+            InlineKeyboardButton(text="🌍 Управление странами", callback_data="admin_subs_countries")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_subs_stats")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_admin_promocodes_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="🎫 Все промокоды", callback_data="admin_promo_list"),
+            InlineKeyboardButton(text="➕ Создать", callback_data="admin_promo_create")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_promo_stats")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_promocode_management_keyboard(promo_id: int, language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="✏️ Редактировать", callback_data=f"promo_edit_{promo_id}"),
+            InlineKeyboardButton(text="🔄 Статус", callback_data=f"promo_toggle_{promo_id}")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data=f"promo_stats_{promo_id}"),
+            InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"promo_delete_{promo_id}")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ К списку", callback_data="admin_promo_list")
+        ]
+    ])
+
+
+def get_admin_messages_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="📨 Всем пользователям", callback_data="admin_msg_all"),
+            InlineKeyboardButton(text="🎯 По подпискам", callback_data="admin_msg_by_sub")
+        ],
+        [
+            InlineKeyboardButton(text="🔍 По критериям", callback_data="admin_msg_custom"),
+            InlineKeyboardButton(text="📋 История", callback_data="admin_msg_history")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_admin_monitoring_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="▶️ Запустить", callback_data="admin_mon_start"),
+            InlineKeyboardButton(text="⏸️ Остановить", callback_data="admin_mon_stop")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статус", callback_data="admin_mon_status"),
+            InlineKeyboardButton(text="📋 Логи", callback_data="admin_mon_logs")
+        ],
+        [
+            InlineKeyboardButton(text="⚙️ Настройки", callback_data="admin_mon_settings")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_admin_remnawave_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="📊 Системная статистика", callback_data="admin_rw_system"),
+            InlineKeyboardButton(text="🖥️ Управление нодами", callback_data="admin_rw_nodes")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Синхронизация", callback_data="admin_rw_sync"),
+            InlineKeyboardButton(text="🌍 Управление сквадами", callback_data="admin_rw_squads")
+        ],
+        [
+            InlineKeyboardButton(text="📈 Трафик", callback_data="admin_rw_traffic")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_admin_statistics_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="👥 Пользователи", callback_data="admin_stats_users"),
+            InlineKeyboardButton(text="📱 Подписки", callback_data="admin_stats_subs")
+        ],
+        [
+            InlineKeyboardButton(text="💰 Доходы", callback_data="admin_stats_revenue"),
+            InlineKeyboardButton(text="🤝 Рефералы", callback_data="admin_stats_referrals")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Общая сводка", callback_data="admin_stats_summary")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_panel")
+        ]
+    ])
+
+
+def get_user_management_keyboard(user_id: int, language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="💰 Баланс", callback_data=f"admin_user_balance_{user_id}"),
+            InlineKeyboardButton(text="📱 Подписка", callback_data=f"admin_user_sub_{user_id}")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data=f"admin_user_stats_{user_id}"),
+            InlineKeyboardButton(text="📋 Транзакции", callback_data=f"admin_user_trans_{user_id}")
+        ],
+        [
+            InlineKeyboardButton(text="🚫 Заблокировать", callback_data=f"admin_user_block_{user_id}"),
+            InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_user_delete_{user_id}")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users_list")
+        ]
+    ])
+
+
+def get_confirmation_keyboard(
+    confirm_action: str,
+    cancel_action: str = "admin_panel",
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text=texts.YES, callback_data=confirm_action),
+            InlineKeyboardButton(text=texts.NO, callback_data=cancel_action)
+        ]
+    ])
+
+
+def get_promocode_type_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="💰 Баланс", callback_data="promo_type_balance"),
+            InlineKeyboardButton(text="📅 Дни подписки", callback_data="promo_type_days")
+        ],
+        [
+            InlineKeyboardButton(text="🎁 Триал", callback_data="promo_type_trial")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_promocodes")
+        ]
+    ])
+
+
+def get_promocode_list_keyboard(promocodes: list, page: int, total_pages: int, language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = []
+    
+    for promo in promocodes:
+        status_emoji = "✅" if promo.is_active else "❌"
+        type_emoji = {"balance": "💰", "subscription_days": "📅", "trial_subscription": "🎁"}.get(promo.type, "🎫")
+        
+        keyboard.append([
+            InlineKeyboardButton(
+                text=f"{status_emoji} {type_emoji} {promo.code}",
+                callback_data=f"promo_manage_{promo.id}"
+            )
+        ])
+    
+    if total_pages > 1:
+        pagination_row = []
+        
+        if page > 1:
+            pagination_row.append(
+                InlineKeyboardButton(text="⬅️", callback_data=f"admin_promo_list_page_{page - 1}")
+            )
+        
+        pagination_row.append(
+            InlineKeyboardButton(text=f"{page}/{total_pages}", callback_data="current_page")
+        )
+        
+        if page < total_pages:
+            pagination_row.append(
+                InlineKeyboardButton(text="➡️", callback_data=f"admin_promo_list_page_{page + 1}")
+            )
+        
+        keyboard.append(pagination_row)
+    
+    keyboard.extend([
+        [InlineKeyboardButton(text="➕ Создать", callback_data="admin_promo_create")],
+        [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_promocodes")]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_broadcast_target_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="👥 Всем", callback_data="broadcast_all"),
+            InlineKeyboardButton(text="📱 С подпиской", callback_data="broadcast_active")
+        ],
+        [
+            InlineKeyboardButton(text="🎁 Триал", callback_data="broadcast_trial"),
+            InlineKeyboardButton(text="❌ Без подписки", callback_data="broadcast_no_sub")
+        ],
+        [
+            InlineKeyboardButton(text="⏰ Истекающие", callback_data="broadcast_expiring")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_messages")
+        ]
+    ])
+
+
+def get_custom_criteria_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="📅 Сегодня", callback_data="criteria_today"),
+            InlineKeyboardButton(text="📅 За неделю", callback_data="criteria_week")
+        ],
+        [
+            InlineKeyboardButton(text="📅 За месяц", callback_data="criteria_month"),
+            InlineKeyboardButton(text="⚡ Активные сегодня", callback_data="criteria_active_today")
+        ],
+        [
+            InlineKeyboardButton(text="💤 Неактивные 7+ дней", callback_data="criteria_inactive_week"),
+            InlineKeyboardButton(text="💤 Неактивные 30+ дней", callback_data="criteria_inactive_month")
+        ],
+        [
+            InlineKeyboardButton(text="🤝 Через рефералов", callback_data="criteria_referrals"),
+            InlineKeyboardButton(text="🎫 Использовали промокоды", callback_data="criteria_promocodes")
+        ],
+        [
+            InlineKeyboardButton(text="🎯 Прямая регистрация", callback_data="criteria_direct")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_messages")
+        ]
+    ])
+
+
+def get_broadcast_history_keyboard(page: int, total_pages: int, language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = []
+    
+    if total_pages > 1:
+        pagination_row = []
+        
+        if page > 1:
+            pagination_row.append(
+                InlineKeyboardButton(text="⬅️", callback_data=f"admin_msg_history_page_{page - 1}")
+            )
+        
+        pagination_row.append(
+            InlineKeyboardButton(text=f"{page}/{total_pages}", callback_data="current_page")
+        )
+        
+        if page < total_pages:
+            pagination_row.append(
+                InlineKeyboardButton(text="➡️", callback_data=f"admin_msg_history_page_{page + 1}")
+            )
+        
+        keyboard.append(pagination_row)
+    
+    keyboard.extend([
+        [InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_msg_history")],
+        [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_messages")]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_sync_options_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = [
+        [InlineKeyboardButton(text="🔄 Полная синхронизация", callback_data="sync_all_users")],
+        [InlineKeyboardButton(text="🆕 Только новые", callback_data="sync_new_users")],
+        [InlineKeyboardButton(text="📈 Обновить данные", callback_data="sync_update_data")],
+        [
+            InlineKeyboardButton(text="🔍 Валидация", callback_data="sync_validate"),
+            InlineKeyboardButton(text="🧹 Очистка", callback_data="sync_cleanup")
+        ],
+        [InlineKeyboardButton(text="💡 Рекомендации", callback_data="sync_recommendations")],
+        [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+    ]
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_sync_confirmation_keyboard(sync_type: str, language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = [
+        [InlineKeyboardButton(text="✅ Подтвердить", callback_data=f"confirm_{sync_type}")],
+        [InlineKeyboardButton(text="❌ Отмена", callback_data="admin_rw_sync")]
+    ]
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_sync_result_keyboard(sync_type: str, has_errors: bool = False, language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = []
+    
+    if has_errors:
+        keyboard.append([
+            InlineKeyboardButton(text="🔄 Повторить", callback_data=f"sync_{sync_type}")
+        ])
+    
+    if sync_type != "all_users":
+        keyboard.append([
+            InlineKeyboardButton(text="🔄 Полная синхронизация", callback_data="sync_all_users")
+        ])
+    
+    keyboard.extend([
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_rw_system"),
+            InlineKeyboardButton(text="🔍 Валидация", callback_data="sync_validate")
+        ],
+        [InlineKeyboardButton(text="⬅️ К синхронизации", callback_data="admin_rw_sync")],
+        [InlineKeyboardButton(text="🏠 В главное меню", callback_data="admin_remnawave")]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+
+def get_period_selection_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="📅 Сегодня", callback_data="period_today"),
+            InlineKeyboardButton(text="📅 Вчера", callback_data="period_yesterday")
+        ],
+        [
+            InlineKeyboardButton(text="📅 Неделя", callback_data="period_week"),
+            InlineKeyboardButton(text="📅 Месяц", callback_data="period_month")
+        ],
+        [
+            InlineKeyboardButton(text="📅 Все время", callback_data="period_all")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_statistics")
+        ]
+    ])
+
+
+def get_node_management_keyboard(node_uuid: str, language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="▶️ Включить", callback_data=f"node_enable_{node_uuid}"),
+            InlineKeyboardButton(text="⏸️ Отключить", callback_data=f"node_disable_{node_uuid}")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Перезагрузить", callback_data=f"node_restart_{node_uuid}"),
+            InlineKeyboardButton(text="📊 Статистика", callback_data=f"node_stats_{node_uuid}")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_rw_nodes")
+        ]
+    ])
+
+def get_squad_management_keyboard(squad_uuid: str, language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="👥 Добавить всех пользователей", callback_data=f"squad_add_users_{squad_uuid}"),
+        ],
+        [
+            InlineKeyboardButton(text="❌ Удалить всех пользователей", callback_data=f"squad_remove_users_{squad_uuid}"),
+        ],
+        [
+            InlineKeyboardButton(text="✏️ Редактировать", callback_data=f"squad_edit_{squad_uuid}"),
+            InlineKeyboardButton(text="🗑️ Удалить сквад", callback_data=f"squad_delete_{squad_uuid}")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_rw_squads")
+        ]
+    ])
+
+def get_squad_edit_keyboard(squad_uuid: str, language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="🔧 Изменить инбаунды", callback_data=f"squad_edit_inbounds_{squad_uuid}"),
+        ],
+        [
+            InlineKeyboardButton(text="✏️ Переименовать", callback_data=f"squad_rename_{squad_uuid}"),
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад к сквадам", callback_data=f"admin_squad_manage_{squad_uuid}")
+        ]
+    ])
+
+def get_monitoring_keyboard() -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="▶️ Запустить", callback_data="admin_mon_start"),
+            InlineKeyboardButton(text="⏹️ Остановить", callback_data="admin_mon_stop")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Принудительная проверка", callback_data="admin_mon_force_check"),
+            InlineKeyboardButton(text="📝 Логи", callback_data="admin_mon_logs")
+        ],
+        [
+            InlineKeyboardButton(text="🧪 Тест уведомлений", callback_data="admin_mon_test_notifications"),
+            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_mon_statistics")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад в админку", callback_data="admin_panel")
+        ]
+    ])
+
+def get_monitoring_logs_keyboard() -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="🔄 Обновить", callback_data="admin_mon_logs"),
+            InlineKeyboardButton(text="🗑️ Очистить старые", callback_data="admin_mon_clear_logs")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_monitoring")
+        ]
+    ])
+
+def get_admin_servers_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="📋 Список серверов", callback_data="admin_servers_list"),
+            InlineKeyboardButton(text="🔄 Синхронизация", callback_data="admin_servers_sync")
+        ],
+        [
+            InlineKeyboardButton(text="➕ Добавить сервер", callback_data="admin_servers_add"),
+            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_servers_stats")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_subscriptions")
+        ]
+    ])
+
+
+def get_server_edit_keyboard(server_id: int, is_available: bool, language: str = "ru") -> InlineKeyboardMarkup:
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="✏️ Название", callback_data=f"admin_server_edit_name_{server_id}"),
+            InlineKeyboardButton(text="💰 Цена", callback_data=f"admin_server_edit_price_{server_id}")
+        ],
+        [
+            InlineKeyboardButton(text="🌍 Страна", callback_data=f"admin_server_edit_country_{server_id}"),
+            InlineKeyboardButton(text="👥 Лимит", callback_data=f"admin_server_edit_limit_{server_id}")
+        ],
+        [
+            InlineKeyboardButton(text="📝 Описание", callback_data=f"admin_server_edit_desc_{server_id}")
+        ],
+        [
+            InlineKeyboardButton(
+                text="❌ Отключить" if is_available else "✅ Включить",
+                callback_data=f"admin_server_toggle_{server_id}"
+            )
+        ],
+        [
+            InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_server_delete_{server_id}"),
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_servers_list")
+        ]
+    ])
+
+
+def get_admin_pagination_keyboard(
+    current_page: int,
+    total_pages: int,
+    callback_prefix: str,
+    back_callback: str = "admin_panel",
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    keyboard = []
+    
+    if total_pages > 1:
+        row = []
+        
+        if current_page > 1:
+            row.append(InlineKeyboardButton(
+                text="⬅️",
+                callback_data=f"{callback_prefix}_page_{current_page - 1}"
+            ))
+        
+        row.append(InlineKeyboardButton(
+            text=f"{current_page}/{total_pages}",
+            callback_data="current_page"
+        ))
+        
+        if current_page < total_pages:
+            row.append(InlineKeyboardButton(
+                text="➡️",
+                callback_data=f"{callback_prefix}_page_{current_page + 1}"
+            ))
+        
+        keyboard.append(row)
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data=back_callback)
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)

app/keyboards/inline.py

@@ -0,0 +1,737 @@
+from typing import List, Optional
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+from app.config import settings, PERIOD_PRICES, TRAFFIC_PRICES
+from app.localization.texts import get_texts
+
+
+def get_rules_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text=texts.RULES_ACCEPT, callback_data="rules_accept"),
+            InlineKeyboardButton(text=texts.RULES_DECLINE, callback_data="rules_decline")
+        ]
+    ])
+
+
+def get_main_menu_keyboard(
+    language: str = "ru", 
+    is_admin: bool = False,
+    has_had_paid_subscription: bool = False,
+    has_active_subscription: bool = False,
+    subscription_is_active: bool = False 
+) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    
+    if settings.DEBUG:
+        print(f"DEBUG KEYBOARD: language={language}, is_admin={is_admin}, has_had_paid={has_had_paid_subscription}, has_active={has_active_subscription}, sub_active={subscription_is_active}")
+    
+    keyboard = [
+        [
+            InlineKeyboardButton(text=texts.MENU_BALANCE, callback_data="menu_balance"),
+            InlineKeyboardButton(text=texts.MENU_SUBSCRIPTION, callback_data="menu_subscription")
+        ]
+    ]
+    
+    
+    show_trial = not has_had_paid_subscription and not has_active_subscription
+    
+    show_buy = not has_active_subscription or not subscription_is_active
+    
+    subscription_buttons = []
+    
+    if show_trial:
+        subscription_buttons.append(
+            InlineKeyboardButton(text=texts.MENU_TRIAL, callback_data="menu_trial")
+        )
+    
+    if show_buy:
+        subscription_buttons.append(
+            InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="menu_buy")
+        )
+    
+    if subscription_buttons:
+        if len(subscription_buttons) == 2:
+            keyboard.append(subscription_buttons)
+        else:
+            keyboard.append([subscription_buttons[0]])
+    
+    keyboard.extend([
+        [
+            InlineKeyboardButton(text=texts.MENU_PROMOCODE, callback_data="menu_promocode"),
+            InlineKeyboardButton(text=texts.MENU_REFERRALS, callback_data="menu_referrals")
+        ],
+        [
+            InlineKeyboardButton(text=texts.MENU_SUPPORT, callback_data="menu_support"),
+            InlineKeyboardButton(text=texts.MENU_RULES, callback_data="menu_rules")
+        ]
+    ])
+    
+    if settings.DEBUG:
+        print(f"DEBUG KEYBOARD: is_admin={is_admin}, добавляем админ кнопку: {is_admin}")
+    
+    if is_admin:
+        if settings.DEBUG:
+            print("DEBUG KEYBOARD: Админ кнопка ДОБАВЛЕНА!")
+        keyboard.append([
+            InlineKeyboardButton(text=texts.MENU_ADMIN, callback_data="admin_panel")
+        ])
+    else:
+        if settings.DEBUG:
+            print("DEBUG KEYBOARD: Админ кнопка НЕ добавлена")
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_back_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")]
+    ])
+
+
+def get_subscription_keyboard(
+    language: str = "ru", 
+    has_subscription: bool = False, 
+    is_trial: bool = False,
+    subscription=None
+) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    if has_subscription:
+        if subscription and subscription.subscription_url:
+            keyboard.append([
+                InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")
+            ])
+        
+        if is_trial:
+            keyboard.append([
+                InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="subscription_upgrade")
+            ])
+        else:
+            row1 = []
+            row2 = []
+            row3 = []
+            row4 = [] 
+            
+            row1.append(InlineKeyboardButton(text="🌐 Добавить страны", callback_data="subscription_add_countries"))
+            
+            if subscription and subscription.traffic_limit_gb > 0:
+                row1.append(InlineKeyboardButton(text="📈 Добавить трафик", callback_data="subscription_add_traffic"))
+            
+            row2.append(InlineKeyboardButton(text="📱 Добавить устройства", callback_data="subscription_add_devices"))
+            
+            if subscription and subscription.days_left <= 3:
+                row2.append(InlineKeyboardButton(text="⏰ Продлить", callback_data="subscription_extend"))
+            
+            row3.append(InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="subscription_reset_traffic"))
+            
+            row3.append(InlineKeyboardButton(text="💳 Автоплатеж", callback_data="subscription_autopay"))
+            
+            row4.append(InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data="subscription_reset_devices"))
+            
+            if row1:
+                keyboard.append(row1)
+            if row2:
+                keyboard.append(row2)
+            if row3:
+                keyboard.append(row3)
+            if row4:
+                keyboard.append(row4)
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_trial_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="🎁 Активировать", callback_data="trial_activate"),
+            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+        ]
+    ])
+
+
+def get_subscription_period_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    periods = [
+        (14, texts.PERIOD_14_DAYS),
+        (30, texts.PERIOD_30_DAYS),
+        (60, texts.PERIOD_60_DAYS),
+        (90, texts.PERIOD_90_DAYS),
+        (180, texts.PERIOD_180_DAYS),
+        (360, texts.PERIOD_360_DAYS)
+    ]
+    
+    for days, text in periods:
+        keyboard.append([
+            InlineKeyboardButton(text=text, callback_data=f"period_{days}")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_traffic_packages_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    packages = [
+        (5, texts.TRAFFIC_5GB),
+        (10, texts.TRAFFIC_10GB),
+        (25, texts.TRAFFIC_25GB),
+        (50, texts.TRAFFIC_50GB),
+        (100, texts.TRAFFIC_100GB),
+        (250, texts.TRAFFIC_250GB),
+        (0, texts.TRAFFIC_UNLIMITED) 
+    ]
+    
+    for gb, text in packages:
+        keyboard.append([
+            InlineKeyboardButton(text=text, callback_data=f"traffic_{gb}")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_countries_keyboard(countries: List[dict], selected: List[str], language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    for country in countries:
+        if not country.get('is_available', True):
+            continue 
+            
+        emoji = "✅" if country['uuid'] in selected else "⚪"
+        
+        if country['price_kopeks'] > 0:
+            price_text = f" (+{texts.format_price(country['price_kopeks'])})"
+        else:
+            price_text = " (Бесплатно)"
+        
+        keyboard.append([
+            InlineKeyboardButton(
+                text=f"{emoji} {country['name']}{price_text}",
+                callback_data=f"country_{country['uuid']}"
+            )
+        ])
+    
+    if not keyboard:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="❌ Нет доступных серверов",
+                callback_data="no_servers"
+            )
+        ])
+    
+    keyboard.extend([
+        [InlineKeyboardButton(text="✅ Продолжить", callback_data="countries_continue")],
+        [InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_devices_keyboard(current: int, language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    for devices in range(1, 6): 
+        price = (devices - 1) * settings.PRICE_PER_DEVICE
+        price_text = f" (+{texts.format_price(price)})" if price > 0 else ""
+        emoji = "✅" if devices == current else "⚪"
+        
+        keyboard.append([
+            InlineKeyboardButton(
+                text=f"{emoji} {devices} устройство{_get_device_suffix(devices)}{price_text}",
+                callback_data=f"devices_{devices}"
+            )
+        ])
+    
+    keyboard.extend([
+        [InlineKeyboardButton(text="✅ Продолжить", callback_data="devices_continue")],
+        [InlineKeyboardButton(text=texts.BACK, callback_data="subscription_config_back")]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_subscription_confirm_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text=texts.CONFIRM, callback_data="subscription_confirm"),
+            InlineKeyboardButton(text=texts.CANCEL, callback_data="subscription_cancel")
+        ]
+    ])
+
+
+def get_balance_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BALANCE_HISTORY, callback_data="balance_history"),
+        InlineKeyboardButton(text=texts.BALANCE_TOP_UP, callback_data="balance_topup")
+    ])
+    
+    if settings.TRIBUTE_ENABLED:
+        keyboard.append([
+            InlineKeyboardButton(text="💳 Быстрое пополнение", callback_data="tribute_quick_pay")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BALANCE_SUPPORT_REQUEST, callback_data="balance_support")
+    ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_payment_methods_keyboard(amount_kopeks: int, language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    if settings.TELEGRAM_STARS_ENABLED:
+        keyboard.append([
+            InlineKeyboardButton(text=texts.TOP_UP_STARS, callback_data=f"pay_stars_{amount_kopeks}")
+        ])
+    
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance") 
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_referral_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text=texts.CREATE_INVITE, callback_data="referral_create_invite")
+        ],
+        [
+            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+        ]
+    ])
+
+
+def get_support_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text=texts.CONTACT_SUPPORT, url=f"https://t.me/{settings.SUPPORT_USERNAME.lstrip('@')}")
+        ],
+        [
+            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+        ]
+    ])
+
+
+def get_pagination_keyboard(
+    current_page: int,
+    total_pages: int,
+    callback_prefix: str,
+    language: str = "ru"
+) -> List[List[InlineKeyboardButton]]:
+    keyboard = []
+    
+    if total_pages > 1:
+        row = []
+        
+        if current_page > 1:
+            row.append(InlineKeyboardButton(
+                text="⬅️",
+                callback_data=f"{callback_prefix}_page_{current_page - 1}"
+            ))
+        
+        row.append(InlineKeyboardButton(
+            text=f"{current_page}/{total_pages}",
+            callback_data="current_page"
+        ))
+        
+        if current_page < total_pages:
+            row.append(InlineKeyboardButton(
+                text="➡️",
+                callback_data=f"{callback_prefix}_page_{current_page + 1}"
+            ))
+        
+        keyboard.append(row)
+    
+    return keyboard
+
+
+def _get_device_suffix(count: int) -> str:
+    if count == 1:
+        return ""
+    elif 2 <= count <= 4:
+        return "а"
+    else:
+        return ""
+
+
+def get_confirmation_keyboard(
+    confirm_data: str,
+    cancel_data: str = "cancel",
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text=texts.YES, callback_data=confirm_data),
+            InlineKeyboardButton(text=texts.NO, callback_data=cancel_data)
+        ]
+    ])
+
+
+def get_autopay_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="✅ Включить", callback_data="autopay_enable"),
+            InlineKeyboardButton(text="❌ Выключить", callback_data="autopay_disable")
+        ],
+        [
+            InlineKeyboardButton(text="⚙️ Настроить дни", callback_data="autopay_set_days")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+        ]
+    ])
+
+
+def get_autopay_days_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = []
+    
+    for days in [1, 3, 7, 14]:
+        keyboard.append([
+            InlineKeyboardButton(
+                text=f"{days} дн{_get_days_suffix(days)}",
+                callback_data=f"autopay_days_{days}"
+            )
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data="subscription_autopay")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def _get_days_suffix(days: int) -> str:
+    if days == 1:
+        return "ь"
+    elif 2 <= days <= 4:
+        return "я"
+    else:
+        return "ей"
+
+
+
+def get_extend_subscription_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    periods = [
+        (14, f"📅 14 дней - {settings.format_price(settings.PRICE_14_DAYS)}"),
+        (30, f"📅 30 дней - {settings.format_price(settings.PRICE_30_DAYS)}"),
+        (60, f"📅 60 дней - {settings.format_price(settings.PRICE_60_DAYS)}"),
+        (90, f"📅 90 дней - {settings.format_price(settings.PRICE_90_DAYS)}")
+    ]
+    
+    for days, text in periods:
+        keyboard.append([
+            InlineKeyboardButton(text=text, callback_data=f"extend_period_{days}")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_add_traffic_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    packages = [
+        (5, f"📊 +5 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_5GB)}"),
+        (10, f"📊 +10 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_10GB)}"),
+        (25, f"📊 +25 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_25GB)}"),
+        (50, f"📊 +50 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_50GB)}"),
+        (100, f"📊 +100 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_100GB)}"),
+        (0, f"📊 Безлимит - {settings.format_price(settings.PRICE_TRAFFIC_UNLIMITED)}")
+    ]
+    
+    for gb, text in packages:
+        keyboard.append([
+            InlineKeyboardButton(text=text, callback_data=f"add_traffic_{gb}")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_add_devices_keyboard(current_devices: int, language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    max_devices = 10 
+    
+    for add_count in range(1, min(6, max_devices - current_devices + 1)): 
+        price = add_count * settings.PRICE_PER_DEVICE
+        total_devices = current_devices + add_count
+        
+        keyboard.append([
+            InlineKeyboardButton(
+                text=f"📱 +{add_count} устройство{_get_device_suffix(add_count)} (итого: {total_devices}) - {settings.format_price(price)}",
+                callback_data=f"add_devices_{add_count}"
+            )
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="menu_subscription")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_reset_traffic_confirm_keyboard(price_kopeks: int, language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text=f"✅ Сбросить за {settings.format_price(price_kopeks)}", 
+                callback_data="confirm_reset_traffic"
+            )
+        ],
+        [
+            InlineKeyboardButton(text="❌ Отмена", callback_data="menu_subscription")
+        ]
+    ])
+
+def get_manage_countries_keyboard(
+    countries: List[dict], 
+    selected: List[str], 
+    current_subscription_countries: List[str],
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    for country in countries:
+        if not country.get('is_available', True):
+            continue
+        
+        is_currently_connected = country['uuid'] in current_subscription_countries
+        is_selected = country['uuid'] in selected
+        
+        if is_currently_connected:
+            if is_selected:
+                emoji = "✅"  
+                status = ""
+            else:
+                emoji = "➖"  
+                status = " (отключить БЕСПЛАТНО)"
+        else:
+            if is_selected:
+                emoji = "➕"  
+                price_text = f" (+{texts.format_price(country['price_kopeks'])})" if country['price_kopeks'] > 0 else " (Бесплатно)"
+                status = price_text
+            else:
+                emoji = "⚪"  
+                price_text = f" (+{texts.format_price(country['price_kopeks'])})" if country['price_kopeks'] > 0 else " (Бесплатно)"
+                status = price_text
+        
+        keyboard.append([
+            InlineKeyboardButton(
+                text=f"{emoji} {country['name']}{status}",
+                callback_data=f"country_manage_{country['uuid']}"
+            )
+        ])
+    
+    if not keyboard:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="❌ Нет доступных серверов",
+                callback_data="no_servers"
+            )
+        ])
+    
+    added = [c for c in selected if c not in current_subscription_countries]
+    removed = [c for c in current_subscription_countries if c not in selected]
+    
+    apply_text = "✅ Применить изменения"
+    if added or removed:
+        changes_count = len(added) + len(removed)
+        apply_text += f" ({changes_count})"
+    
+    keyboard.extend([
+        [InlineKeyboardButton(text=apply_text, callback_data="countries_apply")],
+        [InlineKeyboardButton(text="❌ Отмена", callback_data="menu_subscription")]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_device_selection_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(text="📱 iOS (iPhone/iPad)", callback_data="device_guide_ios"),
+            InlineKeyboardButton(text="🤖 Android", callback_data="device_guide_android")
+        ],
+        [
+            InlineKeyboardButton(text="💻 Windows", callback_data="device_guide_windows"),
+            InlineKeyboardButton(text="🍎 macOS", callback_data="device_guide_mac")
+        ],
+        [
+            InlineKeyboardButton(text="📺 Android TV", callback_data="device_guide_tv")
+        ],
+        [
+            InlineKeyboardButton(text="📋 Показать ссылку подписки", callback_data="open_subscription_link")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+        ]
+    ])
+
+
+def get_connection_guide_keyboard(
+    subscription_url: str, 
+    app: dict, 
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    from app.handlers.subscription import create_deep_link
+    
+    keyboard = []
+    
+    if 'installationStep' in app and 'buttons' in app['installationStep']:
+        app_buttons = []
+        for button in app['installationStep']['buttons']:
+            button_text = button['buttonText'].get(language, button['buttonText']['en'])
+            app_buttons.append(
+                InlineKeyboardButton(text=f"📥 {button_text}", url=button['buttonLink'])
+            )
+            if len(app_buttons) == 2:
+                keyboard.append(app_buttons)
+                app_buttons = []
+        
+        if app_buttons:
+            keyboard.append(app_buttons)
+    
+    keyboard.append([
+        InlineKeyboardButton(text="📋 Скопировать ссылку подписки", url=subscription_url)
+    ])
+    
+    keyboard.extend([
+        [
+            InlineKeyboardButton(text="📱 Выбрать другое устройство", callback_data="subscription_connect")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ К подписке", callback_data="menu_subscription")
+        ]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_app_selection_keyboard(
+    device_type: str, 
+    apps: list, 
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    keyboard = []
+    
+    for app in apps:
+        app_name = app['name']
+        if app.get('isFeatured', False):
+            app_name = f"⭐ {app_name}"
+        
+        keyboard.append([
+            InlineKeyboardButton(
+                text=app_name, 
+                callback_data=f"app_{device_type}_{app['id']}"
+            )
+        ])
+    
+    keyboard.extend([
+        [
+            InlineKeyboardButton(text="📱 Выбрать другое устройство", callback_data="subscription_connect")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ К подписке", callback_data="menu_subscription")
+        ]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+def get_specific_app_keyboard(
+    subscription_url: str,
+    app: dict,
+    device_type: str,
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    from app.handlers.subscription import create_deep_link
+    
+    keyboard = []
+    
+    if 'installationStep' in app and 'buttons' in app['installationStep']:
+        app_buttons = []
+        for button in app['installationStep']['buttons']:
+            button_text = button['buttonText'].get(language, button['buttonText']['en'])
+            app_buttons.append(
+                InlineKeyboardButton(text=f"📥 {button_text}", url=button['buttonLink'])
+            )
+            if len(app_buttons) == 2:
+                keyboard.append(app_buttons)
+                app_buttons = []
+        
+        if app_buttons:
+            keyboard.append(app_buttons)
+    
+    keyboard.append([
+        InlineKeyboardButton(text="📋 Скопировать ссылку подписки", url=subscription_url)
+    ])
+    
+    if 'additionalAfterAddSubscriptionStep' in app and 'buttons' in app['additionalAfterAddSubscriptionStep']:
+        for button in app['additionalAfterAddSubscriptionStep']['buttons']:
+            button_text = button['buttonText'].get(language, button['buttonText']['en'])
+            keyboard.append([
+                InlineKeyboardButton(text=button_text, url=button['buttonLink'])
+            ])
+    
+    keyboard.extend([
+        [
+            InlineKeyboardButton(text="📋 Другие приложения", callback_data=f"app_list_{device_type}")
+        ],
+        [
+            InlineKeyboardButton(text="📱 Выбрать другое устройство", callback_data="subscription_connect")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ К подписке", callback_data="menu_subscription")
+        ]
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)

app/keyboards/reply.py

@@ -0,0 +1,116 @@
+from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, ReplyKeyboardRemove
+from typing import List
+
+from app.localization.texts import get_texts
+
+
+def get_main_reply_keyboard(language: str = "ru") -> ReplyKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return ReplyKeyboardMarkup(
+        keyboard=[
+            [
+                KeyboardButton(text=texts.MENU_BALANCE),
+                KeyboardButton(text=texts.MENU_SUBSCRIPTION)
+            ],
+            [
+                KeyboardButton(text=texts.MENU_PROMOCODE),
+                KeyboardButton(text=texts.MENU_REFERRALS)
+            ],
+            [
+                KeyboardButton(text=texts.MENU_SUPPORT),
+                KeyboardButton(text=texts.MENU_RULES)
+            ]
+        ],
+        resize_keyboard=True,
+        one_time_keyboard=False
+    )
+
+
+def get_admin_reply_keyboard(language: str = "ru") -> ReplyKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return ReplyKeyboardMarkup(
+        keyboard=[
+            [
+                KeyboardButton(text="👥 Пользователи"),
+                KeyboardButton(text="📱 Подписки")
+            ],
+            [
+                KeyboardButton(text="🎫 Промокоды"),
+                KeyboardButton(text="📨 Рассылки")
+            ],
+            [
+                KeyboardButton(text="📊 Статистика"),
+                KeyboardButton(text="🔧 Мониторинг")
+            ],
+            [
+                KeyboardButton(text="🏠 Главное меню")
+            ]
+        ],
+        resize_keyboard=True,
+        one_time_keyboard=False
+    )
+
+
+def get_cancel_keyboard(language: str = "ru") -> ReplyKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return ReplyKeyboardMarkup(
+        keyboard=[
+            [KeyboardButton(text=texts.CANCEL)]
+        ],
+        resize_keyboard=True,
+        one_time_keyboard=True
+    )
+
+
+def get_confirmation_reply_keyboard(language: str = "ru") -> ReplyKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return ReplyKeyboardMarkup(
+        keyboard=[
+            [
+                KeyboardButton(text=texts.YES),
+                KeyboardButton(text=texts.NO)
+            ]
+        ],
+        resize_keyboard=True,
+        one_time_keyboard=True
+    )
+
+
+def get_skip_keyboard(language: str = "ru") -> ReplyKeyboardMarkup:
+    return ReplyKeyboardMarkup(
+        keyboard=[
+            [KeyboardButton(text="⏭️ Пропустить")]
+        ],
+        resize_keyboard=True,
+        one_time_keyboard=True
+    )
+
+
+def remove_keyboard() -> ReplyKeyboardRemove:
+    return ReplyKeyboardRemove()
+
+
+def get_contact_keyboard(language: str = "ru") -> ReplyKeyboardMarkup:
+    return ReplyKeyboardMarkup(
+        keyboard=[
+            [KeyboardButton(text="📱 Отправить контакт", request_contact=True)],
+            [KeyboardButton(text="❌ Отмена")]
+        ],
+        resize_keyboard=True,
+        one_time_keyboard=True
+    )
+
+
+def get_location_keyboard(language: str = "ru") -> ReplyKeyboardMarkup:
+    return ReplyKeyboardMarkup(
+        keyboard=[
+            [KeyboardButton(text="📍 Отправить геолокацию", request_location=True)],
+            [KeyboardButton(text="❌ Отмена")]
+        ],
+        resize_keyboard=True,
+        one_time_keyboard=True
+    )

app/localization/texts.py

@@ -0,0 +1,488 @@
+import asyncio
+from typing import Dict, Any
+from app.config import settings
+
+_cached_rules = {}
+
+def _get_default_rules(language: str = "ru") -> str:
+    if language == "en":
+        return """
+🔒 <b>Service Usage Rules</b>
+
+1. It is forbidden to use the service for illegal activities
+2. Copyright infringement is prohibited
+3. Spam and malware distribution are prohibited
+4. Using the service for DDoS attacks is prohibited
+5. One account - one user
+6. Refunds are made only in exceptional cases
+7. Administration reserves the right to block an account for violating the rules
+
+<b>By accepting the rules, you agree to comply with them.</b>
+"""
+    else:
+        return """
+📋 <b>Правила использования сервиса</b>
+
+1. Запрещается использование сервиса для незаконной деятельности
+2. Запрещается нарушение авторских прав
+3. Запрещается спам и рассылка вредоносного ПО
+4. Запрещается использование сервиса для DDoS атак
+5. Один аккаунт - один пользователь
+6. Возврат средств производится только в исключительных случаях
+7. Администрация оставляет за собой право заблокировать аккаунт при нарушении правил
+
+<b>Принимая правила, вы соглашаетесь соблюдать их.</b>
+"""
+
+class Texts:
+    def __init__(self, language: str = "ru"):
+        self.language = language
+    
+    @property
+    def RULES_TEXT(self) -> str:
+        if self.language in _cached_rules:
+            return _cached_rules[self.language]
+        
+        return _get_default_rules(self.language)
+    
+    BACK = "⬅️ Назад"
+    CANCEL = "❌ Отмена"
+    CONFIRM = "✅ Подтвердить"
+    CONTINUE = "➡️ Продолжить"
+    YES = "✅ Да"
+    NO = "❌ Нет"
+    LOADING = "⏳ Загрузка..."
+    ERROR = "❌ Произошла ошибка"
+    SUCCESS = "✅ Успешно"
+    
+    @staticmethod
+    def format_price(kopeks: int) -> str:
+        return f"{kopeks / 100:.2f} ₽"
+    
+    @staticmethod
+    def format_traffic(gb: float) -> str:
+        if gb == 0:
+            return "∞ (безлимит)"
+        elif gb >= 1024:
+            return f"{gb/1024:.1f} ТБ"
+        else:
+            return f"{gb:.0f} ГБ"
+
+
+class RussianTexts(Texts):
+    
+    def __init__(self):
+        super().__init__("ru")
+    
+    WELCOME = """
+🎉 <b>Добро пожаловать в VPN сервис!</b>
+
+Наш сервис предоставляет быстрый и безопасный доступ к интернету без ограничений.
+
+🔐 <b>Преимущества:</b>
+• Высокая скорость подключения
+• Серверы в разных странах
+• Надежная защита данных
+• Круглосуточная поддержка
+
+Для начала работы выберите язык интерфейса:
+"""
+    
+    LANGUAGE_SELECTED = "🌐 Язык интерфейса установлен: <b>Русский</b>"
+    
+    RULES_ACCEPT = "✅ Принимаю правила"
+    RULES_DECLINE = "❌ Не принимаю"
+    RULES_REQUIRED = "❗️ Для использования сервиса необходимо принять правила!"
+    
+    REFERRAL_CODE_QUESTION = """
+🤝 <b>У вас есть реферальный код от друга?</b>
+
+Если у вас есть промокод или реферальная ссылка от друга, введите её сейчас, чтобы получить бонус!
+
+Введите код или нажмите "Пропустить":
+"""
+    
+    REFERRAL_CODE_APPLIED = "🎁 Реферальный код применен! Вы получите бонус после первой покупки."
+    REFERRAL_CODE_INVALID = "❌ Неверный реферальный код"
+    REFERRAL_CODE_SKIP = "⏭️ Пропустить"
+    
+    MAIN_MENU = """
+👤 <b>{user_name}</b>
+
+💰 <b>Баланс:</b> {balance}
+📱 <b>Подписка:</b> {subscription_status}
+
+Выберите действие:
+"""
+    
+    MENU_BALANCE = "💰 Баланс"
+    MENU_SUBSCRIPTION = "📱 Подписка"
+    MENU_TRIAL = "🎁 Тестовая подписка"
+    MENU_BUY_SUBSCRIPTION = "💎 Купить подписку"
+    MENU_EXTEND_SUBSCRIPTION = "⏰ Продлить подписку"
+    MENU_PROMOCODE = "🎫 Промокод"
+    MENU_REFERRALS = "🤝 Рефералы"
+    MENU_SUPPORT = "🛠️ Техподдержка"
+    MENU_RULES = "📋 Правила сервиса"
+    MENU_LANGUAGE = "🌐 Язык"
+    MENU_ADMIN = "⚙️ Админ-панель"
+    
+    SUBSCRIPTION_NONE = "❌ Нет активной подписки"
+    SUBSCRIPTION_TRIAL = "🎁 Тестовая подписка"
+    SUBSCRIPTION_ACTIVE = "✅ Активна"
+    SUBSCRIPTION_EXPIRED = "⏰ Истекла"
+    
+    SUBSCRIPTION_INFO = """
+📱 <b>Информация о подписке</b>
+
+📊 <b>Статус:</b> {status}
+🎭 <b>Тип:</b> {type}
+📅 <b>Действует до:</b> {end_date}
+⏰ <b>Осталось дней:</b> {days_left}
+
+📈 <b>Трафик:</b> {traffic_used} / {traffic_limit}
+🌍 <b>Серверы:</b> {countries_count} стран
+📱 <b>Устройства:</b> {devices_used} / {devices_limit}
+
+💳 <b>Автоплатеж:</b> {autopay_status}
+"""
+    
+    TRIAL_AVAILABLE = """
+🎁 <b>Тестовая подписка</b>
+
+Вы можете получить бесплатную тестовую подписку:
+
+⏰ <b>Период:</b> {days} дней
+📈 <b>Трафик:</b> {traffic} ГБ
+📱 <b>Устройства:</b> {devices} шт.
+🌍 <b>Сервер:</b> 1 страна
+
+Активировать тестовую подписку?
+"""
+    
+    TRIAL_ACTIVATED = "🎉 Тестовая подписка активирована!"
+    TRIAL_ALREADY_USED = "❌ Тестовая подписка уже была использована"
+    
+    BUY_SUBSCRIPTION_START = """
+💎 <b>Настройка подписки</b>
+
+Давайте настроим вашу подписку под ваши потребности.
+
+Сначала выберите период подписки:
+"""
+    
+    SELECT_PERIOD = "Выберите период:"
+    SELECT_TRAFFIC = "Выберите пакет трафика:"
+    SELECT_COUNTRIES = "Выберите страны:"
+    SELECT_DEVICES = "Количество устройств:"
+    
+    PERIOD_14_DAYS = f"📅 14 дней - {settings.format_price(settings.PRICE_14_DAYS)}"
+    PERIOD_30_DAYS = f"📅 30 дней - {settings.format_price(settings.PRICE_30_DAYS)}"
+    PERIOD_60_DAYS = f"📅 60 дней - {settings.format_price(settings.PRICE_60_DAYS)}"
+    PERIOD_90_DAYS = f"📅 90 дней - {settings.format_price(settings.PRICE_90_DAYS)}"
+    PERIOD_180_DAYS = f"📅 180 дней - {settings.format_price(settings.PRICE_180_DAYS)}"
+    PERIOD_360_DAYS = f"📅 360 дней - {settings.format_price(settings.PRICE_360_DAYS)}"
+    
+    TRAFFIC_5GB = f"📊 5 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_5GB)}"
+    TRAFFIC_10GB = f"📊 10 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_10GB)}"
+    TRAFFIC_25GB = f"📊 25 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_25GB)}"
+    TRAFFIC_50GB = f"📊 50 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_50GB)}"
+    TRAFFIC_100GB = f"📊 100 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_100GB)}"
+    TRAFFIC_250GB = f"📊 250 ГБ - {settings.format_price(settings.PRICE_TRAFFIC_250GB)}"
+    TRAFFIC_UNLIMITED = f"📊 Безлимит - {settings.format_price(settings.PRICE_TRAFFIC_UNLIMITED)}"
+    
+    SUBSCRIPTION_SUMMARY = """
+📋 <b>Итоговая конфигурация</b>
+
+📅 <b>Период:</b> {period} дней
+📈 <b>Трафик:</b> {traffic}
+🌍 <b>Страны:</b> {countries}
+📱 <b>Устройства:</b> {devices}
+
+💰 <b>Итого к оплате:</b> {total_price}
+
+Подтвердить покупку?
+"""
+    
+    INSUFFICIENT_BALANCE = "❌ Недостаточно средств на балансе. Пополните баланс и попробуйте снова."
+    SUBSCRIPTION_PURCHASED = "🎉 Подписка успешно приобретена!"
+    
+    BALANCE_INFO = """
+💰 <b>Баланс: {balance}</b>
+
+Выберите действие:
+"""
+    
+    BALANCE_HISTORY = "📊 История операций"
+    BALANCE_TOP_UP = "💳 Пополнить"
+    BALANCE_SUPPORT_REQUEST = "🛠️ Запрос через поддержку"
+    
+    TOP_UP_AMOUNT = "💳 Введите сумму для пополнения (в рублях):"
+    TOP_UP_METHODS = """
+💳 <b>Выберите способ оплаты</b>
+
+Сумма: {amount}
+"""
+    
+    TOP_UP_STARS = "⭐ Telegram Stars"
+    TOP_UP_TRIBUTE = "💎 Банковская карта"
+    
+    PROMOCODE_ENTER = "🎫 Введите промокод:"
+    PROMOCODE_SUCCESS = "🎉 Промокод активирован! {description}"
+    PROMOCODE_INVALID = "❌ Неверный промокод"
+    PROMOCODE_EXPIRED = "❌ Промокод истек"
+    PROMOCODE_USED = "❌ Промокод уже использован"
+    
+    REFERRAL_INFO = """
+🤝 <b>Реферальная программа</b>
+
+👥 <b>Приглашено:</b> {referrals_count} друзей
+💰 <b>Заработано:</b> {earned_amount}
+
+🔗 <b>Ваша реферальная ссылка:</b>
+<code>{referral_link}</code>
+
+🎫 <b>Ваш промокод:</b>
+<code>{referral_code}</code>
+
+💰 <b>Условия:</b>
+• За каждого друга: {registration_bonus}
+• Процент с пополнений: {commission_percent}%
+"""
+    
+    REFERRAL_INVITE_MESSAGE = """
+🎯 <b>Приглашение в VPN сервис</b>
+
+Привет! Приглашаю тебя в отличный VPN сервис!
+
+🎁 По моей ссылке ты получишь бонус: {bonus}
+
+🔗 Переходи: {link}
+🎫 Или используй промокод: {code}
+
+💪 Быстро, надежно, недорого!
+"""
+    
+    CREATE_INVITE = "📝 Создать приглашение"
+
+    TRIAL_ENDING_SOON = """
+🎁 <b>Тестовая подписка скоро закончится!</b>
+
+Ваша тестовая подписка истекает через 2 часа.
+
+💎 <b>Не хотите остаться без VPN?</b>
+Переходите на полную подписку!
+
+🔥 <b>Специальное предложение:</b>
+• 30 дней всего за {price}
+• Безлимитный трафик  
+• Все серверы доступны
+• Поддержка до 3 устройств
+
+⚡️ Успейте оформить до окончания тестового периода!
+"""
+
+    SUBSCRIPTION_EXPIRING_PAID = """
+⚠️ <b>Подписка истекает через {days} дней!</b>
+
+Ваша платная подписка истекает {end_date}.
+
+💳 <b>Автоплатеж:</b> {autopay_status}
+
+{action_text}
+"""
+
+    AUTOPAY_ENABLED_TEXT = "Включен - подписка продлится автоматически"
+    AUTOPAY_DISABLED_TEXT = "Отключен - не забудьте продлить вручную!"
+
+    SUBSCRIPTION_EXPIRED = """
+❌ <b>Подписка истекла</b>
+
+Ваша подписка истекла. Для восстановления доступа продлите подписку.
+
+🔧 Доступ к серверам заблокирован до продления.
+"""
+
+    AUTOPAY_SUCCESS = """
+✅ <b>Автоплатеж выполнен</b>
+
+Ваша подписка автоматически продлена на {days} дней.
+Списано с баланса: {amount}
+
+Новая дата окончания: {new_end_date}
+"""
+
+    AUTOPAY_FAILED = """
+❌ <b>Ошибка автоплатежа</b>
+
+Не удалось списать средства для продления подписки.
+
+💰 Ваш баланс: {balance}
+💳 Требуется: {required}
+
+Пополните баланс и продлите подписку вручную.
+"""
+    
+    SUPPORT_INFO = f"""
+🛠️ <b>Техническая поддержка</b>
+
+По всем вопросам обращайтесь к нашей поддержке:
+
+👤 {settings.SUPPORT_USERNAME}
+
+Мы поможем с:
+• Настройкой подключения
+• Решением технических проблем  
+• Вопросами по оплате
+• Другими вопросами
+
+⏰ Время ответа: обычно в течение 1-2 часов
+"""
+    
+    CONTACT_SUPPORT = "💬 Написать в поддержку"
+    
+    ADMIN_PANEL = """
+⚙️ <b>Административная панель</b>
+
+Выберите раздел для управления:
+"""
+    
+    ADMIN_USERS = "👥 Пользователи"
+    ADMIN_SUBSCRIPTIONS = "📱 Подписки"
+    ADMIN_PROMOCODES = "🎫 Промокоды"
+    ADMIN_MESSAGES = "📨 Рассылки"
+    ADMIN_MONITORING = "🔍 Мониторинг"
+    ADMIN_REFERRALS = "🤝 Рефералы"
+    ADMIN_RULES = "📋 Правила"
+    ADMIN_REMNAWAVE = "🖥️ RemnaWave"
+    ADMIN_STATISTICS = "📊 Статистика"
+    
+    ACCESS_DENIED = "❌ Доступ запрещен"
+    USER_NOT_FOUND = "❌ Пользователь не найден"
+    SUBSCRIPTION_NOT_FOUND = "❌ Подписка не найдена"
+    INVALID_AMOUNT = "❌ Неверная сумма"
+    OPERATION_CANCELLED = "❌ Операция отменена"
+    
+    SUBSCRIPTION_EXPIRING = """
+⚠️ <b>Подписка истекает!</b>
+
+Ваша подписка истекает через {days} дней.
+
+Не забудьте продлить подписку, чтобы не потерять доступ к серверам.
+"""
+    
+    SUBSCRIPTION_EXPIRED = """
+❌ <b>Подписка истекла</b>
+
+Ваша подписка истекла. Для восстановления доступа продлите подписку.
+"""
+    
+    AUTOPAY_SUCCESS = """
+✅ <b>Автоплатеж выполнен</b>
+
+Ваша подписка автоматически продлена на {days} дней.
+Списано с баланса: {amount}
+"""
+    
+    AUTOPAY_FAILED = """
+❌ <b>Ошибка автоплатежа</b>
+
+Не удалось списать средства для продления подписки.
+Недостаточно средств на балансе: {balance}
+Требуется: {required}
+
+Пополните баланс и продлите подписку вручную.
+"""
+
+
+class EnglishTexts(Texts):
+    
+    def __init__(self):
+        super().__init__("en")
+    
+    WELCOME = """
+🎉 <b>Welcome to VPN Service!</b>
+
+Our service provides fast and secure internet access without restrictions.
+
+🔐 <b>Advantages:</b>
+• High connection speed
+• Servers in different countries  
+• Reliable data protection
+• 24/7 support
+
+To get started, select interface language:
+"""
+    
+    LANGUAGE_SELECTED = "🌐 Interface language set: <b>English</b>"
+    
+    BACK = "⬅️ Back"
+    CANCEL = "❌ Cancel"
+    CONFIRM = "✅ Confirm"
+    CONTINUE = "➡️ Continue"
+    YES = "✅ Yes"
+    NO = "❌ No"
+    
+    MENU_BALANCE = "💰 Balance"
+    MENU_SUBSCRIPTION = "📱 Subscription"
+    MENU_TRIAL = "🎁 Trial subscription"
+    
+
+LANGUAGES = {
+    "ru": RussianTexts,
+    "en": EnglishTexts
+}
+
+
+def get_texts(language: str = "ru") -> Texts:
+    return LANGUAGES.get(language, RussianTexts)()
+
+async def get_rules_from_db(language: str = "ru") -> str:
+    try:
+        from app.database.database import get_db
+        from app.database.crud.rules import get_current_rules_content
+        
+        async for db in get_db():
+            rules = await get_current_rules_content(db, language)
+            if rules:
+                _cached_rules[language] = rules
+                return rules
+            break
+            
+    except Exception as e:
+        print(f"Ошибка получения правил из БД: {e}")
+    
+    default_rules = _get_default_rules(language)
+    _cached_rules[language] = default_rules
+    return default_rules
+
+def get_rules_sync(language: str = "ru") -> str:
+    try:
+        if language in _cached_rules:
+            return _cached_rules[language]
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        rules = loop.run_until_complete(get_rules_from_db(language))
+        loop.close()
+        return rules
+        
+    except Exception as e:
+        print(f"Ошибка получения правил: {e}")
+        return _get_default_rules(language)
+
+async def refresh_rules_cache(language: str = "ru"):
+    try:
+        if language in _cached_rules:
+            del _cached_rules[language]
+        
+        await get_rules_from_db(language)
+        print(f"✅ Кеш правил для языка {language} обновлен")
+        
+    except Exception as e:
+        print(f"Ошибка обновления кеша правил: {e}")
+
+def clear_rules_cache():
+    global _cached_rules
+    _cached_rules.clear()
+    print("✅ Кеш правил очищен")

app/middlewares/auth.py

@@ -0,0 +1,93 @@
+import logging
+from typing import Callable, Dict, Any, Awaitable
+from aiogram import BaseMiddleware
+from aiogram.types import Message, CallbackQuery, TelegramObject, User as TgUser
+from aiogram.fsm.context import FSMContext
+
+from app.config import settings
+from app.database.database import get_db
+from app.database.crud.user import get_user_by_telegram_id, create_user
+from app.states import RegistrationStates
+
+logger = logging.getLogger(__name__)
+
+
+class AuthMiddleware(BaseMiddleware):
+    
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: Dict[str, Any]
+    ) -> Any:
+        
+        user: TgUser = None
+        if isinstance(event, (Message, CallbackQuery)):
+            user = event.from_user
+        
+        if not user:
+            return await handler(event, data)
+        
+        if user.is_bot:
+            return await handler(event, data)
+        
+        async for db in get_db():
+            try:
+                db_user = await get_user_by_telegram_id(db, user.id)
+                
+                if not db_user:
+                    state: FSMContext = data.get('state')
+                    current_state = None
+                    
+                    if state:
+                        current_state = await state.get_state()
+                    
+                    registration_states = [
+                        RegistrationStates.waiting_for_rules_accept,
+                        RegistrationStates.waiting_for_referral_code
+                    ]
+                    
+                    is_registration_process = (
+                        (isinstance(event, Message) and event.text and event.text.startswith('/start'))
+                        or (isinstance(event, CallbackQuery) and current_state and 
+                            any(str(state) in str(current_state) for state in registration_states))
+                        or (isinstance(event, CallbackQuery) and event.data and 
+                            (event.data in ['rules_accept', 'rules_decline', 'referral_skip']))
+                    )
+                    
+                    if is_registration_process:
+                        logger.info(f"🔓 Пропускаем пользователя {user.id} в процессе регистрации")
+                        data['db'] = db
+                        data['db_user'] = None
+                        data['is_admin'] = False
+                        return await handler(event, data)
+                    else:
+                        if isinstance(event, Message):
+                            await event.answer(
+                                "◀️ Для начала работы необходимо выполнить команду /start"
+                            )
+                        elif isinstance(event, CallbackQuery):
+                            await event.answer(
+                                "◀️ Необходимо начать с команды /start",
+                                show_alert=True
+                            )
+                        logger.info(f"🚫 Заблокирован незарегистрированный пользователь {user.id}")
+                        return
+                else:
+                    from datetime import datetime
+                    db_user.last_activity = datetime.utcnow()
+                    await db.commit()
+                
+                data['db'] = db
+                data['db_user'] = db_user
+                data['is_admin'] = settings.is_admin(user.id)
+                
+                return await handler(event, data)
+                
+            except Exception as e:
+                logger.error(f"Ошибка в AuthMiddleware: {e}")
+                logger.error(f"Event type: {type(event)}")
+                if hasattr(event, 'data'):
+                    logger.error(f"Callback data: {event.data}")
+                await db.rollback()
+                raise

app/middlewares/logging.py

@@ -0,0 +1,42 @@
+import logging
+import time
+from typing import Callable, Dict, Any, Awaitable
+from aiogram import BaseMiddleware
+from aiogram.types import Message, CallbackQuery, TelegramObject
+
+logger = logging.getLogger(__name__)
+
+
+class LoggingMiddleware(BaseMiddleware):
+    
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: Dict[str, Any]
+    ) -> Any:
+        
+        start_time = time.time()
+        
+        try:
+            if isinstance(event, Message):
+                user_info = f"@{event.from_user.username}" if event.from_user.username else f"ID:{event.from_user.id}"
+                text = event.text or event.caption or "[медиа]"
+                logger.info(f"📩 Сообщение от {user_info}: {text}")
+                
+            elif isinstance(event, CallbackQuery):
+                user_info = f"@{event.from_user.username}" if event.from_user.username else f"ID:{event.from_user.id}"
+                logger.info(f"🔘 Callback от {user_info}: {event.data}")
+            
+            result = await handler(event, data)
+            
+            execution_time = time.time() - start_time
+            if execution_time > 1.0:  
+                logger.warning(f"⏱️ Медленная операция: {execution_time:.2f}s")
+            
+            return result
+            
+        except Exception as e:
+            execution_time = time.time() - start_time
+            logger.error(f"❌ Ошибка при обработке события за {execution_time:.2f}s: {e}")
+            raise

app/middlewares/throttling.py

@@ -0,0 +1,53 @@
+import asyncio
+import logging
+import time
+from typing import Callable, Dict, Any, Awaitable
+from aiogram import BaseMiddleware
+from aiogram.types import Message, CallbackQuery, TelegramObject
+
+logger = logging.getLogger(__name__)
+
+
+class ThrottlingMiddleware(BaseMiddleware):
+    
+    def __init__(self, rate_limit: float = 0.5):
+        self.rate_limit = rate_limit
+        self.user_buckets: Dict[int, float] = {}
+    
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: Dict[str, Any]
+    ) -> Any:
+        
+        user_id = None
+        if isinstance(event, (Message, CallbackQuery)):
+            user_id = event.from_user.id
+        
+        if not user_id:
+            return await handler(event, data)
+        
+        now = time.time()
+        last_call = self.user_buckets.get(user_id, 0)
+        
+        if now - last_call < self.rate_limit:
+            logger.warning(f"🚫 Throttling для пользователя {user_id}")
+            
+            if isinstance(event, Message):
+                await event.answer("⏳ Пожалуйста, не отправляйте сообщения так часто!")
+            elif isinstance(event, CallbackQuery):
+                await event.answer("⏳ Слишком быстро! Подождите немного.", show_alert=True)
+            
+            return
+        
+        self.user_buckets[user_id] = now
+        
+        cleanup_threshold = now - 60
+        self.user_buckets = {
+            uid: timestamp 
+            for uid, timestamp in self.user_buckets.items() 
+            if timestamp > cleanup_threshold
+        }
+        
+        return await handler(event, data)

app/services/__init__.py

@@ -0,0 +1,3 @@
+"""
+Сервисы бизнес-логики
+"""

app/services/monitoring_service.py

@@ -0,0 +1,621 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional, Set
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, and_
+from sqlalchemy.orm import selectinload
+
+from app.config import settings
+from app.database.database import get_db
+from app.database.crud.subscription import (
+    get_expired_subscriptions, get_expiring_subscriptions,
+    get_subscriptions_for_autopay, deactivate_subscription,
+    extend_subscription
+)
+from app.database.crud.user import (
+    get_user_by_id, get_inactive_users, delete_user,
+    subtract_user_balance
+)
+from app.database.models import MonitoringLog, SubscriptionStatus, Subscription, User
+from app.services.subscription_service import SubscriptionService
+from app.services.payment_service import PaymentService
+from app.localization.texts import get_texts
+
+logger = logging.getLogger(__name__)
+
+
+class MonitoringService:
+    
+    def __init__(self, bot=None):
+        self.is_running = False
+        self.subscription_service = SubscriptionService()
+        self.payment_service = PaymentService()
+        self.bot = bot
+        self._notified_users: Set[str] = set()  # Защита от дублирования уведомлений
+    
+    async def start_monitoring(self):
+        if self.is_running:
+            logger.warning("Мониторинг уже запущен")
+            return
+        
+        self.is_running = True
+        logger.info("🔄 Запуск службы мониторинга")
+        
+        while self.is_running:
+            try:
+                await self._monitoring_cycle()
+                await asyncio.sleep(settings.MONITORING_INTERVAL * 60) 
+                
+            except Exception as e:
+                logger.error(f"Ошибка в цикле мониторинга: {e}")
+                await asyncio.sleep(60) 
+    
+    def stop_monitoring(self):
+        self.is_running = False
+        logger.info("ℹ️ Мониторинг остановлен")
+    
+    async def _monitoring_cycle(self):
+        async for db in get_db():
+            try:
+                await self._check_expired_subscriptions(db)
+                await self._check_expiring_subscriptions(db)
+                await self._check_trial_expiring_soon(db)  # Новый метод!
+                await self._process_autopayments(db)
+                await self._cleanup_inactive_users(db)
+                await self._sync_with_remnawave(db)
+                
+                # Очищаем кеш уведомлений каждые 24 часа
+                current_hour = datetime.utcnow().hour
+                if current_hour == 0:
+                    self._notified_users.clear()
+                
+                await self._log_monitoring_event(
+                    db, "monitoring_cycle_completed", 
+                    "Цикл мониторинга успешно завершен", 
+                    {"timestamp": datetime.utcnow().isoformat()}
+                )
+                
+            except Exception as e:
+                logger.error(f"Ошибка в цикле мониторинга: {e}")
+                await self._log_monitoring_event(
+                    db, "monitoring_cycle_error", 
+                    f"Ошибка в цикле мониторинга: {str(e)}", 
+                    {"error": str(e)},
+                    is_success=False
+                )
+            finally:
+                break 
+    
+    async def _check_expired_subscriptions(self, db: AsyncSession):
+        """Проверка истекших подписок"""
+        try:
+            expired_subscriptions = await get_expired_subscriptions(db)
+            
+            for subscription in expired_subscriptions:
+                await deactivate_subscription(db, subscription)
+                
+                user = await get_user_by_id(db, subscription.user_id)
+                if user and user.remnawave_uuid:
+                    await self.subscription_service.disable_remnawave_user(user.remnawave_uuid)
+                
+                # Отправляем уведомление об истечении
+                if user and self.bot:
+                    await self._send_subscription_expired_notification(user)
+                
+                logger.info(f"🔴 Подписка пользователя {subscription.user_id} истекла и деактивирована")
+            
+            if expired_subscriptions:
+                await self._log_monitoring_event(
+                    db, "expired_subscriptions_processed",
+                    f"Обработано {len(expired_subscriptions)} истекших подписок",
+                    {"count": len(expired_subscriptions)}
+                )
+                
+        except Exception as e:
+            logger.error(f"Ошибка проверки истекших подписок: {e}")
+    
+    async def _check_expiring_subscriptions(self, db: AsyncSession):
+        """Проверка подписок, истекающих через 2-3 дня (только платные)"""
+        try:
+            warning_days = settings.get_autopay_warning_days()
+            
+            for days in warning_days:
+                # Получаем только платные подписки
+                expiring_subscriptions = await self._get_expiring_paid_subscriptions(db, days)
+                
+                for subscription in expiring_subscriptions:
+                    user = await get_user_by_id(db, subscription.user_id)
+                    if not user:
+                        continue
+                    
+                    notification_key = f"expiring_{user.telegram_id}_{days}d"
+                    if notification_key in self._notified_users:
+                        continue  # Уже уведомляли сегодня
+                    
+                    if self.bot:
+                        await self._send_subscription_expiring_notification(user, subscription, days)
+                        self._notified_users.add(notification_key)
+                    
+                    logger.info(f"⚠️ Пользователю {user.telegram_id} отправлено уведомление об истечении подписки через {days} дней")
+                
+                if expiring_subscriptions:
+                    await self._log_monitoring_event(
+                        db, "expiring_notifications_sent",
+                        f"Отправлено {len(expiring_subscriptions)} уведомлений об истечении через {days} дней",
+                        {"days": days, "count": len(expiring_subscriptions)}
+                    )
+                    
+        except Exception as e:
+            logger.error(f"Ошибка проверки истекающих подписок: {e}")
+    
+    async def _check_trial_expiring_soon(self, db: AsyncSession):
+        """Проверка тестовых подписок, истекающих через 2 часа"""
+        try:
+            # Получаем тестовые подписки, истекающие через 2 часа
+            threshold_time = datetime.utcnow() + timedelta(hours=2)
+            
+            result = await db.execute(
+                select(Subscription)
+                .options(selectinload(Subscription.user))
+                .where(
+                    and_(
+                        Subscription.status == SubscriptionStatus.ACTIVE.value,
+                        Subscription.is_trial == True,
+                        Subscription.end_date <= threshold_time,
+                        Subscription.end_date > datetime.utcnow()
+                    )
+                )
+            )
+            trial_expiring = result.scalars().all()
+            
+            for subscription in trial_expiring:
+                user = subscription.user
+                if not user:
+                    continue
+                
+                notification_key = f"trial_2h_{user.telegram_id}"
+                if notification_key in self._notified_users:
+                    continue  # Уже уведомляли
+                
+                if self.bot:
+                    await self._send_trial_ending_notification(user, subscription)
+                    self._notified_users.add(notification_key)
+                
+                logger.info(f"🎁 Пользователю {user.telegram_id} отправлено уведомление об окончании тестовой подписки через 2 часа")
+            
+            if trial_expiring:
+                await self._log_monitoring_event(
+                    db, "trial_expiring_notifications_sent",
+                    f"Отправлено {len(trial_expiring)} уведомлений об окончании тестовых подписок",
+                    {"count": len(trial_expiring)}
+                )
+                
+        except Exception as e:
+            logger.error(f"Ошибка проверки истекающих тестовых подписок: {e}")
+    
+    async def _get_expiring_paid_subscriptions(self, db: AsyncSession, days_before: int) -> List[Subscription]:
+        """Получение платных подписок, истекающих через указанное количество дней"""
+        threshold_date = datetime.utcnow() + timedelta(days=days_before)
+        
+        result = await db.execute(
+            select(Subscription)
+            .options(selectinload(Subscription.user))
+            .where(
+                and_(
+                    Subscription.status == SubscriptionStatus.ACTIVE.value,
+                    Subscription.is_trial == False,  # Только платные
+                    Subscription.end_date <= threshold_date,
+                    Subscription.end_date > datetime.utcnow()
+                )
+            )
+        )
+        return result.scalars().all()
+    
+    async def _process_autopayments(self, db: AsyncSession):
+        """Обработка автоплатежей"""
+        try:
+            # Исправленный запрос с использованием индивидуальных настроек
+            current_time = datetime.utcnow()
+            
+            result = await db.execute(
+                select(Subscription)
+                .options(selectinload(Subscription.user))
+                .where(
+                    and_(
+                        Subscription.status == SubscriptionStatus.ACTIVE.value,
+                        Subscription.autopay_enabled == True,
+                        Subscription.is_trial == False  # Автооплата только для платных
+                    )
+                )
+            )
+            all_autopay_subscriptions = result.scalars().all()
+            
+            # Фильтруем по времени с учетом индивидуальных настроек
+            autopay_subscriptions = []
+            for sub in all_autopay_subscriptions:
+                days_before_expiry = (sub.end_date - current_time).days
+                if days_before_expiry <= sub.autopay_days_before:
+                    autopay_subscriptions.append(sub)
+            
+            processed_count = 0
+            failed_count = 0
+            
+            for subscription in autopay_subscriptions:
+                user = subscription.user
+                if not user:
+                    continue
+                
+                renewal_cost = settings.PRICE_30_DAYS
+                
+                # Проверяем, не списывали ли уже сегодня
+                autopay_key = f"autopay_{user.telegram_id}_{subscription.id}"
+                if autopay_key in self._notified_users:
+                    continue
+                
+                if user.balance_kopeks >= renewal_cost:
+                    # Списываем средства
+                    success = await subtract_user_balance(
+                        db, user, renewal_cost,
+                        "Автопродление подписки"
+                    )
+                    
+                    if success:
+                        # Продлеваем подписку
+                        await extend_subscription(db, subscription, 30)
+                        await self.subscription_service.update_remnawave_user(db, subscription)
+                        
+                        # Уведомляем об успешном автоплатеже
+                        if self.bot:
+                            await self._send_autopay_success_notification(user, renewal_cost, 30)
+                        
+                        processed_count += 1
+                        self._notified_users.add(autopay_key)
+                        logger.info(f"💳 Автопродление подписки пользователя {user.telegram_id} успешно")
+                    else:
+                        failed_count += 1
+                        if self.bot:
+                            await self._send_autopay_failed_notification(user, user.balance_kopeks, renewal_cost)
+                        logger.warning(f"💳 Ошибка списания средств для автопродления пользователя {user.telegram_id}")
+                else:
+                    failed_count += 1
+                    # Уведомляем о недостатке средств
+                    if self.bot:
+                        await self._send_autopay_failed_notification(user, user.balance_kopeks, renewal_cost)
+                    logger.warning(f"💳 Недостаточно средств для автопродления у пользователя {user.telegram_id}")
+            
+            if processed_count > 0 or failed_count > 0:
+                await self._log_monitoring_event(
+                    db, "autopayments_processed",
+                    f"Автоплатежи: успешно {processed_count}, неудачно {failed_count}",
+                    {"processed": processed_count, "failed": failed_count}
+                )
+                
+        except Exception as e:
+            logger.error(f"Ошибка обработки автоплатежей: {e}")
+    
+    # Методы отправки уведомлений
+    async def _send_subscription_expired_notification(self, user: User):
+        """Уведомление об истечении подписки"""
+        try:
+            texts = get_texts(user.language)
+            message = texts.SUBSCRIPTION_EXPIRED
+            await self.bot.send_message(user.telegram_id, message, parse_mode="HTML")
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления об истечении подписки пользователю {user.telegram_id}: {e}")
+    
+    async def _send_subscription_expiring_notification(self, user: User, subscription: Subscription, days: int):
+        """Уведомление об истечении подписки через N дней"""
+        try:
+            texts = get_texts(user.language)
+            message = texts.SUBSCRIPTION_EXPIRING.format(days=days)
+            await self.bot.send_message(user.telegram_id, message, parse_mode="HTML")
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления об истечении подписки пользователю {user.telegram_id}: {e}")
+    
+    async def _send_trial_ending_notification(self, user: User, subscription: Subscription):
+        """Уведомление об окончании тестовой подписки через 2 часа"""
+        try:
+            texts = get_texts(user.language)
+            
+            # Создаем специальное сообщение для тестовой подписки
+            message = f"""
+🎁 <b>Тестовая подписка скоро закончится!</b>
+
+Ваша тестовая подписка истекает через 2 часа.
+
+💎 <b>Не хотите остаться без VPN?</b>
+Переходите на полную подписку со скидкой!
+
+🔥 <b>Специальное предложение:</b>
+• 30 дней всего за {settings.format_price(settings.PRICE_30_DAYS)}
+• Безлимитный трафик
+• Все серверы доступны
+• Поддержка до 3 устройств
+
+⚡️ Успейте оформить до окончания тестового периода!
+"""
+            
+            # Добавляем inline клавиатуру с кнопкой покупки
+            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+            
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="💎 Купить подписку", callback_data="buy_subscription")],
+                [InlineKeyboardButton(text="💰 Пополнить баланс", callback_data="balance_top_up")]
+            ])
+            
+            await self.bot.send_message(
+                user.telegram_id, 
+                message, 
+                parse_mode="HTML",
+                reply_markup=keyboard
+            )
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления об окончании тестовой подписки пользователю {user.telegram_id}: {e}")
+    
+    async def _send_autopay_success_notification(self, user: User, amount: int, days: int):
+        """Уведомление об успешном автоплатеже"""
+        try:
+            texts = get_texts(user.language)
+            message = texts.AUTOPAY_SUCCESS.format(
+                days=days,
+                amount=settings.format_price(amount)
+            )
+            await self.bot.send_message(user.telegram_id, message, parse_mode="HTML")
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления об автоплатеже пользователю {user.telegram_id}: {e}")
+    
+    async def _send_autopay_failed_notification(self, user: User, balance: int, required: int):
+        """Уведомление о неудачном автоплатеже"""
+        try:
+            texts = get_texts(user.language)
+            message = texts.AUTOPAY_FAILED.format(
+                balance=settings.format_price(balance),
+                required=settings.format_price(required)
+            )
+            
+            # Добавляем кнопку пополнения баланса
+            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+            
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="💰 Пополнить баланс", callback_data="balance_top_up")]
+            ])
+            
+            await self.bot.send_message(
+                user.telegram_id, 
+                message, 
+                parse_mode="HTML",
+                reply_markup=keyboard
+            )
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о неудачном автоплатеже пользователю {user.telegram_id}: {e}")
+    
+    # Остальные методы остаются без изменений...
+    async def _cleanup_inactive_users(self, db: AsyncSession):
+        try:
+            now = datetime.utcnow()
+            if now.hour != 3: 
+                return
+            
+            inactive_users = await get_inactive_users(db, settings.INACTIVE_USER_DELETE_MONTHS)
+            deleted_count = 0
+            
+            for user in inactive_users:
+                if not user.subscription or not user.subscription.is_active:
+                    success = await delete_user(db, user)
+                    if success:
+                        deleted_count += 1
+            
+            if deleted_count > 0:
+                await self._log_monitoring_event(
+                    db, "inactive_users_cleanup",
+                    f"Удалено {deleted_count} неактивных пользователей",
+                    {"deleted_count": deleted_count}
+                )
+                logger.info(f"🗑️ Удалено {deleted_count} неактивных пользователей")
+                
+        except Exception as e:
+            logger.error(f"Ошибка очистки неактивных пользователей: {e}")
+    
+    async def _sync_with_remnawave(self, db: AsyncSession):
+        try:
+            now = datetime.utcnow()
+            if now.minute != 0:
+                return
+            
+            async with self.subscription_service.api as api:
+                system_stats = await api.get_system_stats()
+                
+                await self._log_monitoring_event(
+                    db, "remnawave_sync",
+                    "Синхронизация с RemnaWave завершена",
+                    {"stats": system_stats}
+                )
+                
+        except Exception as e:
+            logger.error(f"Ошибка синхронизации с RemnaWave: {e}")
+            await self._log_monitoring_event(
+                db, "remnawave_sync_error",
+                f"Ошибка синхронизации с RemnaWave: {str(e)}",
+                {"error": str(e)},
+                is_success=False
+            )
+    
+    async def _log_monitoring_event(
+        self,
+        db: AsyncSession,
+        event_type: str,
+        message: str,
+        data: Dict[str, Any] = None,
+        is_success: bool = True
+    ):
+        try:
+            log_entry = MonitoringLog(
+                event_type=event_type,
+                message=message,
+                data=data or {},
+                is_success=is_success
+            )
+            
+            db.add(log_entry)
+            await db.commit()
+            
+        except Exception as e:
+            logger.error(f"Ошибка логирования события мониторинга: {e}")
+    
+    async def get_monitoring_status(self, db: AsyncSession) -> Dict[str, Any]:
+        try:
+            from sqlalchemy import select, desc
+            
+            recent_events_result = await db.execute(
+                select(MonitoringLog)
+                .order_by(desc(MonitoringLog.created_at))
+                .limit(10)
+            )
+            recent_events = recent_events_result.scalars().all()
+            
+            yesterday = datetime.utcnow() - timedelta(days=1)
+            
+            events_24h_result = await db.execute(
+                select(MonitoringLog)
+                .where(MonitoringLog.created_at >= yesterday)
+            )
+            events_24h = events_24h_result.scalars().all()
+            
+            successful_events = sum(1 for event in events_24h if event.is_success)
+            failed_events = sum(1 for event in events_24h if not event.is_success)
+            
+            return {
+                "is_running": self.is_running,
+                "last_update": datetime.utcnow(),
+                "recent_events": [
+                    {
+                        "type": event.event_type,
+                        "message": event.message,
+                        "success": event.is_success,
+                        "created_at": event.created_at
+                    }
+                    for event in recent_events
+                ],
+                "stats_24h": {
+                    "total_events": len(events_24h),
+                    "successful": successful_events,
+                    "failed": failed_events,
+                    "success_rate": round(successful_events / len(events_24h) * 100, 1) if events_24h else 0
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения статуса мониторинга: {e}")
+            return {
+                "is_running": self.is_running,
+                "last_update": datetime.utcnow(),
+                "recent_events": [],
+                "stats_24h": {
+                    "total_events": 0,
+                    "successful": 0,
+                    "failed": 0,
+                    "success_rate": 0
+                }
+            }
+    
+    async def force_check_subscriptions(self, db: AsyncSession) -> Dict[str, int]:
+        try:
+            # Проверяем истекшие
+            expired_subscriptions = await get_expired_subscriptions(db)
+            expired_count = 0
+            
+            for subscription in expired_subscriptions:
+                await deactivate_subscription(db, subscription)
+                expired_count += 1
+            
+            expiring_subscriptions = await get_expiring_subscriptions(db, 1)
+            expiring_count = len(expiring_subscriptions)
+            
+            autopay_subscriptions = await get_subscriptions_for_autopay(db)
+            autopay_processed = 0
+            
+            for subscription in autopay_subscriptions:
+                user = await get_user_by_id(db, subscription.user_id)
+                if user and user.balance_kopeks >= settings.PRICE_30_DAYS:
+                    autopay_processed += 1
+            
+            await self._log_monitoring_event(
+                db, "manual_check_subscriptions",
+                f"Принудительная проверка: истекло {expired_count}, истекает {expiring_count}, автоплатежей {autopay_processed}",
+                {
+                    "expired": expired_count,
+                    "expiring": expiring_count,
+                    "autopay_ready": autopay_processed
+                }
+            )
+            
+            return {
+                "expired": expired_count,
+                "expiring": expiring_count,
+                "autopay_ready": autopay_processed
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка принудительной проверки подписок: {e}")
+            return {"expired": 0, "expiring": 0, "autopay_ready": 0}
+    
+    async def get_monitoring_logs(
+        self,
+        db: AsyncSession,
+        limit: int = 50,
+        event_type: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        try:
+            from sqlalchemy import select, desc
+            
+            query = select(MonitoringLog).order_by(desc(MonitoringLog.created_at))
+            
+            if event_type:
+                query = query.where(MonitoringLog.event_type == event_type)
+            
+            query = query.limit(limit)
+            
+            result = await db.execute(query)
+            logs = result.scalars().all()
+            
+            return [
+                {
+                    "id": log.id,
+                    "event_type": log.event_type,
+                    "message": log.message,
+                    "data": log.data,
+                    "is_success": log.is_success,
+                    "created_at": log.created_at
+                }
+                for log in logs
+            ]
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения логов мониторинга: {e}")
+            return []
+    
+    async def cleanup_old_logs(self, db: AsyncSession, days: int = 30) -> int:
+        try:
+            from sqlalchemy import delete
+            
+            cutoff_date = datetime.utcnow() - timedelta(days=days)
+            
+            result = await db.execute(
+                delete(MonitoringLog).where(MonitoringLog.created_at < cutoff_date)
+            )
+            
+            deleted_count = result.rowcount
+            await db.commit()
+            
+            logger.info(f"Удалено {deleted_count} старых записей логов")
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"Ошибка очистки логов: {e}")
+            return 0
+
+
+monitoring_service = MonitoringService()

app/services/payment_service.py

@@ -0,0 +1,115 @@
+import logging
+import hashlib
+import hmac
+from typing import Optional
+from aiogram import Bot
+from aiogram.types import LabeledPrice
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class PaymentService:
+    
+    def __init__(self, bot: Optional[Bot] = None):
+        self.bot = bot
+    
+    async def create_stars_invoice(
+        self,
+        amount_kopeks: int,
+        description: str,
+        payload: Optional[str] = None
+    ) -> str:
+        
+        if not self.bot:
+            raise ValueError("Bot instance required for Stars payments")
+        
+        try:
+            stars_amount = max(1, amount_kopeks // 100)
+            
+            invoice_link = await self.bot.create_invoice_link(
+                title="Пополнение баланса VPN",
+                description=description,
+                payload=payload or f"balance_topup_{amount_kopeks}",
+                provider_token="", 
+                currency="XTR", 
+                prices=[LabeledPrice(label="Пополнение", amount=stars_amount)]
+            )
+            
+            logger.info(f"Создан Stars invoice на {stars_amount} звезд")
+            return invoice_link
+            
+        except Exception as e:
+            logger.error(f"Ошибка создания Stars invoice: {e}")
+            raise
+    
+    async def create_tribute_payment(
+        self,
+        amount_kopeks: int,
+        user_id: int,
+        description: str
+    ) -> str:
+        
+        if not settings.TRIBUTE_ENABLED:
+            raise ValueError("Tribute payments are disabled")
+        
+        try:
+            payment_data = {
+                "amount": amount_kopeks,
+                "currency": "RUB",
+                "description": description,
+                "user_id": user_id,
+                "callback_url": f"{settings.WEBHOOK_URL}/tribute/callback"
+            }
+            
+            payment_url = f"https://tribute.ru/pay?amount={amount_kopeks}&user={user_id}"
+            
+            logger.info(f"Создан Tribute платеж на {amount_kopeks/100}₽ для пользователя {user_id}")
+            return payment_url
+            
+        except Exception as e:
+            logger.error(f"Ошибка создания Tribute платежа: {e}")
+            raise
+    
+    def verify_tribute_webhook(
+        self,
+        data: dict,
+        signature: str
+    ) -> bool:
+        
+        if not settings.TRIBUTE_WEBHOOK_SECRET:
+            return False
+        
+        try:
+            message = str(data).encode()
+            expected_signature = hmac.new(
+                settings.TRIBUTE_WEBHOOK_SECRET.encode(),
+                message,
+                hashlib.sha256
+            ).hexdigest()
+            
+            return hmac.compare_digest(signature, expected_signature)
+            
+        except Exception as e:
+            logger.error(f"Ошибка проверки Tribute webhook: {e}")
+            return False
+    
+    async def process_successful_payment(
+        self,
+        payment_id: str,
+        amount_kopeks: int,
+        user_id: int,
+        payment_method: str
+    ) -> bool:
+        
+        try:
+            # Здесь должна быть логика обработки платежа
+            # Например, пополнение баланса пользователя
+            
+            logger.info(f"Обработан успешный платеж: {payment_id}, {amount_kopeks/100}₽, {user_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка обработки платежа: {e}")
+            return False

app/services/promocode_service.py

@@ -0,0 +1,117 @@
+import logging
+from datetime import datetime
+from typing import Dict, Any
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.promocode import (
+    get_promocode_by_code, use_promocode, check_user_promocode_usage,
+    create_promocode_use, get_promocode_use_by_user_and_code
+)
+from app.database.crud.user import add_user_balance, get_user_by_id
+from app.database.crud.subscription import extend_subscription, get_subscription_by_user_id
+from app.database.models import PromoCodeType, SubscriptionStatus, User, PromoCode
+from app.services.remnawave_service import RemnaWaveService
+from app.services.subscription_service import SubscriptionService
+
+logger = logging.getLogger(__name__)
+
+
+class PromoCodeService:
+    
+    def __init__(self):
+        self.remnawave_service = RemnaWaveService()
+        self.subscription_service = SubscriptionService()
+    
+    async def activate_promocode(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        code: str
+    ) -> Dict[str, Any]:
+        
+        try:
+            user = await get_user_by_id(db, user_id)
+            if not user:
+                return {"success": False, "error": "user_not_found"}
+            
+            promocode = await get_promocode_by_code(db, code)
+            if not promocode:
+                return {"success": False, "error": "not_found"}
+            
+            if not promocode.is_valid:
+                if promocode.current_uses >= promocode.max_uses:
+                    return {"success": False, "error": "used"}
+                else:
+                    return {"success": False, "error": "expired"}
+            
+            existing_use = await check_user_promocode_usage(db, user_id, promocode.id)
+            if existing_use:
+                return {"success": False, "error": "already_used_by_user"}
+            
+            result_description = await self._apply_promocode_effects(db, user, promocode)
+            
+            if promocode.type == PromoCodeType.SUBSCRIPTION_DAYS.value and promocode.subscription_days > 0:
+                from app.utils.user_utils import mark_user_as_had_paid_subscription
+                await mark_user_as_had_paid_subscription(db, user)
+                
+                logger.info(f"🎯 Пользователь {user.telegram_id} получил платную подписку через промокод {code}")
+            
+            await create_promocode_use(db, promocode.id, user_id)
+            
+            promocode.current_uses += 1
+            await db.commit()
+            
+            logger.info(f"✅ Пользователь {user.telegram_id} активировал промокод {code}")
+            
+            return {
+                "success": True,
+                "description": result_description
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка активации промокода {code} для пользователя {user_id}: {e}")
+            await db.rollback()
+            return {"success": False, "error": "server_error"}
+
+    async def _apply_promocode_effects(self, db: AsyncSession, user: User, promocode: PromoCode) -> str:
+        effects = []
+        
+        if promocode.balance_bonus_kopeks > 0:
+            await add_user_balance(
+                db, user, promocode.balance_bonus_kopeks,
+                f"Бонус по промокоду {promocode.code}"
+            )
+            
+            balance_bonus_rubles = promocode.balance_bonus_kopeks / 100
+            effects.append(f"💰 Баланс пополнен на {balance_bonus_rubles}₽")
+        
+        if promocode.subscription_days > 0:
+            from app.database.crud.subscription import create_paid_subscription
+            
+            subscription = await get_subscription_by_user_id(db, user.id)
+            
+            if subscription:
+                await extend_subscription(db, subscription, promocode.subscription_days)
+                effects.append(f"⏰ Подписка продлена на {promocode.subscription_days} дней")
+            else:
+                await create_paid_subscription(
+                    db=db,
+                    user_id=user.id,
+                    duration_days=promocode.subscription_days,
+                    traffic_limit_gb=0,
+                    device_limit=1,
+                    connected_squads=[]
+                )
+                effects.append(f"🎉 Получена подписка на {promocode.subscription_days} дней")
+        
+        if promocode.type == PromoCodeType.TRIAL_SUBSCRIPTION.value:
+            from app.database.crud.subscription import create_trial_subscription
+            
+            subscription = await get_subscription_by_user_id(db, user.id)
+            if not subscription and not user.has_had_paid_subscription:
+                await create_trial_subscription(db, user.id)
+                effects.append("🎁 Активирована тестовая подписка")
+            else:
+                effects.append("ℹ️ Тестовая подписка уже недоступна")
+        
+        return "\n".join(effects) if effects else "✅ Промокод активирован"

app/services/referral_service.py

@@ -0,0 +1,174 @@
+import logging
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.crud.user import add_user_balance, get_user_by_id
+from app.database.crud.referral import create_referral_earning
+from app.database.models import TransactionType
+
+logger = logging.getLogger(__name__)
+
+
+async def process_referral_registration(
+    db: AsyncSession,
+    new_user_id: int,
+    referrer_id: int
+):
+    
+    try:
+        new_user = await get_user_by_id(db, new_user_id)
+        referrer = await get_user_by_id(db, referrer_id)
+        
+        if not new_user or not referrer:
+            logger.error(f"Пользователи не найдены: {new_user_id}, {referrer_id}")
+            return False
+        
+        if new_user.referred_by_id != referrer_id:
+            logger.error(f"Пользователь {new_user_id} не привязан к рефереру {referrer_id}")
+            return False
+        
+        if settings.REFERRED_USER_REWARD > 0:
+            await add_user_balance(
+                db, new_user, settings.REFERRED_USER_REWARD,
+                f"Бонус за регистрацию по реферальной ссылке"
+            )
+            
+            logger.info(f"💰 Новый пользователь {new_user_id} получил бонус {settings.REFERRED_USER_REWARD/100}₽")
+        
+        await create_referral_earning(
+            db=db,
+            user_id=referrer_id,
+            referral_id=new_user_id,
+            amount_kopeks=0,
+            reason="referral_registration_pending"
+        )
+        
+        logger.info(f"✅ Обработана реферальная регистрация: {new_user_id} -> {referrer_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка обработки реферальной регистрации: {e}")
+        return False
+
+
+async def process_referral_purchase(
+    db: AsyncSession,
+    user_id: int,
+    purchase_amount_kopeks: int,
+    transaction_id: int = None
+):
+    
+    try:
+        user = await get_user_by_id(db, user_id)
+        if not user or not user.referred_by_id:
+            logger.info(f"Пользователь {user_id} не является рефералом")
+            return False
+        
+        referrer = await get_user_by_id(db, user.referred_by_id)
+        if not referrer:
+            logger.error(f"Реферер {user.referred_by_id} не найден")
+            return False
+        
+        from app.database.crud.referral import get_referral_earnings_by_referral
+        existing_earnings = await get_referral_earnings_by_referral(db, user_id)
+        
+        purchase_earnings = [
+            earning for earning in existing_earnings 
+            if earning.reason in ["referral_first_purchase", "referral_commission"]
+        ]
+        
+        is_first_purchase = len(purchase_earnings) == 0
+        
+        logger.info(f"🔍 Покупка реферала {user_id}: первая = {is_first_purchase}, сумма = {purchase_amount_kopeks/100}₽")
+        
+        if is_first_purchase:
+            reward_amount = settings.REFERRAL_REGISTRATION_REWARD
+            
+            await add_user_balance(
+                db, referrer, reward_amount,
+                f"Реферальная награда за первую покупку {user.full_name}"
+            )
+            
+            await create_referral_earning(
+                db=db,
+                user_id=referrer.id,
+                referral_id=user_id,
+                amount_kopeks=reward_amount,
+                reason="referral_first_purchase",
+                referral_transaction_id=transaction_id
+            )
+            
+            logger.info(f"🎉 Первая покупка реферала: {referrer.telegram_id} получил {reward_amount/100}₽")
+        
+        commission_amount = int(purchase_amount_kopeks * settings.REFERRAL_COMMISSION_PERCENT / 100)
+        
+        if commission_amount > 0:
+            await add_user_balance(
+                db, referrer, commission_amount,
+                f"Комиссия {settings.REFERRAL_COMMISSION_PERCENT}% с покупки {user.full_name}"
+            )
+            
+            await create_referral_earning(
+                db=db,
+                user_id=referrer.id,
+                referral_id=user_id,
+                amount_kopeks=commission_amount,
+                reason="referral_commission",
+                referral_transaction_id=transaction_id
+            )
+            
+            logger.info(f"💰 Комиссия с покупки: {referrer.telegram_id} получил {commission_amount/100}₽")
+        
+        if not user.has_had_paid_subscription:
+            user.has_had_paid_subscription = True
+            await db.commit()
+            logger.info(f"✅ Пользователь {user_id} отмечен как имевший платную подписку")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка обработки покупки реферала: {e}")
+        return False
+
+
+async def get_referral_stats_for_user(db: AsyncSession, user_id: int) -> dict:
+    
+    try:
+        from app.database.crud.referral import get_referral_earnings_sum
+        from sqlalchemy import select, func
+        from app.database.models import User
+        
+        invited_count_result = await db.execute(
+            select(func.count(User.id)).where(User.referred_by_id == user_id)
+        )
+        invited_count = invited_count_result.scalar()
+        
+        paid_referrals_result = await db.execute(
+            select(func.count(User.id)).where(
+                User.referred_by_id == user_id,
+                User.has_had_paid_subscription == True
+            )
+        )
+        paid_referrals_count = paid_referrals_result.scalar()
+        
+        total_earned = await get_referral_earnings_sum(db, user_id)
+        
+        from datetime import datetime, timedelta
+        month_ago = datetime.utcnow() - timedelta(days=30)
+        month_earned = await get_referral_earnings_sum(db, user_id, start_date=month_ago)
+        
+        return {
+            "invited_count": invited_count,
+            "paid_referrals_count": paid_referrals_count,
+            "total_earned_kopeks": total_earned,
+            "month_earned_kopeks": month_earned
+        }
+        
+    except Exception as e:
+        logger.error(f"Ошибка получения статистики рефералов: {e}")
+        return {
+            "invited_count": 0,
+            "paid_referrals_count": 0,
+            "total_earned_kopeks": 0,
+            "month_earned_kopeks": 0
+        }

app/services/subscription_service.py

@@ -0,0 +1,240 @@
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List, Tuple
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import Subscription, User
+from app.external.remnawave_api import (
+    RemnaWaveAPI, RemnaWaveUser, UserStatus, 
+    TrafficLimitStrategy, RemnaWaveAPIError
+)
+from app.database.crud.user import get_user_by_id
+
+logger = logging.getLogger(__name__)
+
+
+class SubscriptionService:
+    
+    def __init__(self):
+        self.api = RemnaWaveAPI(
+            base_url=settings.REMNAWAVE_API_URL,
+            api_key=settings.REMNAWAVE_API_KEY
+        )
+    
+    async def create_remnawave_user(
+        self, 
+        db: AsyncSession, 
+        subscription: Subscription
+    ) -> Optional[RemnaWaveUser]:
+        
+        try:
+            user = await get_user_by_id(db, subscription.user_id)
+            if not user:
+                logger.error(f"Пользователь {subscription.user_id} не найден")
+                return None
+            
+            async with self.api as api:
+                existing_users = await api.get_user_by_telegram_id(user.telegram_id)
+                if existing_users:
+                    remnawave_user = existing_users[0]
+                    updated_user = await api.update_user(
+                        uuid=remnawave_user.uuid,
+                        status=UserStatus.ACTIVE,
+                        expire_at=subscription.end_date,
+                        traffic_limit_bytes=self._gb_to_bytes(subscription.traffic_limit_gb),
+                        traffic_limit_strategy=TrafficLimitStrategy.MONTH,
+                        hwid_device_limit=subscription.device_limit,
+                        active_internal_squads=subscription.connected_squads
+                    )
+                else:
+                    username = f"user_{user.telegram_id}"
+                    updated_user = await api.create_user(
+                        username=username,
+                        expire_at=subscription.end_date,
+                        status=UserStatus.ACTIVE,
+                        traffic_limit_bytes=self._gb_to_bytes(subscription.traffic_limit_gb),
+                        traffic_limit_strategy=TrafficLimitStrategy.MONTH,
+                        telegram_id=user.telegram_id,
+                        hwid_device_limit=subscription.device_limit,
+                        description=f"Bot user: {user.full_name}",
+                        active_internal_squads=subscription.connected_squads
+                    )
+                
+                subscription.remnawave_short_uuid = updated_user.short_uuid
+                subscription.subscription_url = updated_user.subscription_url 
+                user.remnawave_uuid = updated_user.uuid
+                
+                await db.commit()
+                
+                logger.info(f"✅ Создан RemnaWave пользователь для подписки {subscription.id}")
+                logger.info(f"🔗 Ссылка на подписку: {updated_user.subscription_url}")
+                logger.info(f"📊 Стратегия сброса трафика: MONTH") 
+                return updated_user
+                
+        except RemnaWaveAPIError as e:
+            logger.error(f"Ошибка RemnaWave API: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Ошибка создания RemnaWave пользователя: {e}")
+            return None
+    
+    async def update_remnawave_user(
+        self,
+        db: AsyncSession,
+        subscription: Subscription
+    ) -> Optional[RemnaWaveUser]:
+        
+        try:
+            user = await get_user_by_id(db, subscription.user_id)
+            if not user or not user.remnawave_uuid:
+                logger.error(f"RemnaWave UUID не найден для пользователя {subscription.user_id}")
+                return None
+            
+            async with self.api as api:
+                updated_user = await api.update_user(
+                    uuid=user.remnawave_uuid,
+                    status=UserStatus.ACTIVE if subscription.is_active else UserStatus.EXPIRED,
+                    expire_at=subscription.end_date,
+                    traffic_limit_bytes=self._gb_to_bytes(subscription.traffic_limit_gb),
+                    traffic_limit_strategy=TrafficLimitStrategy.MONTH, 
+                    hwid_device_limit=subscription.device_limit,
+                    active_internal_squads=subscription.connected_squads
+                )
+                
+                subscription.subscription_url = updated_user.subscription_url
+                await db.commit()
+                
+                logger.info(f"✅ Обновлен RemnaWave пользователь {user.remnawave_uuid}")
+                logger.info(f"📊 Стратегия сброса трафика: MONTH") 
+                return updated_user
+                
+        except RemnaWaveAPIError as e:
+            logger.error(f"Ошибка обновления RemnaWave пользователя: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Ошибка обновления RemnaWave пользователя: {e}")
+            return None
+    
+    async def disable_remnawave_user(self, user_uuid: str) -> bool:
+        
+        try:
+            async with self.api as api:
+                await api.disable_user(user_uuid)
+                logger.info(f"✅ Отключен RemnaWave пользователь {user_uuid}")
+                return True
+                
+        except Exception as e:
+            logger.error(f"Ошибка отключения RemnaWave пользователя: {e}")
+            return False
+    
+    async def revoke_subscription(
+        self,
+        db: AsyncSession,
+        subscription: Subscription
+    ) -> Optional[str]:
+        
+        try:
+            user = await get_user_by_id(db, subscription.user_id)
+            if not user or not user.remnawave_uuid:
+                return None
+            
+            async with self.api as api:
+                updated_user = await api.revoke_user_subscription(user.remnawave_uuid)
+                
+                subscription.remnawave_short_uuid = updated_user.short_uuid
+                subscription.subscription_url = updated_user.subscription_url
+                await db.commit()
+                
+                logger.info(f"✅ Обновлена ссылка подписки для пользователя {user.telegram_id}")
+                return updated_user.subscription_url
+                
+        except Exception as e:
+            logger.error(f"Ошибка обновления ссылки подписки: {e}")
+            return None
+    
+    async def get_subscription_info(self, short_uuid: str) -> Optional[dict]:
+        
+        try:
+            async with self.api as api:
+                info = await api.get_subscription_info(short_uuid)
+                return info
+                
+        except Exception as e:
+            logger.error(f"Ошибка получения информации о подписке: {e}")
+            return None
+    
+    async def sync_subscription_usage(
+        self,
+        db: AsyncSession,
+        subscription: Subscription
+    ) -> bool:
+        
+        try:
+            user = await get_user_by_id(db, subscription.user_id)
+            if not user or not user.remnawave_uuid:
+                return False
+            
+            async with self.api as api:
+                remnawave_user = await api.get_user_by_uuid(user.remnawave_uuid)
+                if not remnawave_user:
+                    return False
+                
+                used_gb = self._bytes_to_gb(remnawave_user.used_traffic_bytes)
+                subscription.traffic_used_gb = used_gb
+                
+                await db.commit()
+                
+                logger.debug(f"Синхронизирован трафик для подписки {subscription.id}: {used_gb} ГБ")
+                return True
+                
+        except Exception as e:
+            logger.error(f"Ошибка синхронизации трафика: {e}")
+            return False
+    
+    async def calculate_subscription_price(
+        self,
+        period_days: int,
+        traffic_gb: int,
+        server_squad_ids: List[int], 
+        devices: int,
+        db: AsyncSession 
+    ) -> Tuple[int, List[int]]:
+    
+        from app.config import PERIOD_PRICES, TRAFFIC_PRICES
+        from app.database.crud.server_squad import get_server_squad_by_id
+    
+        base_price = PERIOD_PRICES.get(period_days, 0)
+        traffic_price = TRAFFIC_PRICES.get(traffic_gb, 0)
+    
+        server_prices = []
+        total_servers_price = 0
+    
+        for server_id in server_squad_ids:
+            server = await get_server_squad_by_id(db, server_id)
+            if server and server.is_available and not server.is_full:
+                server_prices.append(server.price_kopeks)
+                total_servers_price += server.price_kopeks
+            else:
+                server_prices.append(0)
+    
+        devices_price = max(0, devices - 1) * settings.PRICE_PER_DEVICE
+        
+        total_price = base_price + traffic_price + total_servers_price + devices_price
+        return total_price, server_prices
+    
+    async def _get_countries_price(self, country_uuids: List[str]) -> int:
+        # TODO: Реализовать получение цен из базы данных сквадов
+        # Пока возвращаем базовую логику
+        price_per_country = 1000 
+        return len(country_uuids) * price_per_country
+    
+    def _gb_to_bytes(self, gb: int) -> int:
+        if gb == 0: 
+            return 0
+        return gb * 1024 * 1024 * 1024
+    
+    def _bytes_to_gb(self, bytes_value: int) -> float:
+        if bytes_value == 0:
+            return 0.0
+        return bytes_value / (1024 * 1024 * 1024)

app/services/tribute_service.py

@@ -0,0 +1,284 @@
+import logging
+import hashlib
+import hmac
+import json
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+from aiogram import Bot
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.database import get_db
+from app.database.models import Transaction, TransactionType, PaymentMethod
+from app.database.crud.transaction import (
+    create_transaction, get_transaction_by_external_id, complete_transaction
+)
+from app.database.crud.user import get_user_by_telegram_id, add_user_balance
+from app.external.tribute import TributeService as TributeAPI
+
+logger = logging.getLogger(__name__)
+
+
+class TributeService:
+    
+    def __init__(self, bot: Bot):
+        self.bot = bot
+        self.tribute_api = TributeAPI()
+    
+    async def create_payment_link(
+        self,
+        user_id: int,
+        amount_kopeks: int,
+        description: str = "Пополнение баланса"
+    ) -> Optional[str]:
+        
+        if not settings.TRIBUTE_ENABLED:
+            logger.warning("Tribute платежи отключены")
+            return None
+        
+        try:
+            payment_url = await self.tribute_api.create_payment_link(
+                user_id=user_id,
+                amount_kopeks=amount_kopeks,
+                description=description
+            )
+            
+            if not payment_url:
+                return None
+            
+            
+            return payment_url
+            
+        except Exception as e:
+            logger.error(f"Ошибка создания Tribute платежа: {e}")
+            return None
+    
+    async def process_webhook(
+        self,
+        payload: str,
+        signature: Optional[str] = None
+    ) -> Dict[str, Any]:
+        
+        if signature and settings.TRIBUTE_WEBHOOK_SECRET:
+            if not self.tribute_api.verify_webhook_signature(payload, signature):
+                logger.warning("Неверная подпись Tribute webhook")
+                return {"status": "error", "reason": "invalid_signature"}
+        
+        try:
+            webhook_data = json.loads(payload)
+        except json.JSONDecodeError:
+            logger.error("Некорректный JSON в Tribute webhook")
+            return {"status": "error", "reason": "invalid_json"}
+        
+        logger.info(f"Получен Tribute webhook: {json.dumps(webhook_data, ensure_ascii=False)}")
+        
+        processed_data = await self.tribute_api.process_webhook(webhook_data)
+        if not processed_data:
+            return {"status": "ignored", "reason": "invalid_data"}
+        
+        event_type = processed_data.get("event_type", "payment")
+        status = processed_data.get("status")
+        
+        if event_type == "payment" and status == "paid":
+            await self._handle_successful_payment(processed_data)
+        elif event_type == "payment" and status == "failed":
+            await self._handle_failed_payment(processed_data)
+        elif event_type == "refund":
+            await self._handle_refund(processed_data)
+        
+        return {"status": "ok", "event": event_type}
+    
+    async def _handle_successful_payment(self, payment_data: Dict[str, Any]):
+        
+        try:
+            user_id = payment_data["user_id"]
+            amount_kopeks = payment_data["amount_kopeks"]
+            payment_id = payment_data["payment_id"]
+            
+            async for session in get_db():
+                existing_transaction = await get_transaction_by_external_id(
+                    session, f"donation_{payment_id}", PaymentMethod.TRIBUTE
+                )
+                
+                if existing_transaction:
+                    logger.warning(f"Транзакция с donation_request_id {payment_id} уже существует")
+                    return
+                
+                user = await get_user_by_telegram_id(session, user_id)
+                if not user:
+                    logger.error(f"Пользователь {user_id} не найден")
+                    return
+                
+                transaction = await create_transaction(
+                    db=session,
+                    user_id=user.id, 
+                    type=TransactionType.DEPOSIT,
+                    amount_kopeks=amount_kopeks,
+                    description=f"Пополнение через Tribute: {amount_kopeks/100}₽",
+                    payment_method=PaymentMethod.TRIBUTE,
+                    external_id=f"donation_{payment_id}",
+                    is_completed=True
+                )
+                
+                user.balance_kopeks += amount_kopeks
+                await session.commit()
+                
+                await self._send_success_notification(user_id, amount_kopeks)
+                
+                logger.info(f"Успешно обработан Tribute платеж: {amount_kopeks/100}₽ для пользователя {user_id}")
+                break
+                
+        except Exception as e:
+            logger.error(f"Ошибка обработки успешного Tribute платежа: {e}")
+    
+    async def _handle_failed_payment(self, payment_data: Dict[str, Any]):
+        
+        try:
+            user_id = payment_data["user_id"]
+            payment_id = payment_data["payment_id"]
+            
+            async for session in get_db():
+                transaction = await get_transaction_by_external_id(
+                    session, payment_id, PaymentMethod.TRIBUTE
+                )
+                
+                if transaction:
+                    transaction.description = f"{transaction.description} (платеж отклонен)"
+                    await session.commit()
+                
+                await self._send_failure_notification(user_id)
+                
+                logger.info(f"Обработан неудачный Tribute платеж для пользователя {user_id}")
+                break
+                
+        except Exception as e:
+            logger.error(f"Ошибка обработки неудачного Tribute платежа: {e}")
+    
+    async def _handle_refund(self, refund_data: Dict[str, Any]):
+        
+        try:
+            user_id = refund_data["user_id"]
+            amount_kopeks = refund_data["amount_kopeks"]
+            payment_id = refund_data["payment_id"]
+            
+            async for session in get_db():
+                await create_transaction(
+                    db=session,
+                    user_id=user_id,
+                    type=TransactionType.REFUND,
+                    amount_kopeks=-amount_kopeks, 
+                    description=f"Возврат Tribute платежа {payment_id}",
+                    payment_method=PaymentMethod.TRIBUTE,
+                    external_id=f"refund_{payment_id}",
+                    is_completed=True
+                )
+                
+                user = await get_user_by_telegram_id(session, user_id)
+                if user and user.balance_kopeks >= amount_kopeks:
+                    user.balance_kopeks -= amount_kopeks
+                    await session.commit()
+                
+                await self._send_refund_notification(user_id, amount_kopeks)
+                
+                logger.info(f"Обработан возврат Tribute: {amount_kopeks/100}₽ для пользователя {user_id}")
+                break
+                
+        except Exception as e:
+            logger.error(f"Ошибка обработки возврата Tribute: {e}")
+    
+    async def _send_success_notification(self, user_id: int, amount_kopeks: int):
+        
+        try:
+            amount_rubles = amount_kopeks / 100
+            
+            text = (
+                f"✅ **Платеж успешно получен!**\n\n"
+                f"💰 Сумма: {amount_rubles:.2f} ₽\n"
+                f"💳 Способ оплаты: Tribute\n"
+                f"🎉 Средства зачислены на баланс!\n\n"
+                f"Спасибо за оплату! 🙏"
+            )
+            
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="💰 Мой баланс", callback_data="menu_balance")],
+                [InlineKeyboardButton(text="🏠 Главное меню", callback_data="back_to_menu")]
+            ])
+            
+            await self.bot.send_message(
+                user_id,
+                text,
+                reply_markup=keyboard,
+                parse_mode="Markdown"
+            )
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления об успешном платеже: {e}")
+    
+    async def _send_failure_notification(self, user_id: int):
+        
+        try:
+            text = (
+                "❌ **Платеж не прошел**\n\n"
+                "К сожалению, ваш платеж через Tribute был отклонен.\n\n"
+                "Возможные причины:\n"
+                "• Недостаточно средств на карте\n"
+                "• Технические проблемы банка\n"
+                "• Превышен лимит операций\n\n"
+                "Попробуйте еще раз или обратитесь в поддержку."
+            )
+            
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="🔄 Попробовать снова", callback_data="menu_balance")],
+                [InlineKeyboardButton(text="💬 Поддержка", callback_data="menu_support")]
+            ])
+            
+            await self.bot.send_message(
+                user_id,
+                text,
+                reply_markup=keyboard,
+                parse_mode="Markdown"
+            )
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о неудачном платеже: {e}")
+    
+    async def _send_refund_notification(self, user_id: int, amount_kopeks: int):
+        
+        try:
+            amount_rubles = amount_kopeks / 100
+            
+            text = (
+                f"🔄 **Возврат средств**\n\n"
+                f"💰 Сумма возврата: {amount_rubles:.2f} ₽\n"
+                f"💳 Способ: Tribute\n\n"
+                f"Средства будут возвращены на вашу карту в течение 3-5 рабочих дней.\n\n"
+                f"Если у вас есть вопросы, обратитесь в поддержку."
+            )
+            
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="💬 Поддержка", callback_data="menu_support")],
+                [InlineKeyboardButton(text="🏠 Главное меню", callback_data="back_to_menu")]
+            ])
+            
+            await self.bot.send_message(
+                user_id,
+                text,
+                reply_markup=keyboard,
+                parse_mode="Markdown"
+            )
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления о возврате: {e}")
+    
+    async def get_payment_status(self, payment_id: str) -> Optional[Dict[str, Any]]:
+        return await self.tribute_api.get_payment_status(payment_id)
+    
+    async def create_refund(
+        self,
+        payment_id: str,
+        amount_kopeks: Optional[int] = None,
+        reason: str = "Возврат по запросу"
+    ) -> Optional[Dict[str, Any]]:
+        return await self.tribute_api.refund_payment(payment_id, amount_kopeks, reason)

app/services/user_service.py

@@ -0,0 +1,333 @@
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict, Any
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database.crud.user import (
+    get_user_by_id, get_user_by_telegram_id, get_users_list,
+    get_users_count, get_users_statistics, get_inactive_users,
+    add_user_balance, subtract_user_balance, update_user, delete_user
+)
+from app.database.crud.transaction import get_user_transactions_count
+from app.database.crud.subscription import get_subscription_by_user_id
+from app.database.models import User, UserStatus
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class UserService:
+    
+    async def get_user_profile(
+        self, 
+        db: AsyncSession, 
+        user_id: int
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            user = await get_user_by_id(db, user_id)
+            if not user:
+                return None
+            
+            subscription = await get_subscription_by_user_id(db, user_id)
+            transactions_count = await get_user_transactions_count(db, user_id)
+            
+            return {
+                "user": user,
+                "subscription": subscription,
+                "transactions_count": transactions_count,
+                "is_admin": settings.is_admin(user.telegram_id),
+                "registration_days": (datetime.utcnow() - user.created_at).days
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения профиля пользователя {user_id}: {e}")
+            return None
+    
+    async def search_users(
+        self,
+        db: AsyncSession,
+        query: str,
+        page: int = 1,
+        limit: int = 20
+    ) -> Dict[str, Any]:
+        try:
+            offset = (page - 1) * limit
+            
+            users = await get_users_list(
+                db, offset=offset, limit=limit, search=query
+            )
+            total_count = await get_users_count(db, search=query)
+            
+            total_pages = (total_count + limit - 1) // limit
+            
+            return {
+                "users": users,
+                "current_page": page,
+                "total_pages": total_pages,
+                "total_count": total_count,
+                "has_next": page < total_pages,
+                "has_prev": page > 1
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка поиска пользователей: {e}")
+            return {
+                "users": [],
+                "current_page": 1,
+                "total_pages": 1,
+                "total_count": 0,
+                "has_next": False,
+                "has_prev": False
+            }
+    
+    async def get_users_page(
+        self,
+        db: AsyncSession,
+        page: int = 1,
+        limit: int = 20,
+        status: Optional[UserStatus] = None
+    ) -> Dict[str, Any]:
+        try:
+            offset = (page - 1) * limit
+            
+            users = await get_users_list(
+                db, offset=offset, limit=limit, status=status
+            )
+            total_count = await get_users_count(db, status=status)
+            
+            total_pages = (total_count + limit - 1) // limit
+            
+            return {
+                "users": users,
+                "current_page": page,
+                "total_pages": total_pages,
+                "total_count": total_count,
+                "has_next": page < total_pages,
+                "has_prev": page > 1
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения страницы пользователей: {e}")
+            return {
+                "users": [],
+                "current_page": 1,
+                "total_pages": 1,
+                "total_count": 0,
+                "has_next": False,
+                "has_prev": False
+            }
+    
+    async def update_user_balance(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        amount_kopeks: int,
+        description: str,
+        admin_id: int
+    ) -> bool:
+        try:
+            user = await get_user_by_id(db, user_id)
+            if not user:
+                return False
+            
+            if amount_kopeks > 0:
+                await add_user_balance(db, user, amount_kopeks, description)
+                logger.info(f"Админ {admin_id} пополнил баланс пользователя {user_id} на {amount_kopeks/100}₽")
+            else:
+                success = await subtract_user_balance(db, user, abs(amount_kopeks), description)
+                if success:
+                    logger.info(f"Админ {admin_id} списал с баланса пользователя {user_id} {abs(amount_kopeks)/100}₽")
+                return success
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка изменения баланса пользователя: {e}")
+            return False
+    
+    async def block_user(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        admin_id: int,
+        reason: str = "Заблокирован администратором"
+    ) -> bool:
+        try:
+            user = await get_user_by_id(db, user_id)
+            if not user:
+                return False
+            
+            await update_user(db, user, status=UserStatus.BLOCKED.value)
+            
+            logger.info(f"Админ {admin_id} заблокировал пользователя {user_id}: {reason}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка блокировки пользователя: {e}")
+            return False
+    
+    async def unblock_user(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        admin_id: int
+    ) -> bool:
+        try:
+            user = await get_user_by_id(db, user_id)
+            if not user:
+                return False
+            
+            await update_user(db, user, status=UserStatus.ACTIVE.value)
+            
+            logger.info(f"Админ {admin_id} разблокировал пользователя {user_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка разблокировки пользователя: {e}")
+            return False
+    
+    async def delete_user_account(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        admin_id: int
+    ) -> bool:
+        try:
+            user = await get_user_by_id(db, user_id)
+            if not user:
+                return False
+            
+            success = await delete_user(db, user)
+            
+            if success:
+                logger.info(f"Админ {admin_id} удалил пользователя {user_id}")
+            
+            return success
+            
+        except Exception as e:
+            logger.error(f"Ошибка удаления пользователя: {e}")
+            return False
+    
+    async def get_user_statistics(self, db: AsyncSession) -> Dict[str, Any]:
+        try:
+            stats = await get_users_statistics(db)
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения статистики пользователей: {e}")
+            return {
+                "total_users": 0,
+                "active_users": 0,
+                "blocked_users": 0,
+                "new_today": 0,
+                "new_week": 0,
+                "new_month": 0
+            }
+    
+    async def cleanup_inactive_users(
+        self,
+        db: AsyncSession,
+        months: int = None
+    ) -> int:
+        try:
+            if months is None:
+                months = settings.INACTIVE_USER_DELETE_MONTHS
+            
+            inactive_users = await get_inactive_users(db, months)
+            deleted_count = 0
+            
+            for user in inactive_users:
+                success = await delete_user(db, user)
+                if success:
+                    deleted_count += 1
+            
+            logger.info(f"Удалено {deleted_count} неактивных пользователей")
+            return deleted_count
+            
+        except Exception as e:
+            logger.error(f"Ошибка очистки неактивных пользователей: {e}")
+            return 0
+    
+    async def get_user_activity_summary(
+        self,
+        db: AsyncSession,
+        user_id: int
+    ) -> Dict[str, Any]:
+        try:
+            user = await get_user_by_id(db, user_id)
+            if not user:
+                return {}
+            
+            subscription = await get_subscription_by_user_id(db, user_id)
+            transactions_count = await get_user_transactions_count(db, user_id)
+            
+            days_since_registration = (datetime.utcnow() - user.created_at).days
+            
+            days_since_activity = (datetime.utcnow() - user.last_activity).days if user.last_activity else None
+            
+            return {
+                "user_id": user.id,
+                "telegram_id": user.telegram_id,
+                "username": user.username,
+                "full_name": user.full_name,
+                "status": user.status,
+                "language": user.language,
+                "balance_kopeks": user.balance_kopeks,
+                "registration_date": user.created_at,
+                "last_activity": user.last_activity,
+                "days_since_registration": days_since_registration,
+                "days_since_activity": days_since_activity,
+                "has_subscription": subscription is not None,
+                "subscription_active": subscription.is_active if subscription else False,
+                "subscription_trial": subscription.is_trial if subscription else False,
+                "transactions_count": transactions_count,
+                "referrer_id": user.referrer_id,
+                "referral_code": user.referral_code
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения сводки активности пользователя {user_id}: {e}")
+            return {}
+    
+    async def get_users_by_criteria(
+        self,
+        db: AsyncSession,
+        criteria: Dict[str, Any]
+    ) -> List[User]:
+        try:
+            status = criteria.get('status')
+            has_subscription = criteria.get('has_subscription')
+            is_trial = criteria.get('is_trial')
+            min_balance = criteria.get('min_balance', 0)
+            max_balance = criteria.get('max_balance')
+            days_inactive = criteria.get('days_inactive')
+            
+            registered_after = criteria.get('registered_after')
+            registered_before = criteria.get('registered_before')
+            
+            users = await get_users_list(db, offset=0, limit=10000, status=status)
+            
+            filtered_users = []
+            for user in users:
+                if user.balance_kopeks < min_balance:
+                    continue
+                if max_balance and user.balance_kopeks > max_balance:
+                    continue
+                
+                if registered_after and user.created_at < registered_after:
+                    continue
+                if registered_before and user.created_at > registered_before:
+                    continue
+                
+                if days_inactive and user.last_activity:
+                    inactive_threshold = datetime.utcnow() - timedelta(days=days_inactive)
+                    if user.last_activity > inactive_threshold:
+                        continue
+                
+                filtered_users.append(user)
+            
+            return filtered_users
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения пользователей по критериям: {e}")
+            return []

app/states.py

@@ -0,0 +1,82 @@
+from aiogram.fsm.state import State, StatesGroup
+
+
+class RegistrationStates(StatesGroup):
+    waiting_for_rules_accept = State()
+    waiting_for_referral_code = State()
+
+
+class SubscriptionStates(StatesGroup):
+    selecting_period = State()
+    selecting_traffic = State()
+    selecting_countries = State()
+    selecting_devices = State()
+    confirming_purchase = State()
+    
+    adding_countries = State()
+    adding_traffic = State()
+    adding_devices = State()
+    extending_subscription = State()
+    confirming_traffic_reset = State()
+
+
+class BalanceStates(StatesGroup):
+    waiting_for_amount = State()
+    waiting_for_stars_payment = State()
+    waiting_for_support_request = State()
+
+
+class PromoCodeStates(StatesGroup):
+    waiting_for_code = State()
+    waiting_for_referral_code = State()
+
+
+class AdminStates(StatesGroup):
+    
+    waiting_for_user_search = State()
+    editing_user_balance = State()
+    editing_user_subscription = State()
+    
+    creating_promocode = State()
+    setting_promocode_type = State()
+    setting_promocode_value = State()
+    setting_promocode_uses = State()
+    setting_promocode_expiry = State()
+    
+    waiting_for_broadcast_message = State()
+    confirming_broadcast = State()
+    
+    editing_squad_price = State()
+    editing_traffic_price = State()
+    editing_device_price = State()
+    
+    editing_rules_page = State()
+    
+    confirming_sync = State()
+
+    editing_server_name = State()
+    editing_server_price = State()
+    editing_server_country = State()
+    editing_server_limit = State()
+    editing_server_description = State()
+    
+    creating_server_uuid = State()
+    creating_server_name = State()
+    creating_server_price = State()
+    creating_server_country = State()
+
+
+class SupportStates(StatesGroup):
+    waiting_for_message = State()
+
+
+class AutoPayStates(StatesGroup):
+    setting_autopay_days = State()
+    confirming_autopay_toggle = State()
+
+class SquadCreateStates(StatesGroup):
+    waiting_for_name = State()
+    selecting_inbounds = State()
+
+class SquadRenameStates(StatesGroup):
+    waiting_for_new_name = State()

app/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Утилиты
+"""

app/utils/cache.py

@@ -0,0 +1,264 @@
+import json
+import logging
+from typing import Any, Optional, Union
+from datetime import datetime, timedelta
+import redis.asyncio as redis
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class CacheService:
+    
+    def __init__(self):
+        self.redis_client: Optional[redis.Redis] = None
+        self._connected = False
+    
+    async def connect(self):
+        try:
+            self.redis_client = redis.from_url(settings.REDIS_URL)
+            await self.redis_client.ping()
+            self._connected = True
+            logger.info("✅ Подключение к Redis кешу установлено")
+        except Exception as e:
+            logger.warning(f"⚠️ Не удалось подключиться к Redis: {e}")
+            self._connected = False
+    
+    async def disconnect(self):
+        if self.redis_client:
+            await self.redis_client.close()
+            self._connected = False
+    
+    async def get(self, key: str) -> Optional[Any]:
+        if not self._connected:
+            return None
+        
+        try:
+            value = await self.redis_client.get(key)
+            if value:
+                return json.loads(value)
+            return None
+        except Exception as e:
+            logger.error(f"Ошибка получения из кеша {key}: {e}")
+            return None
+    
+    async def set(
+        self, 
+        key: str, 
+        value: Any, 
+        expire: Union[int, timedelta] = None
+    ) -> bool:
+        if not self._connected:
+            return False
+        
+        try:
+            serialized_value = json.dumps(value, default=str)
+            
+            if isinstance(expire, timedelta):
+                expire = int(expire.total_seconds())
+            
+            await self.redis_client.set(key, serialized_value, ex=expire)
+            return True
+        except Exception as e:
+            logger.error(f"Ошибка записи в кеш {key}: {e}")
+            return False
+    
+    async def delete(self, key: str) -> bool:
+        if not self._connected:
+            return False
+        
+        try:
+            deleted = await self.redis_client.delete(key)
+            return deleted > 0
+        except Exception as e:
+            logger.error(f"Ошибка удаления из кеша {key}: {e}")
+            return False
+    
+    async def exists(self, key: str) -> bool:
+        if not self._connected:
+            return False
+        
+        try:
+            return await self.redis_client.exists(key)
+        except Exception as e:
+            logger.error(f"Ошибка проверки существования в кеше {key}: {e}")
+            return False
+    
+    async def expire(self, key: str, seconds: int) -> bool:
+        if not self._connected:
+            return False
+        
+        try:
+            return await self.redis_client.expire(key, seconds)
+        except Exception as e:
+            logger.error(f"Ошибка установки TTL для {key}: {e}")
+            return False
+    
+    async def get_keys(self, pattern: str = "*") -> list:
+        if not self._connected:
+            return []
+        
+        try:
+            keys = await self.redis_client.keys(pattern)
+            return [key.decode() if isinstance(key, bytes) else key for key in keys]
+        except Exception as e:
+            logger.error(f"Ошибка получения ключей по паттерну {pattern}: {e}")
+            return []
+    
+    async def flush_all(self) -> bool:
+        if not self._connected:
+            return False
+        
+        try:
+            await self.redis_client.flushall()
+            logger.info("🗑️ Кеш полностью очищен")
+            return True
+        except Exception as e:
+            logger.error(f"Ошибка очистки кеша: {e}")
+            return False
+    
+    async def increment(self, key: str, amount: int = 1) -> Optional[int]:
+        if not self._connected:
+            return None
+        
+        try:
+            return await self.redis_client.incrby(key, amount)
+        except Exception as e:
+            logger.error(f"Ошибка инкремента {key}: {e}")
+            return None
+    
+    async def set_hash(self, name: str, mapping: dict, expire: int = None) -> bool:
+        if not self._connected:
+            return False
+        
+        try:
+            await self.redis_client.hset(name, mapping=mapping)
+            if expire:
+                await self.redis_client.expire(name, expire)
+            return True
+        except Exception as e:
+            logger.error(f"Ошибка записи хеша {name}: {e}")
+            return False
+    
+    async def get_hash(self, name: str, key: str = None) -> Optional[Union[dict, str]]:
+        if not self._connected:
+            return None
+        
+        try:
+            if key:
+                value = await self.redis_client.hget(name, key)
+                return value.decode() if value else None
+            else:
+                hash_data = await self.redis_client.hgetall(name)
+                return {k.decode(): v.decode() for k, v in hash_data.items()}
+        except Exception as e:
+            logger.error(f"Ошибка получения хеша {name}: {e}")
+            return None
+
+
+cache = CacheService()
+
+
+def cache_key(*parts) -> str:
+    return ":".join(str(part) for part in parts)
+
+
+async def cached_function(key: str, expire: int = 300):
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            cache_result = await cache.get(key)
+            if cache_result is not None:
+                return cache_result
+            
+            result = await func(*args, **kwargs)
+            await cache.set(key, result, expire)
+            return result
+        
+        return wrapper
+    return decorator
+
+
+class UserCache:
+    
+    @staticmethod
+    async def get_user_data(user_id: int) -> Optional[dict]:
+        key = cache_key("user", user_id)
+        return await cache.get(key)
+    
+    @staticmethod
+    async def set_user_data(user_id: int, data: dict, expire: int = 3600) -> bool:
+        key = cache_key("user", user_id)
+        return await cache.set(key, data, expire)
+    
+    @staticmethod
+    async def delete_user_data(user_id: int) -> bool:
+        key = cache_key("user", user_id)
+        return await cache.delete(key)
+    
+    @staticmethod
+    async def get_user_session(user_id: int, session_key: str) -> Optional[Any]:
+        key = cache_key("session", user_id, session_key)
+        return await cache.get(key)
+    
+    @staticmethod
+    async def set_user_session(
+        user_id: int, 
+        session_key: str, 
+        data: Any, 
+        expire: int = 1800
+    ) -> bool:
+        key = cache_key("session", user_id, session_key)
+        return await cache.set(key, data, expire)
+
+
+class SystemCache:
+    
+    @staticmethod
+    async def get_system_stats() -> Optional[dict]:
+        return await cache.get("system:stats")
+    
+    @staticmethod
+    async def set_system_stats(stats: dict, expire: int = 300) -> bool:
+        return await cache.set("system:stats", stats, expire)
+    
+    @staticmethod
+    async def get_nodes_status() -> Optional[list]:
+        return await cache.get("remnawave:nodes")
+    
+    @staticmethod
+    async def set_nodes_status(nodes: list, expire: int = 60) -> bool:
+        return await cache.set("remnawave:nodes", nodes, expire)
+    
+    @staticmethod
+    async def get_daily_stats(date: str) -> Optional[dict]:
+        key = cache_key("stats", "daily", date)
+        return await cache.get(key)
+    
+    @staticmethod
+    async def set_daily_stats(date: str, stats: dict) -> bool:
+        key = cache_key("stats", "daily", date)
+        return await cache.set(key, stats, 86400)  # 24 часа
+
+
+class RateLimitCache:
+    
+    @staticmethod
+    async def is_rate_limited(user_id: int, action: str, limit: int, window: int) -> bool:
+        key = cache_key("rate_limit", user_id, action)
+        current = await cache.get(key)
+        
+        if current is None:
+            await cache.set(key, 1, window)
+            return False
+        
+        if current >= limit:
+            return True
+        
+        await cache.increment(key)
+        return False
+    
+    @staticmethod
+    async def reset_rate_limit(user_id: int, action: str) -> bool:
+        key = cache_key("rate_limit", user_id, action)
+        return await cache.delete(key)

app/utils/decorators.py

@@ -0,0 +1,117 @@
+import logging
+import functools
+from typing import Callable, Any
+from aiogram import types
+from aiogram.fsm.context import FSMContext
+
+from app.config import settings
+from app.localization.texts import get_texts
+
+logger = logging.getLogger(__name__)
+
+
+def admin_required(func: Callable) -> Callable:
+    
+    @functools.wraps(func)
+    async def wrapper(
+        event: types.Update,
+        *args,
+        **kwargs
+    ) -> Any:
+        user = None
+        if isinstance(event, (types.Message, types.CallbackQuery)):
+            user = event.from_user
+        
+        if not user or not settings.is_admin(user.id):
+            texts = get_texts()
+            
+            if isinstance(event, types.Message):
+                await event.answer(texts.ACCESS_DENIED)
+            elif isinstance(event, types.CallbackQuery):
+                await event.answer(texts.ACCESS_DENIED, show_alert=True)
+            
+            logger.warning(f"Попытка доступа к админской функции от {user.id if user else 'Unknown'}")
+            return
+        
+        return await func(event, *args, **kwargs)
+    
+    return wrapper
+
+
+def error_handler(func: Callable) -> Callable:
+    
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs) -> Any:
+        try:
+            return await func(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"Ошибка в {func.__name__}: {e}", exc_info=True)
+            
+            event = None
+            db_user = kwargs.get('db_user')
+            
+            for arg in args:
+                if isinstance(arg, (types.Message, types.CallbackQuery)):
+                    event = arg
+                    break
+            
+            if event:
+                texts = get_texts(db_user.language if db_user else 'ru')
+                
+                if isinstance(event, types.Message):
+                    await event.answer(texts.ERROR)
+                elif isinstance(event, types.CallbackQuery):
+                    await event.answer(texts.ERROR, show_alert=True)
+    
+    return wrapper
+
+
+def state_cleanup(func: Callable) -> Callable:
+    
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs) -> Any:
+        state = kwargs.get('state')
+        
+        try:
+            return await func(*args, **kwargs)
+        except Exception as e:
+            if state and isinstance(state, FSMContext):
+                await state.clear()
+            raise e
+    
+    return wrapper
+
+
+def typing_action(func: Callable) -> Callable:
+    
+    @functools.wraps(func)
+    async def wrapper(
+        event: types.Update,
+        *args,
+        **kwargs
+    ) -> Any:
+        if isinstance(event, types.Message):
+            await event.bot.send_chat_action(
+                chat_id=event.chat.id,
+                action="typing"
+            )
+        
+        return await func(event, *args, **kwargs)
+    
+    return wrapper
+
+
+def rate_limit(rate: float = 1.0, key: str = None):
+    def decorator(func: Callable) -> Callable:
+        
+        @functools.wraps(func)
+        async def wrapper(
+            event: types.Update,
+            *args,
+            **kwargs
+        ) -> Any:
+            return await func(event, *args, **kwargs)
+        
+        return wrapper
+    
+    return decorator

app/utils/formatters.py

@@ -0,0 +1,207 @@
+from datetime import datetime, timedelta
+from typing import Union, Optional
+
+
+def format_datetime(dt: Union[datetime, str], format_str: str = "%d.%m.%Y %H:%M") -> str:
+    if isinstance(dt, str):
+        if dt == "now" or dt == "":
+            dt = datetime.now()
+        else:
+            try:
+                dt = datetime.fromisoformat(dt.replace('Z', '+00:00'))
+            except (ValueError, AttributeError):
+                dt = datetime.now()
+    
+    return dt.strftime(format_str)
+
+
+def format_date(dt: Union[datetime, str], format_str: str = "%d.%m.%Y") -> str:
+    if isinstance(dt, str):
+        if dt == "now" or dt == "":
+            dt = datetime.now()
+        else:
+            try:
+                dt = datetime.fromisoformat(dt.replace('Z', '+00:00'))
+            except (ValueError, AttributeError):
+                dt = datetime.now()
+    
+    return dt.strftime(format_str)
+
+
+def format_time_ago(dt: Union[datetime, str]) -> str:
+    if isinstance(dt, str):
+        if dt == "now" or dt == "":
+            dt = datetime.now()
+        else:
+            try:
+                dt = datetime.fromisoformat(dt.replace('Z', '+00:00'))
+            except (ValueError, AttributeError):
+                dt = datetime.now()
+    
+    now = datetime.utcnow()
+    diff = now - dt
+    
+    if diff.days > 0:
+        if diff.days == 1:
+            return "вчера"
+        elif diff.days < 7:
+            return f"{diff.days} дн. назад"
+        elif diff.days < 30:
+            weeks = diff.days // 7
+            return f"{weeks} нед. назад"
+        elif diff.days < 365:
+            months = diff.days // 30
+            return f"{months} мес. назад"
+        else:
+            years = diff.days // 365
+            return f"{years} г. назад"
+    
+    elif diff.seconds > 3600:
+        hours = diff.seconds // 3600
+        return f"{hours} ч. назад"
+    
+    elif diff.seconds > 60:
+        minutes = diff.seconds // 60
+        return f"{minutes} мин. назад"
+    
+    else:
+        return "только что"
+
+
+def format_duration(seconds: int) -> str:
+    if seconds < 60:
+        return f"{seconds} сек."
+    
+    minutes = seconds // 60
+    if minutes < 60:
+        return f"{minutes} мин."
+    
+    hours = minutes // 60
+    if hours < 24:
+        return f"{hours} ч."
+    
+    days = hours // 24
+    return f"{days} дн."
+
+
+def format_bytes(bytes_value: int) -> str:
+    if bytes_value == 0:
+        return "0 B"
+    
+    units = ["B", "KB", "MB", "GB", "TB"]
+    size = float(bytes_value)
+    unit_index = 0
+    
+    while size >= 1024 and unit_index < len(units) - 1:
+        size /= 1024
+        unit_index += 1
+    
+    if size == int(size):
+        return f"{int(size)} {units[unit_index]}"
+    else:
+        return f"{size:.1f} {units[unit_index]}"
+
+
+def format_percentage(value: float, decimals: int = 1) -> str:
+    return f"{value:.{decimals}f}%"
+
+
+def format_number(number: Union[int, float], separator: str = " ") -> str:
+    if isinstance(number, float):
+        integer_part = int(number)
+        decimal_part = number - integer_part
+        
+        formatted_integer = f"{integer_part:,}".replace(",", separator)
+        
+        if decimal_part > 0:
+            return f"{formatted_integer}.{decimal_part:.2f}".split('.')[0] + f".{str(decimal_part).split('.')[1][:2]}"
+        else:
+            return formatted_integer
+    else:
+        return f"{number:,}".replace(",", separator)
+
+
+def format_price_range(min_price: int, max_price: int) -> str:
+    from app.config import settings
+    
+    min_formatted = settings.format_price(min_price)
+    max_formatted = settings.format_price(max_price)
+    
+    if min_price == max_price:
+        return min_formatted
+    else:
+        return f"{min_formatted} - {max_formatted}"
+
+
+def truncate_text(text: str, max_length: int = 100, suffix: str = "...") -> str:
+    if len(text) <= max_length:
+        return text
+    
+    return text[:max_length - len(suffix)] + suffix
+
+
+def format_username(username: Optional[str], user_id: int, full_name: Optional[str] = None) -> str:
+    if full_name:
+        return full_name
+    elif username:
+        return f"@{username}"
+    else:
+        return f"ID{user_id}"
+
+
+def format_subscription_status(
+    is_active: bool,
+    is_trial: bool,
+    end_date: Union[datetime, str],
+    language: str = "ru"
+) -> str:
+    
+    if isinstance(end_date, str):
+        try:
+            end_date = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+        except (ValueError, AttributeError):
+            end_date = datetime.now()
+    
+    if not is_active:
+        return "❌ Неактивна" if language == "ru" else "❌ Inactive"
+    
+    if is_trial:
+        status = "🎁 Тестовая" if language == "ru" else "🎁 Trial"
+    else:
+        status = "✅ Активна" if language == "ru" else "✅ Active"
+    
+    now = datetime.utcnow()
+    if end_date > now:
+        days_left = (end_date - now).days
+        if days_left > 0:
+            status += f" ({days_left} дн.)" if language == "ru" else f" ({days_left} days)"
+        else:
+            hours_left = (end_date - now).seconds // 3600
+            status += f" ({hours_left} ч.)" if language == "ru" else f" ({hours_left} hrs)"
+    else:
+        status = "⏰ Истекла" if language == "ru" else "⏰ Expired"
+    
+    return status
+
+
+def format_traffic_usage(used_gb: float, limit_gb: int, language: str = "ru") -> str:
+    
+    if limit_gb == 0: 
+        if language == "ru":
+            return f"{used_gb:.1f} ГБ / ∞"
+        else:
+            return f"{used_gb:.1f} GB / ∞"
+    
+    percentage = (used_gb / limit_gb) * 100 if limit_gb > 0 else 0
+    
+    if language == "ru":
+        return f"{used_gb:.1f} ГБ / {limit_gb} ГБ ({percentage:.1f}%)"
+    else:
+        return f"{used_gb:.1f} GB / {limit_gb} GB ({percentage:.1f}%)"
+
+
+def format_boolean(value: bool, language: str = "ru") -> str:
+    if language == "ru":
+        return "✅ Да" if value else "❌ Нет"
+    else:
+        return "✅ Yes" if value else "❌ No"

app/utils/pagination.py

@@ -0,0 +1,82 @@
+from typing import List, TypeVar, Generic, Dict, Any
+from math import ceil
+
+T = TypeVar('T')
+
+
+class PaginationResult(Generic[T]):
+    
+    def __init__(
+        self,
+        items: List[T],
+        total_count: int,
+        page: int,
+        per_page: int
+    ):
+        self.items = items
+        self.total_count = total_count
+        self.page = page
+        self.per_page = per_page
+        self.total_pages = ceil(total_count / per_page) if per_page > 0 else 1
+        self.has_prev = page > 1
+        self.has_next = page < self.total_pages
+        self.prev_page = page - 1 if self.has_prev else None
+        self.next_page = page + 1 if self.has_next else None
+
+
+def paginate_list(
+    items: List[T],
+    page: int = 1,
+    per_page: int = 10
+) -> PaginationResult[T]:
+    total_count = len(items)
+    
+    start_index = (page - 1) * per_page
+    end_index = start_index + per_page
+    
+    page_items = items[start_index:end_index]
+    
+    return PaginationResult(
+        items=page_items,
+        total_count=total_count,
+        page=page,
+        per_page=per_page
+    )
+
+
+def get_pagination_info(
+    total_count: int,
+    page: int = 1,
+    per_page: int = 10
+) -> Dict[str, Any]:
+    total_pages = ceil(total_count / per_page) if per_page > 0 else 1
+    
+    return {
+        "total_count": total_count,
+        "page": page,
+        "per_page": per_page,
+        "total_pages": total_pages,
+        "has_prev": page > 1,
+        "has_next": page < total_pages,
+        "prev_page": page - 1 if page > 1 else None,
+        "next_page": page + 1 if page < total_pages else None,
+        "offset": (page - 1) * per_page
+    }
+
+
+def get_page_numbers(
+    current_page: int,
+    total_pages: int,
+    max_visible: int = 5
+) -> List[int]:
+    if total_pages <= max_visible:
+        return list(range(1, total_pages + 1))
+    
+    half_visible = max_visible // 2
+    start_page = max(1, current_page - half_visible)
+    end_page = min(total_pages, start_page + max_visible - 1)
+    
+    if end_page - start_page + 1 < max_visible:
+        start_page = max(1, end_page - max_visible + 1)
+    
+    return list(range(start_page, end_page + 1))

app/utils/user_utils.py

@@ -0,0 +1,76 @@
+import logging
+import random
+import string
+from datetime import datetime
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from app.database.models import User
+
+logger = logging.getLogger(__name__)
+
+
+async def mark_user_as_had_paid_subscription(
+    db: AsyncSession,
+    user: User
+) -> None:
+    if not user.has_had_paid_subscription:
+        user.has_had_paid_subscription = True
+        user.updated_at = datetime.utcnow()
+        await db.commit()
+        logger.info(f"🎯 Пользователь {user.telegram_id} отмечен как имевший платную подписку")
+
+
+async def generate_unique_referral_code(db: AsyncSession, telegram_id: int) -> str:
+    
+    base_code = str(telegram_id)[-6:]
+    
+    for attempt in range(10):
+        if attempt == 0:
+            referral_code = base_code
+        else:
+            suffix = ''.join(random.choices(string.ascii_lowercase + string.digits, k=2))
+            referral_code = base_code + suffix
+        
+        result = await db.execute(
+            select(User.id).where(User.referral_code == referral_code)
+        )
+        
+        if not result.scalar():
+            return referral_code
+    
+    import uuid
+    return str(uuid.uuid4())[:8]
+
+
+async def get_user_referral_summary(db: AsyncSession, user_id: int) -> dict:
+    
+    try:
+        from app.services.referral_service import get_referral_stats_for_user
+        from app.database.crud.referral import get_referral_earnings_by_user
+        
+        stats = await get_referral_stats_for_user(db, user_id)
+        
+        recent_earnings = await get_referral_earnings_by_user(db, user_id, limit=5)
+        
+        return {
+            **stats,
+            "recent_earnings": [
+                {
+                    "amount_kopeks": earning.amount_kopeks,
+                    "reason": earning.reason,
+                    "created_at": earning.created_at,
+                    "referral_name": earning.referral.full_name if earning.referral else "Неизвестно"
+                }
+                for earning in recent_earnings
+            ]
+        }
+        
+    except Exception as e:
+        logger.error(f"Ошибка получения сводки рефералов: {e}")
+        return {
+            "invited_count": 0,
+            "paid_referrals_count": 0,
+            "total_earned_kopeks": 0,
+            "month_earned_kopeks": 0,
+            "recent_earnings": []
+        }

app/utils/validators.py

@@ -0,0 +1,137 @@
+import re
+from typing import Optional, Union
+from datetime import datetime
+
+
+def validate_email(email: str) -> bool:
+    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+    return re.match(pattern, email) is not None
+
+
+def validate_phone(phone: str) -> bool:
+    pattern = r'^\+?[1-9]\d{1,14}$'
+    cleaned_phone = re.sub(r'[\s\-\(\)]', '', phone)
+    return re.match(pattern, cleaned_phone) is not None
+
+
+def validate_telegram_username(username: str) -> bool:
+    if not username:
+        return False
+    username = username.lstrip('@')
+    pattern = r'^[a-zA-Z0-9_]{5,32}$'
+    return re.match(pattern, username) is not None
+
+
+def validate_promocode(code: str) -> bool:
+    if not code or len(code) < 3 or len(code) > 20:
+        return False
+    return code.replace('_', '').replace('-', '').isalnum()
+
+
+def validate_amount(amount_str: str, min_amount: float = 0, max_amount: float = float('inf')) -> Optional[float]:
+    try:
+        amount = float(amount_str.replace(',', '.'))
+        if min_amount <= amount <= max_amount:
+            return amount
+        return None
+    except (ValueError, TypeError):
+        return None
+
+
+def validate_positive_integer(value: Union[str, int], max_value: int = None) -> Optional[int]:
+    try:
+        num = int(value)
+        if num > 0 and (max_value is None or num <= max_value):
+            return num
+        return None
+    except (ValueError, TypeError):
+        return None
+
+
+def validate_date_string(date_str: str, date_format: str = "%Y-%m-%d") -> Optional[datetime]:
+    try:
+        return datetime.strptime(date_str, date_format)
+    except ValueError:
+        return None
+
+
+def validate_url(url: str) -> bool:
+    pattern = r'^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$'
+    return re.match(pattern, url) is not None
+
+
+def validate_uuid(uuid_str: str) -> bool:
+    pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
+    return re.match(pattern, uuid_str.lower()) is not None
+
+
+def validate_traffic_amount(traffic_str: str) -> Optional[int]:
+    traffic_str = traffic_str.upper().strip()
+    
+    if traffic_str in ['UNLIMITED', 'БЕЗЛИМИТ', '∞']:
+        return 0
+    
+    units = {
+        'MB': 1,
+        'GB': 1024,
+        'TB': 1024 * 1024,
+        'МБ': 1,
+        'ГБ': 1024,
+        'ТБ': 1024 * 1024
+    }
+    
+    for unit, multiplier in units.items():
+        if traffic_str.endswith(unit):
+            try:
+                value = float(traffic_str[:-len(unit)].strip())
+                return int(value * multiplier)
+            except ValueError:
+                break
+    
+    try:
+        return int(float(traffic_str))
+    except ValueError:
+        return None
+
+
+def validate_subscription_period(days: Union[str, int]) -> Optional[int]:
+    try:
+        days_int = int(days)
+        if 1 <= days_int <= 3650:
+            return days_int
+        return None
+    except (ValueError, TypeError):
+        return None
+
+
+def sanitize_html(text: str) -> str:
+    allowed_tags = ['b', 'strong', 'i', 'em', 'u', 'ins', 's', 'strike', 'del', 'code', 'pre']
+    
+    for tag in allowed_tags:
+        text = re.sub(f'<{tag}>', f'<{tag}>', text, flags=re.IGNORECASE)
+        text = re.sub(f'</{tag}>', f'</{tag}>', text, flags=re.IGNORECASE)
+    
+    text = re.sub(r'<(?!/?(?:' + '|'.join(allowed_tags) + r')\b)[^>]*>', '', text)
+    
+    return text
+
+
+def validate_device_count(count: Union[str, int]) -> Optional[int]:
+    try:
+        count_int = int(count)
+        if 1 <= count_int <= 10:
+            return count_int
+        return None
+    except (ValueError, TypeError):
+        return None
+
+
+def validate_referral_code(code: str) -> bool:
+    if not code:
+        return False
+    
+    if code.startswith('ref') and len(code) > 3:
+        user_id_part = code[3:]
+        return user_id_part.isdigit()
+    
+    return validate_promocode(code)

autopay_service.py

@@ -1,284 +0,0 @@
-import asyncio
-import logging
-from datetime import datetime, timedelta
-from typing import List, Optional
-from database import Database, UserSubscription, User, Subscription
-from remnawave_api import RemnaWaveAPI
-from referral_utils import process_referral_rewards
-
-logger = logging.getLogger(__name__)
-
-class AutoPayService:
-    
-    def __init__(self, db: Database, api: Optional[RemnaWaveAPI] = None, bot=None):
-        self.db = db
-        self.api = api
-        self.bot = bot
-        self.is_running = False
-        self.check_task = None
-        
-    async def start(self):
-        if self.is_running:
-            logger.warning("AutoPay service is already running")
-            return
-            
-        self.is_running = True
-        logger.info("🔄 Starting AutoPay service...")
-        
-        self.check_task = asyncio.create_task(self._periodic_check())
-        
-    async def stop(self):
-        if not self.is_running:
-            return
-            
-        self.is_running = False
-        logger.info("⏹ Stopping AutoPay service...")
-        
-        if self.check_task:
-            self.check_task.cancel()
-            try:
-                await self.check_task
-            except asyncio.CancelledError:
-                pass
-                
-    async def _periodic_check(self):
-        while self.is_running:
-            try:
-                await self.process_autopayments()
-                # Проверяем каждые 30 минут
-                await asyncio.sleep(1800)
-            except asyncio.CancelledError:
-                logger.info("AutoPay periodic check cancelled")
-                break
-            except Exception as e:
-                logger.error(f"Error in AutoPay periodic check: {e}")
-                await asyncio.sleep(300) 
-                
-    async def process_autopayments(self) -> dict:
-        logger.info("🔄 Processing autopayments...")
-        
-        try:
-            subscriptions_to_pay = await self.db.get_subscriptions_for_autopay()
-            
-            if not subscriptions_to_pay:
-                logger.info("No subscriptions ready for autopay")
-                return {
-                    'processed': 0,
-                    'successful': 0,
-                    'failed': 0,
-                    'insufficient_balance': 0,
-                    'errors': []
-                }
-            
-            logger.info(f"Found {len(subscriptions_to_pay)} subscriptions for autopay")
-            
-            stats = {
-                'processed': 0,
-                'successful': 0,
-                'failed': 0,
-                'insufficient_balance': 0,
-                'errors': []
-            }
-            
-            for user_sub in subscriptions_to_pay:
-                try:
-                    result = await self._process_single_autopayment(user_sub)
-                    stats['processed'] += 1
-                    
-                    if result['success']:
-                        stats['successful'] += 1
-                        logger.info(f"✅ Autopay successful for user {user_sub.user_id}, subscription {user_sub.id}")
-                    elif result['reason'] == 'insufficient_balance':
-                        stats['insufficient_balance'] += 1
-                        logger.info(f"💳 Insufficient balance for user {user_sub.user_id}, subscription {user_sub.id}")
-                    else:
-                        stats['failed'] += 1
-                        stats['errors'].append(f"User {user_sub.user_id}: {result['reason']}")
-                        logger.warning(f"❌ Autopay failed for user {user_sub.user_id}: {result['reason']}")
-                        
-                except Exception as e:
-                    stats['processed'] += 1
-                    stats['failed'] += 1
-                    error_msg = f"User {user_sub.user_id}: {str(e)}"
-                    stats['errors'].append(error_msg)
-                    logger.error(f"Error processing autopay for user {user_sub.user_id}: {e}")
-            
-            logger.info(f"📊 Autopay processing complete: {stats['successful']} successful, "
-                       f"{stats['failed']} failed, {stats['insufficient_balance']} insufficient balance")
-            
-            return stats
-            
-        except Exception as e:
-            logger.error(f"Error in process_autopayments: {e}")
-            return {
-                'processed': 0,
-                'successful': 0,
-                'failed': 0,
-                'insufficient_balance': 0,
-                'errors': [str(e)]
-            }
-    
-    async def _process_single_autopayment(self, user_sub: UserSubscription) -> dict:
-        try:
-            user = await self.db.get_user_by_telegram_id(user_sub.user_id)
-            if not user:
-                return {'success': False, 'reason': 'User not found'}
-            
-            subscription = await self.db.get_subscription_by_id(user_sub.subscription_id)
-            if not subscription:
-                return {'success': False, 'reason': 'Subscription plan not found'}
-            
-            if subscription.is_trial:
-                logger.info(f"Skipping autopay for trial subscription: user {user_sub.user_id}")
-                return {'success': False, 'reason': 'Trial subscriptions are not eligible for autopay'}
-            
-            if not user_sub.is_active or not user_sub.auto_pay_enabled:
-                return {'success': False, 'reason': 'Subscription inactive or autopay disabled'}
-            
-            if user.balance < subscription.price:
-                await self._notify_insufficient_balance(user, subscription, user_sub)
-                return {'success': False, 'reason': 'insufficient_balance'}
-            
-            return await self._execute_autopayment(user, subscription, user_sub)
-            
-        except Exception as e:
-            logger.error(f"Error in _process_single_autopayment: {e}")
-            return {'success': False, 'reason': str(e)}
-    
-    async def _execute_autopayment(self, user: User, subscription: Subscription, user_sub: UserSubscription) -> dict:
-        try:
-            user.balance -= subscription.price
-            await self.db.update_user(user)
-            
-            now = datetime.utcnow()
-            if user_sub.expires_at > now:
-                new_expiry = user_sub.expires_at + timedelta(days=subscription.duration_days)
-            else:
-                new_expiry = now + timedelta(days=subscription.duration_days)
-            
-            user_sub.expires_at = new_expiry
-            user_sub.is_active = True
-            await self.db.update_user_subscription(user_sub)
-            
-            if self.api and user_sub.short_uuid:
-                try:
-                    remna_user_details = await self.api.get_user_by_short_uuid(user_sub.short_uuid)
-                    if remna_user_details:
-                        user_uuid = remna_user_details.get('uuid')
-                        if user_uuid:
-                            expiry_str = new_expiry.isoformat() + 'Z'
-                            update_data = {
-                                'enable': True,
-                                'expireAt': expiry_str
-                            }
-                            await self.api.update_user(user_uuid, update_data)
-                            logger.info(f"Updated RemnaWave expiry for user {user_sub.user_id}")
-                except Exception as e:
-                    logger.warning(f"Failed to update RemnaWave expiry: {e}")
-            
-            payment = await self.db.create_payment(
-                user_id=user_sub.user_id,
-                amount=-subscription.price,
-                payment_type='autopay',
-                description=f'Автоплатеж: {subscription.name}',
-                status='completed'
-            )
-            
-            if self.bot:
-                try:
-                    await process_referral_rewards(
-                        user_sub.user_id,
-                        subscription.price,
-                        payment.id,
-                        self.db,
-                        self.bot,
-                        payment_type='autopay'
-                    )
-                except Exception as e:
-                    logger.warning(f"Failed to process referral rewards for autopay: {e}")
-            
-            await self._notify_successful_autopay(user, subscription, user_sub, new_expiry)
-            
-            return {'success': True, 'reason': 'Payment processed successfully'}
-            
-        except Exception as e:
-            logger.error(f"Error executing autopayment: {e}")
-            try:
-                user.balance += subscription.price
-                await self.db.update_user(user)
-            except:
-                pass
-            return {'success': False, 'reason': str(e)}
-    
-    async def _notify_successful_autopay(self, user: User, subscription: Subscription, 
-                                       user_sub: UserSubscription, new_expiry: datetime):
-        if not self.bot:
-            return
-        
-        try:
-            from utils import format_datetime
-            
-            text = f"✅ Автоматическое продление подписки\n\n"
-            text += f"📋 Подписка: {subscription.name}\n"
-            text += f"💰 Списано: {subscription.price} руб.\n"
-            text += f"📅 Продлено до: {format_datetime(new_expiry, user.language)}\n"
-            text += f"💳 Остаток на балансе: {user.balance} руб.\n\n"
-            text += f"🔄 Следующее продление произойдет автоматически за {user_sub.auto_pay_days_before} дн. до истечения.\n\n"
-            text += f"ℹ️ Для отключения автоплатежа перейдите в 'Мои подписки' → выберите подписку"
-            
-            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
-            keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                [InlineKeyboardButton(text="📋 Мои подписки", callback_data="my_subscriptions")],
-                [InlineKeyboardButton(text="💰 Баланс", callback_data="balance")]
-            ])
-            
-            await self.bot.send_message(
-                user.telegram_id,
-                text,
-                reply_markup=keyboard
-            )
-            
-        except Exception as e:
-            logger.error(f"Failed to send autopay success notification: {e}")
-    
-    async def _notify_insufficient_balance(self, user: User, subscription: Subscription, user_sub: UserSubscription):
-        if not self.bot:
-            return
-        
-        try:
-            from utils import format_datetime
-            
-            needed = subscription.price - user.balance
-            days_left = (user_sub.expires_at - datetime.utcnow()).days
-            
-            text = f"⚠️ Не удалось автоматически продлить подписку\n\n"
-            text += f"📋 Подписка: {subscription.name}\n"
-            text += f"💰 Нужно для продления: {subscription.price} руб.\n"
-            text += f"💳 Ваш баланс: {user.balance} руб.\n"
-            text += f"💸 Недостает: {needed} руб.\n\n"
-            text += f"📅 Подписка истекает: {format_datetime(user_sub.expires_at, user.language)}\n"
-            text += f"⏰ Осталось дней: {days_left}\n\n"
-            text += f"💡 Пополните баланс для автоматического продления"
-            
-            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
-            keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                [InlineKeyboardButton(text="💰 Пополнить баланс", callback_data="topup_balance")],
-                [InlineKeyboardButton(text="📋 Мои подписки", callback_data="my_subscriptions")]
-            ])
-            
-            await self.bot.send_message(
-                user.telegram_id,
-                text,
-                reply_markup=keyboard
-            )
-            
-        except Exception as e:
-            logger.error(f"Failed to send insufficient balance notification: {e}")
-    
-    async def get_service_status(self) -> dict:
-        return {
-            'is_running': self.is_running,
-            'check_interval': 1800, 
-            'has_api': self.api is not None,
-            'has_bot': self.bot is not None
-        }

config.py

@@ -1,157 +0,0 @@
-import os
-from dataclasses import dataclass
-from typing import List, Dict
-
-@dataclass
-class Config:
-    BOT_TOKEN: str
-    BOT_USERNAME: str
-    DATABASE_URL: str
-    REMNAWAVE_URL: str
-    REMNAWAVE_TOKEN: str
-    SUBSCRIPTION_BASE_URL: str
-    ADMIN_IDS: List[int]
-    SUPPORT_USERNAME: str
-    DEFAULT_LANGUAGE: str
-    TRIAL_ENABLED: bool
-    TRIAL_DURATION_DAYS: int
-    TRIAL_TRAFFIC_GB: int
-    TRIAL_SQUAD_UUID: str
-    REFERRAL_FIRST_REWARD: float
-    REFERRAL_REFERRED_BONUS: float
-    REFERRAL_THRESHOLD: float
-    REFERRAL_PERCENTAGE: float
-    MONITOR_ENABLED: bool = True
-    MONITOR_CHECK_INTERVAL: int = 3600  
-    MONITOR_DAILY_CHECK_HOUR: int = 10  
-    MONITOR_WARNING_DAYS: int = 3  
-    DELETE_EXPIRED_TRIAL_DAYS: int = 1  
-    DELETE_EXPIRED_REGULAR_DAYS: int = 7  
-    AUTO_DELETE_ENABLED: bool = False 
-    TRIAL_NOTIFICATION_ENABLED: bool = True  
-    TRIAL_NOTIFICATION_HOURS_AFTER: int = 2  
-    TRIAL_NOTIFICATION_HOURS_WINDOW: int = 22 
-    TRIBUTE_ENABLED: bool = False
-    TRIBUTE_API_KEY: str = ""
-    TRIBUTE_WEBHOOK_PORT: int = 8081
-    TRIBUTE_WEBHOOK_PATH: str = "/tribute-webhook"
-    TRIBUTE_DONATE_URL: str = "" 
-    TRIBUTE_DONATE_LINK: str = "" 
-
-    LUCKY_GAME_ENABLED: bool = True
-    LUCKY_GAME_REWARD: float = 50.0 
-    LUCKY_GAME_NUMBERS: int = 30    
-    LUCKY_GAME_WINNING_COUNT: int = 3 
-    
-    STARS_ENABLED: bool = True
-    STARS_RATES: Dict[int, float] = None  
-
-def load_config() -> Config:
-    
-    def parse_admin_ids(admin_ids_str: str) -> List[int]:
-        if not admin_ids_str:
-            return []
-        try:
-            return [int(id_str.strip()) for id_str in admin_ids_str.split(',') if id_str.strip()]
-        except (ValueError, AttributeError):
-            return []
-    
-    def get_bool(key: str, default: bool = False) -> bool:
-        value = os.getenv(key, '').lower()
-        return value in ('true', '1', 'yes', 'on')
-    
-    def get_int(key: str, default: int = 0) -> int:
-        try:
-            return int(os.getenv(key, str(default)))
-        except (ValueError, TypeError):
-            return default
-    
-    def get_float(key: str, default: float = 0.0) -> float:
-        try:
-            return float(os.getenv(key, str(default)))
-        except (ValueError, TypeError):
-            return default
-    
-    def parse_stars_rates() -> Dict[int, float]:
-        default_rates = {
-            100: 150.0,
-            150: 220.0,
-            250: 400.0,
-            350: 500.0,
-            500: 800.0,
-            750: 1150.0,
-            1000: 1500.0
-        }
-        
-        custom_rates = {}
-        
-        for stars in [100, 150, 250, 350, 500, 750, 1000]:
-            env_key = f"STARS_{stars}_RATE"
-            rate = get_float(env_key, 0.0)
-            if rate > 0:
-                custom_rates[stars] = rate
-        
-        if custom_rates:
-            return custom_rates
-        
-        return default_rates
-    
-    return Config(
-        BOT_TOKEN=os.getenv('BOT_TOKEN', ''),
-        BOT_USERNAME=os.getenv('BOT_USERNAME', ''),
-        DATABASE_URL=os.getenv('DATABASE_URL', 'sqlite+aiosqlite:///bot.db'),
-        REMNAWAVE_URL=os.getenv('REMNAWAVE_URL', ''),
-        REMNAWAVE_TOKEN=os.getenv('REMNAWAVE_TOKEN', ''),
-        SUBSCRIPTION_BASE_URL=os.getenv('SUBSCRIPTION_BASE_URL', ''),
-        ADMIN_IDS=parse_admin_ids(os.getenv('ADMIN_IDS', '')),
-        SUPPORT_USERNAME=os.getenv('SUPPORT_USERNAME', 'support'),
-        DEFAULT_LANGUAGE=os.getenv('DEFAULT_LANGUAGE', 'ru'),
-        TRIAL_ENABLED=get_bool('TRIAL_ENABLED', False),
-        TRIAL_DURATION_DAYS=get_int('TRIAL_DURATION_DAYS', 3),
-        TRIAL_TRAFFIC_GB=get_int('TRIAL_TRAFFIC_GB', 2),
-        TRIAL_SQUAD_UUID=os.getenv('TRIAL_SQUAD_UUID', ''),
-        REFERRAL_FIRST_REWARD=get_float('REFERRAL_FIRST_REWARD', 150.0),
-        REFERRAL_REFERRED_BONUS=get_float('REFERRAL_REFERRED_BONUS', 150.0), 
-        REFERRAL_THRESHOLD=get_float('REFERRAL_THRESHOLD', 300.0),
-        REFERRAL_PERCENTAGE=get_float('REFERRAL_PERCENTAGE', 0.25),
-        MONITOR_ENABLED=get_bool('MONITOR_ENABLED', True),
-        MONITOR_CHECK_INTERVAL=get_int('MONITOR_CHECK_INTERVAL', 3600),  
-        MONITOR_DAILY_CHECK_HOUR=get_int('MONITOR_DAILY_CHECK_HOUR', 10),  
-        MONITOR_WARNING_DAYS=get_int('MONITOR_WARNING_DAYS', 3),  
-        DELETE_EXPIRED_TRIAL_DAYS=get_int('DELETE_EXPIRED_TRIAL_DAYS', 1),
-        DELETE_EXPIRED_REGULAR_DAYS=get_int('DELETE_EXPIRED_REGULAR_DAYS', 7),
-        AUTO_DELETE_ENABLED=get_bool('AUTO_DELETE_ENABLED', False),
-        TRIAL_NOTIFICATION_ENABLED=get_bool('TRIAL_NOTIFICATION_ENABLED', True),
-        TRIAL_NOTIFICATION_HOURS_AFTER=get_int('TRIAL_NOTIFICATION_HOURS_AFTER', 2),
-        TRIAL_NOTIFICATION_HOURS_WINDOW=get_int('TRIAL_NOTIFICATION_HOURS_WINDOW', 22),
-        LUCKY_GAME_ENABLED=get_bool('LUCKY_GAME_ENABLED', True),
-        LUCKY_GAME_REWARD=get_float('LUCKY_GAME_REWARD', 50.0),
-        LUCKY_GAME_NUMBERS=get_int('LUCKY_GAME_NUMBERS', 30),
-        LUCKY_GAME_WINNING_COUNT=get_int('LUCKY_GAME_WINNING_COUNT', 3),
-        STARS_ENABLED=get_bool('STARS_ENABLED', True),
-        STARS_RATES=parse_stars_rates(),
-        TRIBUTE_ENABLED=get_bool('TRIBUTE_ENABLED', False),
-        TRIBUTE_API_KEY=os.getenv('TRIBUTE_API_KEY', ''),
-        TRIBUTE_WEBHOOK_PORT=get_int('TRIBUTE_WEBHOOK_PORT', 8081),
-        TRIBUTE_WEBHOOK_PATH=os.getenv('TRIBUTE_WEBHOOK_PATH', '/tribute-webhook'),
-        TRIBUTE_DONATE_URL=os.getenv('TRIBUTE_DONATE_URL', ''),
-        TRIBUTE_DONATE_LINK=os.getenv('TRIBUTE_DONATE_LINK', '')
-    )
-
-def debug_environment():
-    env_vars = [
-        'BOT_TOKEN', 'BOT_USERNAME', 'DATABASE_URL',
-        'REMNAWAVE_URL', 'REMNAWAVE_TOKEN', 'ADMIN_IDS',
-        'REFERRAL_FIRST_REWARD', 'REFERRAL_THRESHOLD',
-        'MONITOR_ENABLED', 'MONITOR_CHECK_INTERVAL',
-        'DELETE_EXPIRED_TRIAL_DAYS', 'DELETE_EXPIRED_REGULAR_DAYS', 'AUTO_DELETE_ENABLED',
-        'LUCKY_GAME_ENABLED', 'LUCKY_GAME_REWARD',
-        'STARS_ENABLED', 'STARS_100_RATE', 'STARS_500_RATE', 'STARS_1000_RATE'
-    ]
-    
-    print("📋 Environment variables:")
-    for var in env_vars:
-        value = os.getenv(var, 'NOT SET')
-        if 'TOKEN' in var and value != 'NOT SET':
-            value = value[:10] + "..." if len(value) > 10 else value
-        print(f"   {var}: {value}")

keyboards.py

@@ -1,947 +0,0 @@
-from database import Subscription
-from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
-from typing import List, Optional, Dict
-from translations import t
-from datetime import datetime
-
-def language_keyboard() -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="🇷🇺 Русский", callback_data="lang_ru"),
-            InlineKeyboardButton(text="🇺🇸 English", callback_data="lang_en")
-        ]
-    ])
-    return keyboard
-
-def main_menu_keyboard(lang: str = 'ru', is_admin: bool = False, show_trial: bool = False, show_lucky_game: bool = False) -> InlineKeyboardMarkup:
-    buttons = [
-        [
-            InlineKeyboardButton(text="💰 " + t('balance', lang), callback_data="balance"),
-            InlineKeyboardButton(text="📋 " + t('my_subscriptions', lang), callback_data="my_subscriptions")
-        ],
-        [InlineKeyboardButton(text="🛒 " + t('buy_subscription', lang), callback_data="buy_subscription")],
-    ]
-
-    if show_trial:
-        buttons.insert(1, [InlineKeyboardButton(text="🆓 Тестовая подписка", callback_data="trial_subscription")])
-
-    if show_lucky_game:
-        buttons.append([InlineKeyboardButton(text="🎰 Проверь свою удачу!", callback_data="lucky_game")])
-
-    buttons.extend([
-        [
-            InlineKeyboardButton(text="🎁 " + t('promocode', lang), callback_data="promocode"),
-            InlineKeyboardButton(text="👥 Рефералы", callback_data="referral_program")
-        ],
-        [
-            InlineKeyboardButton(text="💬 " + t('support', lang), callback_data="support")
-        ],
-        [InlineKeyboardButton(text="🌐 " + t('change_language', lang), callback_data="change_language")],
-        [InlineKeyboardButton(text="📜 Правила сервиса", callback_data="service_rules")]
-    ])
-
-    if is_admin:
-        buttons.append([InlineKeyboardButton(text="⚙️ " + t('admin_panel', lang), callback_data="admin_panel")])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def balance_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="💳 " + t('topup_balance', lang), callback_data="topup_balance")],
-        [InlineKeyboardButton(text="📊 " + t('payment_history', lang), callback_data="payment_history")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="main_menu")]
-    ])
-    return keyboard
-
-def topup_keyboard(lang: str, tribute_enabled: bool = False, stars_enabled: bool = False) -> InlineKeyboardMarkup:
-    keyboard = []
-    
-    if tribute_enabled:
-        keyboard.append([
-            InlineKeyboardButton(
-                text="💳 Tribute (Карта)" if lang == 'ru' else "💳 Tribute (Card/SBP)",
-                callback_data="topup_tribute"
-            )
-        ])
-    
-    if stars_enabled:
-        keyboard.append([
-            InlineKeyboardButton(
-                text="⭐ Telegram Stars" if lang == 'ru' else "⭐ Telegram Stars",
-                callback_data="topup_stars"
-            )
-        ])
-    
-    keyboard.extend([
-        [InlineKeyboardButton(
-            text="💬 Связаться с поддержкой" if lang == 'ru' else "💬 Contact Support",
-            callback_data="topup_support"
-        )],
-        [InlineKeyboardButton(
-            text="🔙 Назад" if lang == 'ru' else "🔙 Back",
-            callback_data="balance"
-        )]
-    ])
-    
-    return InlineKeyboardMarkup(inline_keyboard=keyboard)
-
-
-def subscriptions_keyboard(subscriptions: List[dict], lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    for i in range(0, len(subscriptions), 2):
-        row = []
-        for j in range(2):
-            if i + j < len(subscriptions):
-                sub = subscriptions[i + j]
-                price_text = f"{sub['price']:.0f}₽"
-                if sub['price'] <= 100:
-                    emoji = "🥉"
-                elif sub['price'] <= 300:
-                    emoji = "🥈"
-                else:
-                    emoji = "🥇"
-                
-                row.append(InlineKeyboardButton(
-                    text=f"{emoji} {sub['name']} - {price_text}",
-                    callback_data=f"buy_sub_{sub['id']}"
-                ))
-        buttons.append(row)
-    
-    buttons.append([InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="main_menu")])
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def subscription_detail_keyboard(subscription_id: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(
-            text="💎 " + t('buy_subscription_btn', lang, price=0), 
-            callback_data=f"confirm_buy_{subscription_id}"
-        )],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="buy_subscription")]
-    ])
-    return keyboard
-
-def user_subscriptions_keyboard(user_subscriptions: List[dict], lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    for sub in user_subscriptions:
-        buttons.append([InlineKeyboardButton(
-            text=f"📱 {sub['name']}",
-            callback_data=f"view_sub_{sub['id']}"
-        )])
-    
-    if not user_subscriptions:
-        buttons.append([InlineKeyboardButton(text="🛒 " + t('buy_subscription', lang), callback_data="buy_subscription")])
-    
-    buttons.append([InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="main_menu")])
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def user_subscription_detail_keyboard(subscription_id: int, lang: str = 'ru', 
-                                   show_extend: bool = False, is_imported: bool = False, 
-                                   is_trial: bool = False, autopay_enabled: bool = False) -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if is_imported:
-        buttons.append([InlineKeyboardButton(text="🔗 Получить ссылку подключения", callback_data=f"get_connection_{subscription_id}")])
-        buttons.append([InlineKeyboardButton(text="🛒 Купить новую подписку", callback_data="buy_subscription")])
-    elif is_trial:
-        buttons.append([InlineKeyboardButton(text="🔗 Получить ссылку подключения", callback_data=f"get_connection_{subscription_id}")])
-        buttons.append([InlineKeyboardButton(text="🛒 Купить полную подписку", callback_data="buy_subscription")])
-    else:
-        if show_extend:
-            buttons.append([InlineKeyboardButton(text="⏰ " + t('extend_subscription', lang), callback_data=f"extend_sub_{subscription_id}")])
-        
-        buttons.append([InlineKeyboardButton(text="🔗 Получить ссылку подключения", callback_data=f"get_connection_{subscription_id}")])
-        
-        if autopay_enabled:
-            autopay_text = "🔄✅ Настроить автоплатеж"
-        else:
-            autopay_text = "🔄❌ Настроить автоплатеж"
-        
-        buttons.append([InlineKeyboardButton(text=autopay_text, callback_data=f"autopay_settings_{subscription_id}")])
-    
-    buttons.append([InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="my_subscriptions")])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def autopay_confirmation_keyboard(subscription_id: int, action: str, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✅ Да", callback_data=f"confirm_autopay_{action}_{subscription_id}"),
-            InlineKeyboardButton(text="❌ Нет", callback_data=f"autopay_settings_{subscription_id}")
-        ]
-    ])
-    return keyboard
-
-def autopay_help_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    """Клавиатура помощи по автоплатежам"""
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="💰 Пополнить баланс", callback_data="topup_balance")],
-        [InlineKeyboardButton(text="📋 Мои подписки", callback_data="my_subscriptions")],
-        [InlineKeyboardButton(text="🏠 Главное меню", callback_data="main_menu")]
-    ])
-    return keyboard
-
-def extend_subscription_keyboard(subscription_id: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✅ Да, продлить", callback_data=f"confirm_extend_{subscription_id}"),
-            InlineKeyboardButton(text="❌ Отмена", callback_data=f"view_sub_{subscription_id}")
-        ]
-    ])
-    return keyboard
-
-def back_keyboard(callback_data: str, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data=callback_data)]
-    ])
-    return keyboard
-
-def cancel_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="❌ " + t('cancel', lang), callback_data="main_menu")]
-    ])
-    return keyboard
-
-
-def admin_menu_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="📦 " + t('manage_subscriptions', lang), callback_data="admin_subscriptions"),
-            InlineKeyboardButton(text="👥 " + t('manage_users', lang), callback_data="admin_users")
-        ],
-        [
-            InlineKeyboardButton(text="💰 " + t('manage_balance', lang), callback_data="admin_balance"),
-            InlineKeyboardButton(text="🎁 " + t('manage_promocodes', lang), callback_data="admin_promocodes")
-        ],
-        [
-            InlineKeyboardButton(text="📨 " + t('send_message', lang), callback_data="admin_messages"),
-            InlineKeyboardButton(text="👥 Рефералы", callback_data="admin_referrals")
-        ],
-        [
-            InlineKeyboardButton(text="📜 Правила сервиса", callback_data="admin_rules"),
-            InlineKeyboardButton(text="🔄 Автоплатежи", callback_data="admin_autopay")
-        ],
-        [
-            InlineKeyboardButton(text="🖥 Система RemnaWave", callback_data="admin_system"),
-            InlineKeyboardButton(text="🔍 Мониторинг подписок", callback_data="admin_monitor")
-        ],
-        [
-            InlineKeyboardButton(text="📊 " + t('statistics', lang), callback_data="admin_stats")
-        ],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="main_menu")]
-    ])
-    return keyboard
-
-def admin_subscriptions_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="➕ " + t('create_subscription', lang), callback_data="create_subscription")],
-        [InlineKeyboardButton(text="📋 Список подписок", callback_data="list_admin_subscriptions")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def admin_users_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="👥 Список пользователей", callback_data="list_users")],
-        [InlineKeyboardButton(text="📋 Все подписки пользователей", callback_data="admin_user_subscriptions_all")],
-        [InlineKeyboardButton(text="🔍 Поиск пользователя", callback_data="search_user")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def admin_users_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="👥 Список пользователей", callback_data="list_users")],
-        [InlineKeyboardButton(text="📋 Все подписки пользователей", callback_data="admin_user_subscriptions_all")],
-        [InlineKeyboardButton(text="🔍 Поиск пользователя", callback_data="search_user")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def admin_user_subscriptions_filters_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    """Клавиатура фильтров для подписок пользователей"""
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="🟢 Активные", callback_data="filter_subs_active"),
-            InlineKeyboardButton(text="🔴 Истекшие", callback_data="filter_subs_expired")
-        ],
-        [
-            InlineKeyboardButton(text="🔄✅ С автоплатежом", callback_data="filter_subs_autopay"),
-            InlineKeyboardButton(text="⏰ Истекают скоро", callback_data="filter_subs_expiring")
-        ],
-        [
-            InlineKeyboardButton(text="🆓 Триальные", callback_data="filter_subs_trial"),
-            InlineKeyboardButton(text="📦 Импортированные", callback_data="filter_subs_imported")
-        ],
-        [
-            InlineKeyboardButton(text="📋 Все подписки", callback_data="admin_user_subscriptions_all"),
-            InlineKeyboardButton(text="🔙 Назад", callback_data="admin_users")
-        ]
-    ])
-    return keyboard
-
-def admin_user_subscription_detail_keyboard(subscription_id: int, user_id: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    """Клавиатура для детального просмотра подписки пользователя"""
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✏️ Редактировать", callback_data=f"edit_user_sub_{subscription_id}"),
-            InlineKeyboardButton(text="🔄 Обновить", callback_data=f"refresh_user_sub_{subscription_id}")
-        ],
-        [
-            InlineKeyboardButton(text="👤 К пользователю", callback_data=f"admin_user_detail_{user_id}"),
-            InlineKeyboardButton(text="📋 К списку подписок", callback_data="admin_user_subscriptions_all")
-        ],
-        [InlineKeyboardButton(text="🔙 Назад", callback_data="admin_users")]
-    ])
-    return keyboard
-
-def user_subscriptions_pagination_keyboard(current_page: int, total_pages: int, 
-                                         filter_type: str = "all", lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if total_pages > 1:
-        nav_row = []
-        
-        if current_page > 0:
-            nav_row.append(InlineKeyboardButton(text="⬅️", callback_data=f"user_subs_page_{current_page - 1}_{filter_type}"))
-        
-        nav_row.append(InlineKeyboardButton(text=f"{current_page + 1}/{total_pages}", callback_data="noop"))
-        
-        if current_page < total_pages - 1:
-            nav_row.append(InlineKeyboardButton(text="➡️", callback_data=f"user_subs_page_{current_page + 1}_{filter_type}"))
-        
-        buttons.append(nav_row)
-    
-    buttons.append([
-        InlineKeyboardButton(text="🔍 Фильтры", callback_data="admin_user_subscriptions_filters"),
-        InlineKeyboardButton(text="🔄 Обновить", callback_data=f"refresh_user_subs_{filter_type}")
-    ])
-    
-    buttons.append([InlineKeyboardButton(text="🔙 Назад", callback_data="admin_users")])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def admin_balance_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="💸 Пополнить баланс пользователю", callback_data="admin_add_balance")],
-        [InlineKeyboardButton(text="📊 История платежей", callback_data="admin_payment_history")],
-        [InlineKeyboardButton(text="⭐ Telegram Stars", callback_data="admin_stars_payments")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def admin_promocodes_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="➕ " + t('create_promocode', lang), callback_data="create_promocode")],
-        [InlineKeyboardButton(text="📋 Управление промокодами", callback_data="list_promocodes")],
-        [InlineKeyboardButton(text="📊 Статистика промокодов", callback_data="promocodes_stats")],
-        [InlineKeyboardButton(text="🧹 Очистить истекшие", callback_data="cleanup_expired_promos")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def promocodes_management_keyboard(promocodes: List, lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    for promo in promocodes[:15]:
-        status_emoji = "🟢" if promo.is_active else "🔴"
-        
-        if promo.expires_at and promo.expires_at < datetime.utcnow():
-            status_emoji = "⏰"
-        
-        usage_text = f"{promo.used_count}/{promo.usage_limit}"
-        button_text = f"{status_emoji} {promo.code} ({promo.discount_amount}₽) [{usage_text}]"
-        
-        buttons.append([
-            InlineKeyboardButton(
-                text=button_text,
-                callback_data=f"promo_info_{promo.id}"
-            )
-        ])
-        
-        control_buttons = []
-        
-        if not promo.code.startswith('REF'):
-            toggle_text = "🔴" if promo.is_active else "🟢"
-            control_buttons.append(
-                InlineKeyboardButton(text=toggle_text, callback_data=f"toggle_promo_{promo.id}")
-            )
-            
-            control_buttons.append(
-                InlineKeyboardButton(text="✏️", callback_data=f"edit_promo_{promo.id}")
-            )
-            
-            control_buttons.append(
-                InlineKeyboardButton(text="🗑", callback_data=f"delete_promo_{promo.id}")
-            )
-        else:
-            control_buttons.append(
-                InlineKeyboardButton(text="👥 Реферальный", callback_data="noop")
-            )
-        
-        if control_buttons:
-            buttons.append(control_buttons)
-    
-    buttons.append([
-        InlineKeyboardButton(text="➕ Создать промокод", callback_data="create_promocode")
-    ])
-    
-    buttons.append([
-        InlineKeyboardButton(text="🧹 Очистить истекшие", callback_data="cleanup_expired_promos"),
-        InlineKeyboardButton(text="📊 Статистика", callback_data="promocodes_stats")
-    ])
-    
-    buttons.append([
-        InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_promocodes")
-    ])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-
-def promocode_edit_keyboard(promo_id: int, language: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = [
-        [InlineKeyboardButton(text="💰 Изменить скидку", callback_data=f"edit_promo_field_{promo_id}_discount")],
-        [InlineKeyboardButton(text="📊 Изменить лимит", callback_data=f"edit_promo_field_{promo_id}_limit")],
-        [InlineKeyboardButton(text="⏰ Изменить срок", callback_data=f"edit_promo_field_{promo_id}_expiry")],
-        [InlineKeyboardButton(text="🗑 Удалить промокод", callback_data=f"delete_promo_{promo_id}")],
-        [InlineKeyboardButton(text=t('back', language), callback_data="list_promocodes")]
-    ]
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def promocode_info_keyboard(promo_id: int, is_referral: bool = False, lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if not is_referral:
-        buttons.extend([
-            [InlineKeyboardButton(text="✏️ Редактировать", callback_data=f"edit_promo_{promo_id}")],
-            [
-                InlineKeyboardButton(text="🟢/🔴 Переключить", callback_data=f"toggle_promo_{promo_id}"),
-                InlineKeyboardButton(text="🗑 Удалить", callback_data=f"delete_promo_{promo_id}")
-            ]
-        ])
-    else:
-        buttons.append([
-            InlineKeyboardButton(text="👥 Реферальный код", callback_data="noop")
-        ])
-    
-    buttons.append([
-        InlineKeyboardButton(text="🔙 К списку", callback_data="list_promocodes")
-    ])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def bulk_promocodes_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = [
-        [InlineKeyboardButton(text="🧹 Удалить все истекшие", callback_data="confirm_cleanup_expired")],
-        [InlineKeyboardButton(text="🔴 Деактивировать все", callback_data="confirm_deactivate_all")],
-        [InlineKeyboardButton(text="📊 Экспорт статистики", callback_data="export_promo_stats")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="list_promocodes")]
-    ]
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def confirmation_keyboard(confirm_callback: str, cancel_callback: str, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✅ Да", callback_data=confirm_callback),
-            InlineKeyboardButton(text="❌ Нет", callback_data=cancel_callback)
-        ]
-    ])
-    return keyboard
-
-def pagination_keyboard(page: int, total_pages: int, prefix: str, lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if total_pages > 1:
-        nav_buttons = []
-        if page > 1:
-            nav_buttons.append(InlineKeyboardButton(text="⬅️ Назад", callback_data=f"{prefix}_page_{page-1}"))
-        
-        nav_buttons.append(InlineKeyboardButton(text=f"📄 {page}/{total_pages}", callback_data="noop"))
-        
-        if page < total_pages:
-            nav_buttons.append(InlineKeyboardButton(text="Вперед ➡️", callback_data=f"{prefix}_page_{page+1}"))
-        
-        buttons.append(nav_buttons)
-    
-    buttons.append([InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")])
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def admin_subscriptions_list_keyboard(subs: List[Subscription], lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    for sub in subs:
-        status_emoji = "🟢" if sub.is_active else "🔴"
-        price = f"{sub.price:.0f}₽"
-        
-        buttons.append([
-            InlineKeyboardButton(
-                text=f"{status_emoji} {sub.name} — {price}",
-                callback_data=f"list_sub_{sub.id}"
-            )
-        ])
-        
-        control_buttons = [
-            InlineKeyboardButton(text="✏️", callback_data=f"edit_sub_{sub.id}"),
-            InlineKeyboardButton(
-                text="🟢" if not sub.is_active else "🔴",
-                callback_data=f"toggle_sub_{sub.id}"
-            ),
-            InlineKeyboardButton(text="🗑", callback_data=f"delete_sub_{sub.id}")
-        ]
-        
-        buttons.append(control_buttons)
-    
-    buttons.append([InlineKeyboardButton(text="➕ Создать подписку", callback_data="create_subscription")])
-    buttons.append([InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_subscriptions")])
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def admin_payment_keyboard(payment_id: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✅ Одобрить платеж", callback_data=f"approve_payment_{payment_id}"),
-            InlineKeyboardButton(text="❌ Отклонить", callback_data=f"reject_payment_{payment_id}")
-        ]
-    ])
-    return keyboard
-
-def admin_messages_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="👤 " + t('send_to_user', lang), callback_data="admin_send_to_user")],
-        [InlineKeyboardButton(text="📢 " + t('send_to_all', lang), callback_data="admin_send_to_all")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def quick_topup_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="💳 100₽", callback_data="quick_topup_100"),
-            InlineKeyboardButton(text="💳 300₽", callback_data="quick_topup_300")
-        ],
-        [
-            InlineKeyboardButton(text="💳 500₽", callback_data="quick_topup_500"),
-            InlineKeyboardButton(text="💳 1000₽", callback_data="quick_topup_1000")
-        ],
-        [InlineKeyboardButton(text="💰 Другая сумма", callback_data="topup_support")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="balance")]
-    ])
-    return keyboard
-
-def connection_keyboard(subscription_url: str, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🔗 Подключиться", url=subscription_url)],
-        [InlineKeyboardButton(text="📱 Инструкция", callback_data="connection_guide")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="my_subscriptions")]
-    ])
-    return keyboard
-
-def trial_subscription_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = [
-        [InlineKeyboardButton(text="✅ Получить тестовую подписку", callback_data="confirm_trial")],
-        [InlineKeyboardButton(text=t('back', lang), callback_data="main_menu")]
-    ]
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def admin_monitor_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📊 Статус сервиса", callback_data="monitor_status")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def admin_system_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📊 Системная статистика", callback_data="system_stats")],
-        [InlineKeyboardButton(text="🖥 Управление нодами", callback_data="nodes_management")],
-        [InlineKeyboardButton(text="👥 Пользователи системы", callback_data="system_users")],
-        [InlineKeyboardButton(text="🔄 Синхронизация с RemnaWave", callback_data="sync_remnawave")],
-        [InlineKeyboardButton(text="🔍 Отладка API", callback_data="debug_api_comprehensive")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def system_stats_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🔄 Обновить статистику", callback_data="refresh_system_stats")],
-        [InlineKeyboardButton(text="🖥 Ноды", callback_data="nodes_management")],
-        [InlineKeyboardButton(text="👥 Системные пользователи", callback_data="system_users")],
-        [InlineKeyboardButton(text="🔙 Назад", callback_data="admin_system")]
-    ])
-    return keyboard
-
-def nodes_management_keyboard(nodes: List[Dict], lang: str = 'ru', timestamp: int = None) -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if nodes:
-        online_count = len([n for n in nodes if n.get('status') == 'online'])
-        total_count = len(nodes)
-        
-        buttons.append([
-            InlineKeyboardButton(
-                text=f"📊 Ноды: {online_count}/{total_count} онлайн",
-                callback_data="noop"
-            )
-        ])
-        
-        for i, node in enumerate(nodes[:5]):
-            status = node.get('status', 'unknown')
-            
-            if status == 'online':
-                status_emoji = "🟢"
-            elif status == 'disabled':
-                status_emoji = "⚫"
-            elif status == 'disconnected':
-                status_emoji = "🔴"
-            elif status == 'xray_stopped':
-                status_emoji = "🟡"
-            else:
-                status_emoji = "⚪"
-            
-            node_name = node.get('name', f'Node-{i+1}')
-            node_id = node.get('id', node.get('uuid'))
-            
-            if len(node_name) > 20:
-                display_name = node_name[:17] + "..."
-            else:
-                display_name = node_name
-            
-            usage_info = ""
-            if node.get('cpuUsage'):
-                usage_info += f" CPU:{node['cpuUsage']:.0f}%"
-            if node.get('memUsage'):
-                usage_info += f" MEM:{node['memUsage']:.0f}%"
-            
-            buttons.append([
-                InlineKeyboardButton(
-                    text=f"{status_emoji} {display_name}{usage_info}",
-                    callback_data=f"node_details_{node_id}"
-                ),
-                InlineKeyboardButton(
-                    text="🔄",
-                    callback_data=f"restart_node_{node_id}"
-                ),
-                InlineKeyboardButton(
-                    text="⚙️",
-                    callback_data=f"node_settings_{node_id}"
-                )
-            ])
-        
-        if len(nodes) > 5:
-            buttons.append([
-                InlineKeyboardButton(
-                    text=f"... и еще {len(nodes) - 5} нод",
-                    callback_data="show_all_nodes"
-                )
-            ])
-    else:
-        buttons.append([
-            InlineKeyboardButton(
-                text="❌ Ноды не найдены",
-                callback_data="noop"
-            )
-        ])
-    
-    buttons.append([
-        InlineKeyboardButton(text="🔄 Перезагрузить все", callback_data="restart_all_nodes"),
-        InlineKeyboardButton(text="📊 Статистика", callback_data="nodes_statistics")
-    ])
-    
-    refresh_callback = f"refresh_nodes_stats_{timestamp}" if timestamp else "refresh_nodes_stats"
-    buttons.append([
-        InlineKeyboardButton(text="🔄 Обновить", callback_data=refresh_callback)
-    ])
-    
-    buttons.append([
-        InlineKeyboardButton(text="🔙 Назад", callback_data="admin_system")
-    ])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def system_users_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📊 Статистика пользователей", callback_data="users_statistics")],
-        [InlineKeyboardButton(text="👥 Список всех пользователей", callback_data="list_all_system_users")],
-        [InlineKeyboardButton(text="🔍 Поиск пользователя", callback_data="search_user_uuid")],
-        [InlineKeyboardButton(text="🔍 Отладка API пользователей", callback_data="debug_users_api")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_system")]
-    ])
-    return keyboard
-
-def bulk_operations_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="bulk_reset_traffic")],
-        [InlineKeyboardButton(text="❌ Отключить пользователей", callback_data="bulk_disable_users")],
-        [InlineKeyboardButton(text="✅ Включить пользователей", callback_data="bulk_enable_users")],
-        [InlineKeyboardButton(text="🗑 Удалить пользователей", callback_data="bulk_delete_users")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="system_users")]
-    ])
-    return keyboard
-
-def confirm_restart_keyboard(node_id: str = None, lang: str = 'ru') -> InlineKeyboardMarkup:
-    action = f"confirm_restart_node_{node_id}" if node_id else "confirm_restart_all_nodes"
-    back_action = f"node_details_{node_id}" if node_id else "nodes_management"
-    
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✅ Да, перезагрузить", callback_data=action),
-            InlineKeyboardButton(text="❌ Отмена", callback_data=back_action)
-        ]
-    ])
-    return keyboard
-
-def admin_referrals_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📊 Статистика рефералов", callback_data="referral_statistics")],
-        [InlineKeyboardButton(text="👥 Список рефереров", callback_data="list_referrers")],
-        [InlineKeyboardButton(text="💰 История выплат", callback_data="referral_payments")],
-        [InlineKeyboardButton(text="⚙️ Настройки программы", callback_data="referral_settings")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def lucky_game_keyboard(can_play: bool, time_left_str: str = "", lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if can_play:
-        buttons.append([InlineKeyboardButton(text="🎲 Играть!", callback_data="start_lucky_game")])
-    else:
-        buttons.append([InlineKeyboardButton(text=f"⏰ Приходи через {time_left_str}", callback_data="noop")])
-    
-    buttons.extend([
-        [InlineKeyboardButton(text="📈 История игр", callback_data="lucky_game_history")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="main_menu")]
-    ])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def lucky_numbers_keyboard(numbers_count: int) -> InlineKeyboardMarkup:
-    buttons = []
-    
-    for i in range(0, numbers_count, 5):
-        row = []
-        for j in range(5):
-            if i + j + 1 <= numbers_count:
-                number = i + j + 1
-                row.append(InlineKeyboardButton(
-                    text=str(number),
-                    callback_data=f"choose_number_{number}"
-                ))
-        buttons.append(row)
-    
-    buttons.append([InlineKeyboardButton(text="❌ Отмена", callback_data="lucky_game")])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def lucky_game_result_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    return InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📈 История игр", callback_data="lucky_game_history")],
-        [InlineKeyboardButton(text="🏠 Главное меню", callback_data="main_menu")]
-    ])
-
-def stars_topup_keyboard(stars_rates: Dict[int, float], lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    sorted_rates = sorted(stars_rates.items())
-    
-    for i in range(0, len(sorted_rates), 2):
-        row = []
-        for j in range(2):
-            if i + j < len(sorted_rates):
-                stars, rubles = sorted_rates[i + j]
-                if stars >= 500:
-                    emoji = "🔥"  # Выгодное предложение
-                elif stars >= 250:
-                    emoji = "💎"  # Хорошее предложение
-                else:
-                    emoji = "⭐"  # Базовое предложение
-                
-                button_text = f"{emoji} {stars} ⭐ → {rubles:.0f}₽"
-                row.append(InlineKeyboardButton(
-                    text=button_text,
-                    callback_data=f"buy_stars_{stars}"
-                ))
-        buttons.append(row)
-    
-    buttons.append([InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="topup_balance")])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def stars_payment_keyboard(stars_amount: int, rub_amount: float, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="❌ Отмена", callback_data="topup_stars")]
-    ])
-    return keyboard
-
-def service_rules_keyboard(current_page: int, total_pages: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if total_pages > 1:
-        nav_row = []
-        
-        if current_page > 0:
-            nav_row.append(InlineKeyboardButton(text="⬅️ Назад", callback_data=f"rules_page_{current_page - 1}"))
-        
-        nav_row.append(InlineKeyboardButton(text=f"{current_page + 1}/{total_pages}", callback_data="noop"))
-        
-        if current_page < total_pages - 1:
-            nav_row.append(InlineKeyboardButton(text="Вперед ➡️", callback_data=f"rules_page_{current_page + 1}"))
-        
-        buttons.append(nav_row)
-    
-    buttons.append([InlineKeyboardButton(text="🏠 Главное меню", callback_data="main_menu")])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def admin_rules_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="📋 Список правил", callback_data="admin_rules_list")],
-        [InlineKeyboardButton(text="➕ Добавить страницу", callback_data="admin_rules_create")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_panel")]
-    ])
-    return keyboard
-
-def admin_rules_list_keyboard(rules, lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    for rule in rules:
-        status_emoji = "🟢" if rule.is_active else "🔴"
-        buttons.append([
-            InlineKeyboardButton(
-                text=f"{status_emoji} {rule.page_order}. {rule.title}",
-                callback_data=f"admin_rule_view_{rule.id}"
-            )
-        ])
-    
-    buttons.extend([
-        [InlineKeyboardButton(text="➕ Добавить страницу", callback_data="admin_rules_create")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="admin_rules")]
-    ])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def admin_rule_edit_keyboard(rule_id: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✏️ Редактировать заголовок", callback_data=f"admin_rule_edit_title_{rule_id}"),
-            InlineKeyboardButton(text="📝 Редактировать содержимое", callback_data=f"admin_rule_edit_content_{rule_id}")
-        ],
-        [
-            InlineKeyboardButton(text="🔄 Изменить порядок", callback_data=f"admin_rule_edit_order_{rule_id}"),
-            InlineKeyboardButton(text="🟢/🔴 Вкл/Выкл", callback_data=f"admin_rule_toggle_{rule_id}")
-        ],
-        [InlineKeyboardButton(text="🗑 Удалить", callback_data=f"admin_rule_delete_{rule_id}")],
-        [InlineKeyboardButton(text="🔙 К списку", callback_data="admin_rules_list")]
-    ])
-    return keyboard
-
-def admin_rule_delete_confirm_keyboard(rule_id: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [
-            InlineKeyboardButton(text="✅ Да, удалить", callback_data=f"admin_rule_confirm_delete_{rule_id}"),
-            InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_rule_view_{rule_id}")
-        ]
-    ])
-    return keyboard
-
-def autopay_settings_keyboard(user_sub_id: int, user_sub, lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    if user_sub.auto_pay_enabled:
-        toggle_text = "❌ Отключить автоплатеж"
-        toggle_callback = f"toggle_autopay_{user_sub_id}"
-    else:
-        toggle_text = "✅ Включить автоплатеж"
-        toggle_callback = f"toggle_autopay_{user_sub_id}"
-    
-    buttons.append([InlineKeyboardButton(text=toggle_text, callback_data=toggle_callback)])
-    
-    if user_sub.auto_pay_enabled:
-        buttons.append([InlineKeyboardButton(text="📅 Настроить дни до продления", callback_data="noop")])
-        
-        days_row = []
-        for days in [1, 3, 5, 7]:
-            emoji = "🔹" if user_sub.auto_pay_days_before == days else "⚪"
-            days_row.append(InlineKeyboardButton(
-                text=f"{emoji} {days}д",
-                callback_data=f"autopay_days_{user_sub_id}_{days}"
-            ))
-        buttons.append(days_row)
-    
-    buttons.append([InlineKeyboardButton(text="🔙 К подписке", callback_data=f"view_sub_{user_sub_id}")])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def autopay_status_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="🔄 Обновить", callback_data="autopay_status")],
-        [InlineKeyboardButton(text="🚀 Принудительная проверка", callback_data="autopay_force_check")],
-        [InlineKeyboardButton(text="📋 Список подписок", callback_data="autopay_subscriptions_list")],
-        [InlineKeyboardButton(text="🔙 Назад", callback_data="admin_autopay")]
-    ])
-    return keyboard
-
-def autopay_subscriptions_keyboard(subscriptions_data: List[Dict], lang: str = 'ru') -> InlineKeyboardMarkup:
-    buttons = []
-    
-    expired = [s for s in subscriptions_data if s['expires_in_days'] <= 0]
-    due_soon = [s for s in subscriptions_data if 0 < s['expires_in_days'] <= s['auto_pay_days_before']]
-    
-    critical_subs = expired + due_soon
-    
-    for sub_data in critical_subs[:8]: 
-        username = sub_data['username'] if sub_data['username'] != 'N/A' else f"ID:{sub_data['user_id']}"
-        days = sub_data['expires_in_days']
-        
-        if days <= 0:
-            status_emoji = "❌"
-            status_text = f"Истекла"
-        elif days <= sub_data['auto_pay_days_before']:
-            status_emoji = "⚠️"
-            status_text = f"Через {days}д"
-        else:
-            status_emoji = "✅"
-            status_text = f"Через {days}д"
-        
-        button_text = f"{status_emoji} @{username} ({status_text})"
-        
-        buttons.append([
-            InlineKeyboardButton(
-                text=button_text,
-                callback_data=f"autopay_user_detail_{sub_data['user_id']}"
-            )
-        ])
-    
-    if len(subscriptions_data) > 8:
-        buttons.append([
-            InlineKeyboardButton(
-                text=f"... и еще {len(subscriptions_data) - 8}",
-                callback_data="noop"
-            )
-        ])
-    
-    buttons.extend([
-        [InlineKeyboardButton(text="🔄 Обновить", callback_data="autopay_subscriptions_list")],
-        [InlineKeyboardButton(text="📊 Статистика", callback_data="autopay_statistics")],
-        [InlineKeyboardButton(text="🔙 Назад", callback_data="admin_autopay")]
-    ])
-    
-    return InlineKeyboardMarkup(inline_keyboard=buttons)
-
-def autopay_user_detail_keyboard(user_id: int, lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="💳 Добавить баланс", callback_data=f"admin_add_balance_to_{user_id}")],
-        [InlineKeyboardButton(text="📋 Управление подписками", callback_data=f"admin_user_subscriptions_{user_id}")],
-        [InlineKeyboardButton(text="🔄 Обновить", callback_data=f"autopay_user_detail_{user_id}")],
-        [InlineKeyboardButton(text="🔙 К списку", callback_data="autopay_subscriptions_list")]
-    ])
-    return keyboard
-
-
-def autopay_statistics_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="⚠️ Недостаточно средств", callback_data="autopay_insufficient_balance_users")],
-        [InlineKeyboardButton(text="📋 Список подписок", callback_data="autopay_subscriptions_list")],
-        [InlineKeyboardButton(text="🔄 Обновить", callback_data="autopay_statistics")],
-        [InlineKeyboardButton(text="🔙 Назад", callback_data="admin_autopay")]
-    ])
-    return keyboard

lucky_game.py

@@ -1,327 +0,0 @@
-import asyncio
-from datetime import datetime, timedelta, timezone
-import logging
-import random
-from typing import Optional, List
-
-from aiogram import Router, F
-from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
-from aiogram.filters import StateFilter
-from aiogram.fsm.context import FSMContext
-from aiogram.fsm.state import State, StatesGroup
-
-from database import Database, User
-from keyboards import back_keyboard
-from translations import t
-from utils import log_user_action, format_datetime
-
-logger = logging.getLogger(__name__)
-
-class LuckyGameStates(StatesGroup):
-    waiting_number_choice = State()
-
-lucky_game_router = Router()
-
-
-@lucky_game_router.callback_query(F.data == "lucky_game")
-async def lucky_game_menu_callback(callback: CallbackQuery, db: Database, **kwargs):
-    user = kwargs.get('user')
-    config = kwargs.get('config')
-    
-    if not user:
-        await callback.answer("❌ Ошибка пользователя")
-        return
-    
-    try:
-        reward_amount = getattr(config, 'LUCKY_GAME_REWARD', 50.0)
-        numbers_count = getattr(config, 'LUCKY_GAME_NUMBERS', 30)
-        winning_numbers = getattr(config, 'LUCKY_GAME_WINNING_COUNT', 3)
-        
-        can_play, next_game_time = await check_can_play_today(db, user.telegram_id)
-        
-        games_played, total_won, win_count = await get_user_game_stats(db, user.telegram_id)
-        
-        text = "🎰 **Проверь свою удачу!**\n\n"
-        text += "🎯 **Как играть:**\n"
-        text += f"• Выберите число от 1 до {numbers_count}\n"
-        text += f"• Из {numbers_count} чисел {winning_numbers} - выигрышные\n"
-        text += f"• Угадали - получаете {reward_amount:.0f}₽ на баланс!\n"
-        text += "• Играть можно 1 раз в сутки\n\n"
-        
-        text += "📊 **Ваша статистика:**\n"
-        text += f"• Игр сыграно: {games_played}\n"
-        text += f"• Выигрышей: {win_count}\n"
-        text += f"• Всего выиграно: {total_won:.0f}₽\n"
-        
-        if games_played > 0:
-            win_rate = (win_count / games_played) * 100
-            text += f"• Процент побед: {win_rate:.1f}%\n"
-        
-        buttons = []
-        
-        if can_play:
-            buttons.append([InlineKeyboardButton(text="🎲 Играть!", callback_data="start_lucky_game")])
-        else:
-            now = datetime.utcnow()
-            time_left = next_game_time - now
-            hours_left = int(time_left.total_seconds() // 3600)
-            minutes_left = int((time_left.total_seconds() % 3600) // 60)
-            
-            if hours_left > 0:
-                time_text = f"{hours_left}ч {minutes_left}м"
-            else:
-                time_text = f"{minutes_left}м"
-                
-            buttons.append([InlineKeyboardButton(text=f"⏰ Приходи через {time_text}", callback_data="noop")])
-        
-        buttons.extend([
-            [InlineKeyboardButton(text="📈 История игр", callback_data="lucky_game_history")],
-            [InlineKeyboardButton(text="🔙 " + t('back', user.language), callback_data="main_menu")]
-        ])
-        
-        keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
-        
-        await callback.message.edit_text(
-            text,
-            reply_markup=keyboard,
-            parse_mode='Markdown'
-        )
-        
-    except Exception as e:
-        logger.error(f"Error in lucky game menu: {e}")
-        await callback.answer("❌ Ошибка загрузки игры")
-
-@lucky_game_router.callback_query(F.data == "start_lucky_game")
-async def start_lucky_game_callback(callback: CallbackQuery, db: Database, state: FSMContext, **kwargs):
-    """Начать игру - показать числа для выбора"""
-    user = kwargs.get('user')
-    config = kwargs.get('config')
-    
-    if not user:
-        await callback.answer("❌ Ошибка пользователя")
-        return
-    
-    try:
-        can_play, next_game_time = await check_can_play_today(db, user.telegram_id)
-        
-        if not can_play:
-            await callback.answer("⏰ Вы уже играли сегодня! Приходите завтра.", show_alert=True)
-            return
-        
-        numbers_count = getattr(config, 'LUCKY_GAME_NUMBERS', 30)
-        winning_numbers = getattr(config, 'LUCKY_GAME_WINNING_COUNT', 3)
-        reward_amount = getattr(config, 'LUCKY_GAME_REWARD', 50.0)
-        
-        winning_nums = random.sample(range(1, numbers_count + 1), winning_numbers)
-        
-        await state.update_data(
-            winning_numbers=winning_nums,
-            reward_amount=reward_amount,
-            numbers_count=numbers_count
-        )
-        await state.set_state(LuckyGameStates.waiting_number_choice)
-        
-        text = f"🎯 **Выберите число от 1 до {numbers_count}**\n\n"
-        text += f"🎁 Награда: {reward_amount:.0f}₽\n"
-        text += f"🍀 Удачных чисел: {winning_numbers} из {numbers_count}\n\n"
-        text += "Нажмите на число, чтобы испытать удачу!"
-        
-        buttons = []
-        for i in range(0, numbers_count, 5):
-            row = []
-            for j in range(5):
-                if i + j + 1 <= numbers_count:
-                    number = i + j + 1
-                    row.append(InlineKeyboardButton(
-                        text=str(number),
-                        callback_data=f"choose_number_{number}"
-                    ))
-            buttons.append(row)
-        
-        buttons.append([InlineKeyboardButton(text="❌ Отмена", callback_data="lucky_game")])
-        
-        keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
-        
-        await callback.message.edit_text(
-            text,
-            reply_markup=keyboard,
-            parse_mode='Markdown'
-        )
-        
-    except Exception as e:
-        logger.error(f"Error starting lucky game: {e}")
-        await callback.answer("❌ Ошибка запуска игры")
-
-@lucky_game_router.callback_query(F.data.startswith("choose_number_"), StateFilter(LuckyGameStates.waiting_number_choice))
-async def choose_number_callback(callback: CallbackQuery, db: Database, state: FSMContext, **kwargs):
-    """Обработка выбора числа"""
-    user = kwargs.get('user')
-    bot = kwargs.get('bot')
-    
-    if not user:
-        await callback.answer("❌ Ошибка пользователя")
-        return
-    
-    try:
-        chosen_number = int(callback.data.split("_")[2])
-        
-        state_data = await state.get_data()
-        winning_numbers = state_data['winning_numbers']
-        reward_amount = state_data['reward_amount']
-        numbers_count = state_data['numbers_count']
-        
-        is_winner = chosen_number in winning_numbers
-        
-        await save_game_result(db, user.telegram_id, chosen_number, winning_numbers, is_winner, reward_amount if is_winner else 0.0)
-        
-        if is_winner:
-            await db.add_balance(user.telegram_id, reward_amount)
-            
-            await db.create_payment(
-                user_id=user.telegram_id,
-                amount=reward_amount,
-                payment_type='lucky_game',
-                description=f'Выигрыш в игре удачи (число {chosen_number})',
-                status='completed'
-            )
-            
-            text = "🎉 **ПОЗДРАВЛЯЕМ! ВЫ ВЫИГРАЛИ!** 🎉\n\n"
-            text += f"🎯 Ваше число: **{chosen_number}**\n"
-            text += f"💰 Награда: **{reward_amount:.0f}₽** зачислена на баланс!\n"
-            text += f"🆕 Новый баланс: **{user.balance + reward_amount:.0f}₽**\n\n"
-        else:
-            text = "😔 **Не повезло в этот раз...**\n\n"
-            text += f"🎯 Ваше число: **{chosen_number}**\n"
-            text += f"🍀 Выигрышные числа: **{', '.join(map(str, sorted(winning_numbers)))}**\n\n"
-            text += "🔄 Попробуйте завтра!"
-        
-        winning_nums_str = ', '.join(map(str, sorted(winning_numbers)))
-        text += f"\n🎲 Сегодняшние удачные числа: {winning_nums_str}"
-        text += f"\n\n⏰ Следующая игра будет доступна завтра!"
-        
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text="📈 История игр", callback_data="lucky_game_history")],
-            [InlineKeyboardButton(text="🏠 Главное меню", callback_data="main_menu")]
-        ])
-        
-        await callback.message.edit_text(
-            text,
-            reply_markup=keyboard,
-            parse_mode='Markdown'
-        )
-        
-        log_user_action(user.telegram_id, "lucky_game_played", 
-                       f"Number: {chosen_number}, Winner: {is_winner}, Reward: {reward_amount if is_winner else 0}")
-        
-    except Exception as e:
-        logger.error(f"Error in choose number: {e}")
-        await callback.answer("❌ Ошибка обработки выбора")
-    
-    await state.clear()
-
-@lucky_game_router.callback_query(F.data == "lucky_game_history")
-async def lucky_game_history_callback(callback: CallbackQuery, db: Database, **kwargs):
-    user = kwargs.get('user')
-    
-    if not user:
-        await callback.answer("❌ Ошибка пользователя")
-        return
-    
-    try:
-        games = await get_user_game_history(db, user.telegram_id, limit=10)
-        
-        if not games:
-            text = "📈 **История ваших игр**\n\n"
-            text += "🎯 Вы еще не играли в игру удачи.\n\n"
-            text += "Начните играть, чтобы увидеть историю!"
-        else:
-            text = "📈 **История ваших игр** (последние 10)\n\n"
-            
-            for i, game in enumerate(games, 1):
-                date_str = format_datetime(game['played_at'], user.language)
-                
-                if game['is_winner']:
-                    emoji = "🎉"
-                    result = f"Выиграли {game['reward_amount']:.0f}₽"
-                else:
-                    emoji = "😔"
-                    result = "Не повезло"
-                
-                text += f"{i}. {emoji} Число: **{game['chosen_number']}** - {result}\n"
-                text += f"   📅 {date_str}\n\n"
-        
-        keyboard = InlineKeyboardMarkup(inline_keyboard=[
-            [InlineKeyboardButton(text="🎰 К игре", callback_data="lucky_game")],
-            [InlineKeyboardButton(text="🏠 Главное меню", callback_data="main_menu")]
-        ])
-        
-        await callback.message.edit_text(
-            text,
-            reply_markup=keyboard,
-            parse_mode='Markdown'
-        )
-        
-    except Exception as e:
-        logger.error(f"Error showing game history: {e}")
-        await callback.answer("❌ Ошибка загрузки истории")
-
-@lucky_game_router.callback_query(F.data == "noop")
-async def noop_callback(callback: CallbackQuery, **kwargs):
-    """Пустая операция для неактивных кнопок"""
-    await callback.answer()
-    
-
-async def check_can_play_today(db: Database, user_id: int) -> tuple[bool, Optional[datetime]]:
-    """Проверяет, может ли пользователь играть сегодня"""
-    try:
-        can_play = await db.can_play_lucky_game_today(user_id)
-        
-        if not can_play:
-            now = datetime.utcnow()
-            tomorrow = now.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
-            return False, tomorrow
-        
-        return True, None
-        
-    except Exception as e:
-        logger.error(f"Error checking can play today: {e}")
-        return True, None
-
-async def get_user_game_stats(db: Database, user_id: int) -> tuple[int, float, int]:
-    """Получает статистику игр пользователя"""
-    try:
-        stats = await db.get_user_game_stats(user_id)
-        return stats['total_games'], stats['total_won'], stats['total_wins']
-        
-    except Exception as e:
-        logger.error(f"Error getting user game stats: {e}")
-        return 0, 0.0, 0
-
-async def save_game_result(db: Database, user_id: int, chosen_number: int, 
-                          winning_numbers: List[int], is_winner: bool, reward_amount: float):
-    """Сохраняет результат игры в базу данных"""
-    try:
-        game = await db.create_lucky_game(
-            user_id=user_id,
-            chosen_number=chosen_number,
-            winning_numbers=winning_numbers,
-            is_winner=is_winner,
-            reward_amount=reward_amount
-        )
-        
-        if game:
-            logger.info(f"Game result saved for user {user_id}: number={chosen_number}, winner={is_winner}, reward={reward_amount}")
-        else:
-            logger.error(f"Failed to save game result for user {user_id}")
-        
-    except Exception as e:
-        logger.error(f"Error saving game result: {e}")
-
-async def get_user_game_history(db: Database, user_id: int, limit: int = 10) -> List[dict]:
-    """Получает историю игр пользователя"""
-    try:
-        return await db.get_user_game_history(user_id, limit)
-        
-    except Exception as e:
-        logger.error(f"Error getting user game history: {e}")
-        return []

main.py

@@ -1,390 +1,81 @@
 import asyncio
 import logging
 import sys
-import os
-from aiogram import Bot, Dispatcher
-from aiogram.fsm.storage.memory import MemoryStorage
-from aiogram.client.default import DefaultBotProperties
-from aiogram.enums import ParseMode
-from lucky_game import lucky_game_router
-from stars_handlers import stars_router
-from autopay_service import AutoPayService
+from pathlib import Path
 
-print("🚀 Запуск бота...")
-print(f"📍 Рабочая директория: {os.getcwd()}")
-print(f"📁 Файлы в директории: {os.listdir('.')}")
+sys.path.append(str(Path(__file__).parent))
 
-if os.path.exists('.env'):
-    print("✅ Файл .env найден")
-else:
-    print("❌ Файл .env НЕ НАЙДЕН!")
-    print("💡 Создайте файл .env в корне проекта")
+from app.bot import setup_bot
+from app.config import settings
+from app.database.database import init_db
+from app.services.monitoring_service import monitoring_service
+from app.external.webhook_server import WebhookServer
 
-from config import load_config, debug_environment
-from database import Database
-from remnawave_api import RemnaWaveAPI
-from subscription_monitor import create_subscription_monitor
-from middlewares import DatabaseMiddleware, UserMiddleware, LoggingMiddleware, ThrottlingMiddleware, WorkflowDataMiddleware, BotMiddleware
-from handlers import router
-from admin_handlers import admin_router
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('bot.log'),
-        logging.StreamHandler(sys.stdout)
-    ]
-)
-logger = logging.getLogger(__name__)
-
-class BotApplication:
-    
-    def __init__(self):
-        self.config = None
-        self.db = None
-        self.api = None
-        self.bot = None
-        self.dp = None
-        self.monitor_service = None
-        self.autopay_service = None
-        self.webhook_server = None
-
-    async def _init_autopay_service(self):
-        try:
-            logger.info("🔧 Initializing autopay service...")
-            
-            if not self.bot:
-                logger.error("❌ Bot instance is None, cannot initialize autopay")
-                return
-            
-            if not self.db:
-                logger.error("❌ Database instance is None, cannot initialize autopay")
-                return
-            
-            self.autopay_service = AutoPayService(self.db, self.api, self.bot)
-            
-            self.dp.workflow_data["autopay_service"] = self.autopay_service
-            logger.info("✅ Autopay service added to workflow_data")
-            
-            logger.info("🚀 Starting autopay service...")
-            await self.autopay_service.start()
-            
-            status = await self.autopay_service.get_service_status()
-            if status['is_running']:
-                logger.info("✅ Autopay service started successfully")
-                logger.info(f"📊 Autopay status: interval=30min")
-            else:
-                logger.warning("⚠️ Autopay service created but not running")
-            
-        except Exception as e:
-            logger.error(f"❌ Failed to initialize autopay service: {e}", exc_info=True)
-            logger.warning("⚠️ Continuing without autopay service")
-            self.autopay_service = None
-        
-    async def initialize(self):
-        
-        debug_environment()
-        
-        self.config = load_config()
-        
-        print(f"🔧 Загруженная конфигурация:")
-        print(f"   BOT_USERNAME: '{self.config.BOT_USERNAME}'")
-        print(f"   REFERRAL_FIRST_REWARD: {self.config.REFERRAL_FIRST_REWARD}")
-        print(f"   ADMIN_IDS: {self.config.ADMIN_IDS}")
-        
-        if not self.config.BOT_TOKEN:
-            logger.error("BOT_TOKEN is required")
-            raise ValueError("BOT_TOKEN is required")
-        
-        if not self.config.REMNAWAVE_URL or not self.config.REMNAWAVE_TOKEN:
-            logger.error("REMNAWAVE_URL and REMNAWAVE_TOKEN are required")
-            raise ValueError("REMNAWAVE_URL and REMNAWAVE_TOKEN are required")
-        
-        if not self.config.BOT_USERNAME:
-            logger.warning("⚠️  BOT_USERNAME не установлен! Реферальные ссылки работать не будут!")
-            print("💡 Добавьте BOT_USERNAME=your_bot_username в .env файл")
-        
-        logger.info("Starting RemnaWave Bot...")
-        logger.info(f"RemnaWave URL: {self.config.REMNAWAVE_URL}")
-        logger.info(f"Admin IDs: {self.config.ADMIN_IDS}")
-        logger.info(f"Bot Username: {self.config.BOT_USERNAME}")
-        
-        self.db = Database(self.config.DATABASE_URL)
-        
-        await self._init_database()
-        
-        self.api = RemnaWaveAPI(
-            self.config.REMNAWAVE_URL, 
-            self.config.REMNAWAVE_TOKEN, 
-            self.config.SUBSCRIPTION_BASE_URL
-        )
-        logger.info("RemnaWave API initialized")
-        
-        await self._test_api_connection()
-        
-        self.bot = Bot(
-            token=self.config.BOT_TOKEN,
-            default=DefaultBotProperties(parse_mode=ParseMode.HTML)
-        )
-        
-        await self._test_bot_token()
-        
-        self._setup_dispatcher()
-
-        await self._init_webhook_server()
-
-        if self.config.TRIBUTE_ENABLED:
-            logger.info("✅ Tribute платежи включены")
-            if not self.config.TRIBUTE_API_KEY:
-                logger.warning("⚠️ TRIBUTE_API_KEY не установлен!")
-            if not self.config.TRIBUTE_DONATE_URL:
-                logger.warning("⚠️ TRIBUTE_DONATE_URL не установлен!")
-        else:
-            logger.info("❌ Tribute платежи отключены")
-        
-        await self._init_monitor_service()
-        await self._init_autopay_service()
-
-        if self.config.STARS_ENABLED:
-            logger.info("✅ Telegram Stars пополнение включено")
-            logger.info(f"📊 Настроенные курсы: {self.config.STARS_RATES}")
-        
-            if not self.config.STARS_RATES or len(self.config.STARS_RATES) == 0:
-                logger.warning("⚠️  STARS_RATES пустые! Telegram Stars будут недоступны")
-                self.config.STARS_ENABLED = False
-            else:
-                valid_rates = all(
-                    isinstance(stars, int) and isinstance(rubles, (int, float)) and stars > 0 and rubles > 0
-                    for stars, rubles in self.config.STARS_RATES.items()
-                )
-                if not valid_rates:
-                    logger.warning("⚠️  Неверные STARS_RATES! Telegram Stars будут недоступны")
-                    self.config.STARS_ENABLED = False
-        else:
-            logger.info("❌ Telegram Stars пополнение отключено")
-
-    async def _init_webhook_server(self):
-        """Инициализация webhook сервера для Tribute"""
-        try:
-            logger.info("🔧 Initializing webhook server...")
-            
-            from webhook_server import WebhookServer
-            self.webhook_server = WebhookServer(self.bot, self.db, self.config)
-            
-            logger.info("🚀 Starting webhook server...")
-            await self.webhook_server.start()
-            
-            logger.info("✅ Webhook server started successfully")
-            
-        except Exception as e:
-            logger.error(f"❌ Failed to initialize webhook server: {e}", exc_info=True)
-            logger.warning("⚠️ Continuing without webhook server")
-            self.webhook_server = None
-        
-    async def _init_database(self):
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                logger.info(f"🗄️  Database initialization attempt {attempt + 1}/{max_retries}")
-                await self.db.init_db()
-                logger.info("✅ Database initialized successfully with all migrations")
-                break
-            except Exception as e:
-                logger.error(f"❌ Database initialization attempt {attempt + 1} failed: {e}")
-                if attempt == max_retries - 1:
-                    logger.error("💥 Failed to initialize database after all retries")
-                    raise
-                await asyncio.sleep(2)
-                
-    async def _test_api_connection(self):
-        try:
-            system_stats = await self.api.get_system_stats()
-            if system_stats:
-                logger.info("RemnaWave API connection successful")
-            else:
-                logger.warning("RemnaWave API connection test failed - continuing anyway")
-        except Exception as e:
-            logger.warning(f"RemnaWave API connection error: {e} - continuing anyway")
-            
-    async def _test_bot_token(self):
-        try:
-            bot_info = await self.bot.get_me()
-            logger.info(f"Bot started: @{bot_info.username} ({bot_info.first_name})")
-            
-            if not self.config.BOT_USERNAME and bot_info.username:
-                self.config.BOT_USERNAME = bot_info.username
-                logger.info(f"✅ BOT_USERNAME автоматически установлен: {bot_info.username}")
-                print("💡 Добавьте BOT_USERNAME в .env файл для постоянного сохранения")
-            
-        except Exception as e:
-            logger.error(f"Invalid bot token or network error: {e}")
-            raise
-            
-    def _setup_dispatcher(self):
-        storage = MemoryStorage()
-        self.dp = Dispatcher(storage=storage)
-        
-        self.dp.workflow_data.update({
-            "config": self.config,
-            "api": self.api,
-            "db": self.db,
-            "monitor_service": None,
-            "autopay_service": None
-        })
-        
-        self.dp.message.middleware(LoggingMiddleware())
-        self.dp.callback_query.middleware(LoggingMiddleware())
-        
-        self.dp.message.middleware(ThrottlingMiddleware(rate_limit=0.5))
-        self.dp.callback_query.middleware(ThrottlingMiddleware(rate_limit=0.3))
-        
-        self.dp.message.middleware(WorkflowDataMiddleware())
-        self.dp.callback_query.middleware(WorkflowDataMiddleware())
-        
-        self.dp.message.middleware(BotMiddleware(self.bot))
-        self.dp.callback_query.middleware(BotMiddleware(self.bot))
-        
-        self.dp.message.middleware(DatabaseMiddleware(self.db))
-        self.dp.callback_query.middleware(DatabaseMiddleware(self.db))
-        
-        self.dp.message.middleware(UserMiddleware(self.db, self.config))
-        self.dp.callback_query.middleware(UserMiddleware(self.db, self.config))
-        
-        self.dp.include_router(router)
-        self.dp.include_router(admin_router)
-        self.dp.include_router(lucky_game_router)
-        self.dp.include_router(stars_router)
-        
-    async def _init_monitor_service(self):
-        try:
-            logger.info("🔧 Initializing subscription monitor service...")
-        
-            if not self.bot:
-                logger.error("❌ Bot instance is None, cannot initialize monitor")
-                return
-            
-            if not self.db:
-                logger.error("❌ Database instance is None, cannot initialize monitor")
-                return
-            
-            if not self.config:
-                logger.error("❌ Config instance is None, cannot initialize monitor")
-                return
-        
-            self.monitor_service = await create_subscription_monitor(
-                self.bot, self.db, self.config, self.api
-            )
-        
-            if not self.monitor_service:
-                logger.error("❌ Failed to create monitor service instance")
-                return
-        
-            self.dp.workflow_data["monitor_service"] = self.monitor_service
-            logger.info("✅ Monitor service added to workflow_data")
-        
-            logger.info("🚀 Starting monitor service...")
-            await self.monitor_service.start()
-        
-            status = await self.monitor_service.get_service_status()
-            if status['is_running']:
-                logger.info("✅ Subscription monitor service started successfully")
-                logger.info(f"📊 Monitor status: interval={status['check_interval']}s, daily_hour={status['daily_check_hour']}, warning_days={status['warning_days']}")
-            else:
-                logger.warning("⚠️ Monitor service created but not running")
-                logger.warning(f"📊 Monitor status: {status}")
-        
-        except Exception as e:
-            logger.error(f"❌ Failed to initialize monitor service: {e}", exc_info=True)
-            logger.warning("⚠️ Continuing without monitor service")
-            self.monitor_service = None
-            
-    async def start(self):
-        logger.info("Bot polling started successfully")
-        
-        if self.config.BOT_USERNAME:
-            logger.info(f"🎁 Реферальная система активна! Ссылки: https://t.me/{self.config.BOT_USERNAME}?start=ref_USERID")
-        else:
-            logger.warning("⚠️  Реферальная система неактивна! Установите BOT_USERNAME")
-        
-        try:
-            await self.dp.start_polling(self.bot)
-        except Exception as e:
-            logger.error(f"Error during polling: {e}")
-            raise
-        finally:
-            await self.shutdown()
-            
-    async def shutdown(self):
-        logger.info("Shutting down bot...")
-
-        if self.webhook_server:
-            try:
-                await self.webhook_server.stop()
-                logger.info("Webhook server stopped")
-            except Exception as e:
-                logger.error(f"Error stopping webhook server: {e}")
-
-        if self.autopay_service: 
-            try:
-                await self.autopay_service.stop()
-                logger.info("Autopay service stopped")
-            except Exception as e:
-                logger.error(f"Error stopping autopay service: {e}")
-        
-        if self.monitor_service:
-            try:
-                await self.monitor_service.stop()
-                logger.info("Monitor service stopped")
-            except Exception as e:
-                logger.error(f"Error stopping monitor service: {e}")
-        
-        if self.api:
-            try:
-                await self.api.close()
-                logger.info("API connection closed")
-            except Exception as e:
-                logger.error(f"Error closing API: {e}")
-        
-        if self.db:
-            try:
-                await self.db.close()
-                logger.info("Database connection closed")
-            except Exception as e:
-                logger.error(f"Error closing database: {e}")
-        
-        if self.bot:
-            try:
-                await self.bot.session.close()
-                logger.info("Bot session closed")
-            except Exception as e:
-                logger.error(f"Error closing bot session: {e}")
-        
-        logger.info("Bot shutdown complete")
 
 async def main():
-    app = None
+    logging.basicConfig(
+        level=getattr(logging, settings.LOG_LEVEL),
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler(settings.LOG_FILE, encoding='utf-8'),
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    
+    logger = logging.getLogger(__name__)
+    logger.info("🚀 Запуск VPN бота...")
+    
+    webhook_server = None
+    
     try:
-        app = BotApplication()
-        await app.initialize()
-        await app.start()
+        logger.info("📊 Инициализация базы данных...")
+        await init_db()
+        
+        logger.info("🤖 Настройка бота...")
+        bot, dp = await setup_bot()
+        
+        monitoring_service.bot = bot
+        
+        # Инициализируем webhook сервер если Tribute включен
+        if settings.TRIBUTE_ENABLED:
+            logger.info("🌐 Запуск webhook сервера для Tribute...")
+            webhook_server = WebhookServer(bot)
+            await webhook_server.start()
+        else:
+            logger.info("ℹ️ Tribute отключен, webhook сервер не запускается")
+        
+        logger.info("🔍 Запуск службы мониторинга...")
+        monitoring_task = asyncio.create_task(monitoring_service.start_monitoring())
+        
+        logger.info("🔄 Запуск polling...")
+        
+        try:
+            await asyncio.gather(
+                dp.start_polling(bot),
+                monitoring_task
+            )
+        except Exception as e:
+            logger.error(f"Ошибка в основном цикле: {e}")
+            monitoring_service.stop_monitoring()
+            if webhook_server:
+                await webhook_server.stop()
+            raise
         
-    except KeyboardInterrupt:
-        logger.info("Bot stopped by user (Ctrl+C)")
     except Exception as e:
-        logger.error(f"Critical error in main: {e}")
-        import traceback
-        traceback.print_exc()
+        logger.error(f"❌ Критическая ошибка при запуске: {e}")
         raise
     finally:
-        if app:
-            await app.shutdown()
+        logger.info("🛑 Завершение работы бота")
+        monitoring_service.stop_monitoring()
+        if webhook_server:
+            await webhook_server.stop()
+
 
 if __name__ == "__main__":
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        logger.info("Bot stopped by user")
+        print("\n🛑 Бот остановлен пользователем")
     except Exception as e:
-        logger.error(f"Fatal error: {e}")
-        sys.exit(1)
+        print(f"❌ Критическая ошибка: {e}")
+        sys.exit(1)

middlewares.py

@@ -1,184 +0,0 @@
-from aiogram import BaseMiddleware
-from aiogram.types import TelegramObject, User as TgUser, Message, CallbackQuery
-from typing import Callable, Dict, Any, Awaitable
-import logging
-from database import Database, User
-from config import Config
-
-logger = logging.getLogger(__name__)
-
-class DatabaseMiddleware(BaseMiddleware):
-    
-    def __init__(self, db: Database):
-        self.db = db
-    
-    async def __call__(
-        self,
-        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
-        event: TelegramObject,
-        data: Dict[str, Any]
-    ) -> Any:
-        data['db'] = self.db
-        return await handler(event, data)
-
-class UserMiddleware(BaseMiddleware):
-    
-    def __init__(self, db: Database, config: Config):
-        self.db = db
-        self.config = config
-    
-    async def __call__(
-        self,
-        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
-        event: TelegramObject,
-        data: Dict[str, Any]
-    ) -> Any:
-        telegram_user: TgUser = data.get('event_from_user')
-        
-        if telegram_user and not telegram_user.is_bot:
-            try:
-                user = await self.db.get_user_by_telegram_id(telegram_user.id)
-                
-                if not user:
-                    is_admin = telegram_user.id in self.config.ADMIN_IDS
-                    
-                    user = await self.db.create_user(
-                        telegram_id=telegram_user.id,
-                        username=telegram_user.username,
-                        first_name=telegram_user.first_name,
-                        last_name=telegram_user.last_name,
-                        language='',
-                        is_admin=is_admin
-                    )
-                    logger.info(f"Created new user: {telegram_user.id} without language")
-                else:
-                    updated = False
-                    if user.username != telegram_user.username:
-                        user.username = telegram_user.username
-                        updated = True
-                    if user.first_name != telegram_user.first_name:
-                        user.first_name = telegram_user.first_name
-                        updated = True
-                    if user.last_name != telegram_user.last_name:
-                        user.last_name = telegram_user.last_name
-                        updated = True
-                    
-                    should_be_admin = telegram_user.id in self.config.ADMIN_IDS
-                    if user.is_admin != should_be_admin:
-                        user.is_admin = should_be_admin
-                        updated = True
-                    
-                    if updated:
-                        await self.db.update_user(user)
-                
-                data['user'] = user
-                data['lang'] = user.language if user.language and user.language != '' else self.config.DEFAULT_LANGUAGE
-                
-            except Exception as e:
-                logger.error(f"Error in UserMiddleware: {e}")
-                class FallbackUser:
-                    def __init__(self, telegram_id: int, username: str = None, config: Config = None):
-                        self.telegram_id = telegram_id
-                        self.username = username
-                        self.first_name = None
-                        self.last_name = None
-                        self.language = config.DEFAULT_LANGUAGE if config else 'ru'
-                        self.balance = 0.0
-                        self.is_admin = telegram_id in (config.ADMIN_IDS if config else [])
-                        self.remnawave_uuid = None
-                
-                try:
-                    fallback_user = FallbackUser(telegram_user.id, telegram_user.username, self.config)
-                    data['user'] = fallback_user
-                    data['lang'] = self.config.DEFAULT_LANGUAGE
-                except:
-                    data['user'] = None
-                    data['lang'] = self.config.DEFAULT_LANGUAGE
-        else:
-            data['user'] = None
-            data['lang'] = self.config.DEFAULT_LANGUAGE
-        
-        return await handler(event, data)
-
-class LoggingMiddleware(BaseMiddleware):
-    
-    async def __call__(
-        self,
-        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
-        event: TelegramObject,
-        data: Dict[str, Any]
-    ) -> Any:
-        telegram_user: TgUser = data.get('event_from_user')
-        
-        if isinstance(event, Message):
-            username = f"@{telegram_user.username}" if telegram_user and telegram_user.username else "no_username"
-            user_id = telegram_user.id if telegram_user else "unknown"
-            text = event.text or "no_text"
-            logger.info(f"Message from {user_id} ({username}): {text}")
-        elif isinstance(event, CallbackQuery):
-            username = f"@{telegram_user.username}" if telegram_user and telegram_user.username else "no_username"
-            user_id = telegram_user.id if telegram_user else "unknown"
-            callback_data = event.data or "no_data"
-            logger.info(f"Callback from {user_id} ({username}): {callback_data}")
-        
-        return await handler(event, data)
-
-class ThrottlingMiddleware(BaseMiddleware):
-    
-    def __init__(self, rate_limit: float = 1.0):
-        self.rate_limit = rate_limit
-        self.user_last_action = {}
-    
-    async def __call__(
-        self,
-        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
-        event: TelegramObject,
-        data: Dict[str, Any]
-    ) -> Any:
-        telegram_user: TgUser = data.get('event_from_user')
-        
-        if telegram_user:
-            import time
-            current_time = time.time()
-            user_id = telegram_user.id
-            
-            if user_id in self.user_last_action:
-                if current_time - self.user_last_action[user_id] < self.rate_limit:
-                    logger.warning(f"Throttling user {user_id}")
-                    return
-            
-            self.user_last_action[user_id] = current_time
-        
-        return await handler(event, data)
-
-class WorkflowDataMiddleware(BaseMiddleware):
-    
-    async def __call__(
-        self,
-        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
-        event: TelegramObject,
-        data: Dict[str, Any]
-    ) -> Any:
-        if hasattr(event, 'bot'):
-            dp = getattr(event.bot, '_dispatcher', None)
-            if dp and hasattr(dp, 'workflow_data'):
-                workflow_data = dp.workflow_data
-                for key, value in workflow_data.items():
-                    if key not in data: 
-                        data[key] = value
-        
-        return await handler(event, data)
-
-class BotMiddleware(BaseMiddleware):
-    
-    def __init__(self, bot):
-        self.bot = bot
-    
-    async def __call__(
-        self,
-        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
-        event: TelegramObject,
-        data: Dict[str, Any]
-    ) -> Any:
-        data['bot'] = self.bot
-        return await handler(event, data)

migrations/alembic/alembic.ini

@@ -0,0 +1,41 @@
+[alembic]
+script_location = migrations/alembic
+prepend_sys_path = .
+version_path_separator = os
+sqlalchemy.url = postgresql+asyncpg://vpn_user:your_password@localhost:5432/vpn_bot
+
+[post_write_hooks]
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

migrations/alembic/env.py

@@ -0,0 +1,67 @@
+import asyncio
+import sys
+from pathlib import Path
+from logging.config import fileConfig
+
+from sqlalchemy import pool
+from sqlalchemy.engine import Connection
+from sqlalchemy.ext.asyncio import async_engine_from_config
+
+from alembic import context
+
+sys.path.append(str(Path(__file__).parent.parent.parent))
+
+from app.database.models import Base
+from app.config import settings
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = Base.metadata
+
+config.set_main_option("sqlalchemy.url", settings.DATABASE_URL)
+
+
+def run_migrations_offline() -> None:
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def do_run_migrations(connection: Connection) -> None:
+    context.configure(connection=connection, target_metadata=target_metadata)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+async def run_async_migrations() -> None:
+    connectable = async_engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations)
+
+    await connectable.dispose()
+
+
+def run_migrations_online() -> None:
+    asyncio.run(run_async_migrations())
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

referral_utils.py

@@ -1,279 +0,0 @@
-import logging
-from datetime import datetime
-from database import Database
-from database import ReferralProgram, ReferralEarning
-
-logger = logging.getLogger(__name__)
-
-async def process_referral_rewards(user_id: int, amount: float, payment_id: int, db: Database, bot=None, payment_type: str = None):
-    try:
-        import os
-        
-        if payment_type not in ['topup', 'admin_topup']:
-            logger.debug(f"Skipping referral rewards for payment type: {payment_type}")
-            return
-        
-        if amount <= 0:
-            logger.debug(f"Skipping referral rewards for non-positive amount: {amount}")
-            return
-        
-        threshold = float(os.getenv('REFERRAL_THRESHOLD', '300.0'))
-        first_reward = float(os.getenv('REFERRAL_FIRST_REWARD', '150.0'))
-        referred_bonus = float(os.getenv('REFERRAL_REFERRED_BONUS', '150.0'))
-        percentage = float(os.getenv('REFERRAL_PERCENTAGE', '0.25'))
-        
-        referral = await db.get_referral_by_referred_id(user_id)
-        
-        if not referral:
-            logger.debug(f"No referral found for user {user_id}")
-            return
-        
-        user = await db.get_user_by_telegram_id(user_id)
-        if not user:
-            logger.error(f"User {user_id} not found")
-            return
-        
-        logger.info(f"Processing referral rewards for topup: user {user_id}, amount {amount}, referrer {referral.referrer_id}")
-        
-        if not referral.first_reward_paid and user.balance >= threshold:
-            logger.info(f"Processing first reward for referral {referral.id} (threshold: {threshold}, reward: {first_reward})")
-            
-            await db.add_balance(referral.referrer_id, first_reward)
-            
-            await db.create_payment(
-                user_id=referral.referrer_id,
-                amount=first_reward,
-                payment_type='referral',
-                description=f'Первая награда за реферала ID:{user_id}',
-                status='completed'
-            )
-            
-            success = await db.create_referral_earning(
-                referrer_id=referral.referrer_id,
-                referred_id=user_id,
-                amount=first_reward,
-                earning_type='first_reward',
-                related_payment_id=payment_id
-            )
-            
-            if success:
-                logger.info(f"First reward paid: {first_reward}₽ to referrer {referral.referrer_id}")
-                
-                if bot:
-                    try:
-                        await bot.send_message(
-                            referral.referrer_id,
-                            f"🎉 Поздравляем! Ваш реферал пополнил баланс на {threshold}₽+\n\n"
-                            f"💰 Вам начислено {first_reward}₽ за приведенного друга!\n"
-                            f"Теперь вы будете получать {percentage*100:.0f}% с каждого его пополнения баланса."
-                        )
-                        
-                        await bot.send_message(
-                            user_id,
-                            f"🎁 Бонус активирован! Вам начислено {referred_bonus}₽ за переход по реферальной ссылке!"
-                        )
-                        
-                        await db.add_balance(user_id, referred_bonus)
-                        await db.create_payment(
-                            user_id=user_id,
-                            amount=referred_bonus,
-                            payment_type='referral',
-                            description='Бонус за переход по реферальной ссылке',
-                            status='completed'
-                        )
-                        
-                        logger.info(f"Referral bonus notifications sent and balance updated")
-                        
-                    except Exception as e:
-                        logger.error(f"Failed to send referral notifications: {e}")
-            else:
-                logger.error(f"Failed to create first reward earning")
-        
-        if referral.first_reward_paid:
-            percentage_reward = amount * percentage
-            
-            if percentage_reward >= 0.01: 
-                await db.add_balance(referral.referrer_id, percentage_reward)
-                
-                await db.create_payment(
-                    user_id=referral.referrer_id,
-                    amount=percentage_reward,
-                    payment_type='referral',
-                    description=f'{percentage*100:.0f}% от пополнения реферала ID:{user_id}',
-                    status='completed'
-                )
-                
-                success = await db.create_referral_earning(
-                    referrer_id=referral.referrer_id,
-                    referred_id=user_id,
-                    amount=percentage_reward,
-                    earning_type='percentage',
-                    related_payment_id=payment_id
-                )
-                
-                if success:
-                    logger.info(f"Percentage reward paid: {percentage_reward:.2f}₽ ({percentage*100:.0f}%) to referrer {referral.referrer_id}")
-                    
-                    if bot and percentage_reward >= 1.0:
-                        try:
-                            await bot.send_message(
-                                referral.referrer_id,
-                                f"💰 Реферальный доход!\n\n"
-                                f"Ваш реферал пополнил баланс на {amount:.2f}₽\n"
-                                f"Вам начислено: {percentage_reward:.2f}₽ ({percentage*100:.0f}%)"
-                            )
-                        except Exception as e:
-                            logger.error(f"Failed to send percentage notification: {e}")
-                else:
-                    logger.error(f"Failed to create percentage earning")
-        else:
-            logger.info(f"Skipping percentage reward for user {user_id} - first reward not yet paid")
-    
-    except Exception as e:
-        logger.error(f"Error processing referral rewards: {e}")
-
-async def create_referral_from_start_param(user_telegram_id: int, start_param: str, db: Database, bot=None):
-    try:
-        if not start_param.startswith("ref_"):
-            return False
-        
-        referrer_id = int(start_param.replace("ref_", ""))
-        
-        if referrer_id == user_telegram_id:
-            logger.warning(f"User {user_telegram_id} tried to refer themselves")
-            return False
-        
-        existing_reverse_referral = await db.get_referral_by_referred_id(referrer_id)
-        if existing_reverse_referral and existing_reverse_referral.referrer_id == user_telegram_id:
-            logger.warning(f"Mutual referral attempt blocked: {user_telegram_id} is already referrer for {referrer_id}")
-            return False
-        
-        existing_referral = await db.get_referral_by_referred_id(user_telegram_id)
-        
-        if existing_referral:
-            logger.info(f"User {user_telegram_id} already has referrer")
-            return False
-        
-        referral_code = await db.generate_unique_referral_code(referrer_id)
-        
-        referral = await db.create_referral(referrer_id, user_telegram_id, referral_code)
-        
-        if referral:
-            logger.info(f"Created referral: {referrer_id} -> {user_telegram_id} with code {referral_code}")
-            
-            if bot:
-                try:
-                    referrer = await db.get_user_by_telegram_id(referrer_id)
-                    if referrer:
-                        import os
-                        threshold = float(os.getenv('REFERRAL_THRESHOLD', '300.0'))
-                        first_reward = float(os.getenv('REFERRAL_FIRST_REWARD', '150.0'))
-                        percentage = float(os.getenv('REFERRAL_PERCENTAGE', '0.25'))
-                        
-                        await bot.send_message(
-                            referrer_id,
-                            f"🎉 Отлично! По вашей ссылке зарегистрировался новый пользователь!\n\n"
-                            f"Вы получите {first_reward:.0f}₽ после того, как он пополнит баланс на {threshold:.0f}₽.\n"
-                            f"И будете получать {percentage*100:.0f}% с каждого его пополнения баланса!"
-                        )
-                except Exception as e:
-                    logger.error(f"Failed to notify referrer: {e}")
-            
-            return True
-        
-        return False
-        
-    except (ValueError, TypeError) as e:
-        logger.warning(f"Invalid referral parameter: {start_param}")
-        return False
-    except Exception as e:
-        logger.error(f"Error creating referral from start param: {e}")
-        return False
-
-async def create_referral_from_promocode(user_telegram_id: int, referral_code: str, db: Database, bot=None):
-    try:
-        if not referral_code.startswith("REF"):
-            return False
-        
-        logger.info(f"Trying to use referral code {referral_code} for user {user_telegram_id}")
-        
-        async with db.session_factory() as session:
-            from sqlalchemy import select
-            result = await session.execute(
-                select(ReferralProgram).where(ReferralProgram.referral_code == referral_code)
-            )
-            referral_record = result.scalar_one_or_none()
-            
-            if not referral_record:
-                logger.warning(f"No referrer found for code {referral_code}")
-                return False
-            
-            referrer_id = referral_record.referrer_id
-            
-            if referrer_id == user_telegram_id:
-                logger.warning(f"User {user_telegram_id} tried to use own referral code")
-                return False
-            
-            existing_reverse_referral = await db.get_referral_by_referred_id(referrer_id)
-            if existing_reverse_referral and existing_reverse_referral.referrer_id == user_telegram_id:
-                logger.warning(f"Mutual referral attempt blocked: {user_telegram_id} is already referrer for {referrer_id}")
-                return False
-            
-            existing_referral = await db.get_referral_by_referred_id(user_telegram_id)
-            
-            if existing_referral:
-                logger.info(f"User {user_telegram_id} already has referrer")
-                return False
-            
-            referral = await db.create_referral(referrer_id, user_telegram_id, referral_code)
-            
-            if referral:
-                logger.info(f"Created referral from promocode: {referrer_id} -> {user_telegram_id}")
-                
-                if bot:
-                    try:
-                        import os
-                        threshold = float(os.getenv('REFERRAL_THRESHOLD', '300.0'))
-                        first_reward = float(os.getenv('REFERRAL_FIRST_REWARD', '150.0'))
-                        
-                        await bot.send_message(
-                            referrer_id,
-                            f"🎉 По вашему промокоду {referral_code} зарегистрировался новый пользователь!\n\n"
-                            f"Вы получите {first_reward:.0f}₽ после того, как он пополнит баланс на {threshold:.0f}₽."
-                        )
-                    except Exception as e:
-                        logger.error(f"Failed to notify referrer: {e}")
-                
-                return True
-            
-            return False
-        
-    except Exception as e:
-        logger.error(f"Error creating referral from promocode: {e}")
-        return False
-
-def generate_referral_link(bot_username: str, user_id: int) -> str:
-    if not bot_username:
-        return ""
-    
-    if bot_username.startswith('@'):
-        bot_username = bot_username[1:]
-    
-    return f"https://t.me/{bot_username}?start=ref_{user_id}"
-
-def validate_referral_code(code: str) -> bool:
-    if not code or not code.startswith("REF"):
-        return False
-    if len(code) < 4 or len(code) > 20:
-        return False
-    return True
-
-def format_referral_stats(stats: dict, lang: str = 'ru') -> str:
-    if lang == 'ru':
-        return (f"👥 Приглашено: {stats['total_referrals']}\n"
-                f"✅ Активных: {stats['active_referrals']}\n"
-                f"💰 Заработано: {stats['total_earned']:.2f}₽")
-    else:
-        return (f"👥 Invited: {stats['total_referrals']}\n"
-                f"✅ Active: {stats['active_referrals']}\n"
-                f"💰 Earned: ${stats['total_earned']:.2f}")

requirements.txt

@@ -1,38 +1,21 @@
-# Telegram Bot Framework
-aiogram>=3.4.0
+# Основные зависимости
+aiogram==3.4.1
+aiohttp==3.9.1
+asyncpg==0.29.0
+SQLAlchemy==2.0.25
+alembic==1.13.1
+aiosqlite==0.19.0
 
-# Database
-SQLAlchemy>=2.0.0
-alembic>=1.12.0
+# Дополнительные зависимости
+pydantic==2.5.3
+pydantic-settings==2.1.0
+python-dotenv==1.0.0
+redis==5.0.1
 
-# PostgreSQL driver
-asyncpg>=0.28.0
-psycopg2-binary>=2.9.0
+# Логирование и мониторинг
+structlog==23.2.0
 
-# SQLite driver (fallback)
-aiosqlite>=0.19.0
-
-# HTTP Client
-aiohttp>=3.8.0
-aiofiles>=23.0.0
-
-# Redis (optional)
-redis>=4.5.0
-aioredis>=2.0.0
-
-# Utilities
-python-dotenv>=1.0.0
-pydantic>=2.0.0
-pydantic-settings>=2.0.0
-
-# Logging and monitoring
-structlog>=23.0.0
-
-# Date and time
-python-dateutil>=2.8.0
-
-# Cryptography
-cryptography>=42.0.0
-
-# JSON handling
-orjson>=3.9.0
+# Утилиты
+python-dateutil==2.8.2
+pytz==2023.4
+cryptography>=41.0.0

screens/adminpanel/1

@@ -1 +0,0 @@
-