Update user_service.py

Bedolaganew

.env.example

@@ -1,64 +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
+
+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_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

.github/workflows/docker-hub.yml

@@ -1,31 +1,28 @@
 name: BedolagaBot
-
 on:
   push:
     branches:
       - main  
-
 jobs:
   build:
     runs-on: ubuntu-latest
-
     steps:
     - name: Checkout code
-      uses: actions/checkout@v3
-
+      uses: actions/checkout@v4
     - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v2
-
+      uses: docker/setup-buildx-action@v3
     - name: Login to Docker Hub
-      uses: docker/login-action@v2
+      uses: docker/login-action@v3
       with:
         username: ${{ secrets.DOCKER_USERNAME }}
         password: ${{ secrets.DOCKER_PASSWORD }}
-
     - name: Build and push Docker image
-      uses: docker/build-push-action@v4
+      uses: docker/build-push-action@v5
       with:
         context: .
         file: ./Dockerfile
+        platforms: linux/amd64,linux/arm64
         push: true
         tags: fr1ngg/remnawave-bedolaga-telegram-bot:latest
+        cache-from: type=gha
+        cache-to: type=gha,mode=max

.github/workflows/docker-registry.yml

@@ -0,0 +1,66 @@
+name: Build and Publish Docker Image
+on:
+  push:
+    branches:
+      - main
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - main
+      - master
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: fr1ngg/remnawave-bedolaga-telegram-bot
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Log in to Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=raw,value=latest,enable={{is_default_branch}}
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+      - name: Generate security report
+        uses: docker/scout-action@v1
+        if: github.event_name == 'pull_request'
+        with:
+          command: quickview,compare
+          image: ${{ steps.meta.outputs.tags }}
+          to: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          ignore-unchanged: true
+          only-severities: critical,high
+          write-comment: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}

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"]

Makefile

@@ -1,96 +0,0 @@
-# RemnaWave Bot Docker Management
-
-.PHONY: help build up down restart logs clean db-backup db-restore
-
-# Default target
-help:
-	@echo "Available commands:"
-	@echo "  build     - Build all Docker images"
-	@echo "  up        - Start all services"
-	@echo "  up-min    - Start only bot and database (minimal setup)"
-	@echo "  up-full   - Start all services including nginx and redis"
-	@echo "  down      - Stop all services"
-	@echo "  restart   - Restart all services"
-	@echo "  logs      - Show logs for all services"
-	@echo "  logs-bot  - Show logs for bot service only"
-	@echo "  logs-db   - Show logs for database service only"
-	@echo "  clean     - Remove all containers, networks, and volumes"
-	@echo "  db-backup - Create database backup"
-	@echo "  db-restore - Restore database from backup"
-	@echo "  shell-bot - Open shell in bot container"
-	@echo "  shell-db  - Open shell in database container"
-
-# Build all images
-build:
-	docker compose build
-
-# Start minimal services (bot + database)
-up-min: setup-dirs
-	docker compose up -d postgres bot
-
-# Start all services including optional ones
-up-full: setup-dirs
-	docker compose --profile with-nginx up -d
-
-# Start main services (default)
-up: setup-dirs
-	docker compose up -d postgres redis bot
-
-# Setup required directories
-setup-dirs:
-	mkdir -p logs data backups
-
-# Stop all services
-down:
-	docker compose down
-
-# Restart all services
-restart:
-	docker compose restart
-
-# Show logs for all services
-logs:
-	docker compose logs -f
-
-# Show logs for bot only
-logs-bot:
-	docker compose logs -f bot
-
-# Show logs for database only  
-logs-db:
-	docker compose logs -f postgres
-
-# Clean up everything (DANGEROUS - removes all data)
-clean:
-	@echo "This will remove all containers, networks, and volumes. Are you sure? [y/N]"
-	@read answer && [ "$$answer" = "y" ] || [ "$$answer" = "Y" ]
-	docker compose down -v --remove-orphans
-	docker system prune -f
-
-# Database backup
-db-backup:
-	@mkdir -p backups
-	docker compose exec postgres pg_dump -U remnawave_user remnawave_bot > backups/backup_$(shell date +%Y%m%d_%H%M%S).sql
-	@echo "Backup created in backups/ directory"
-
-# Database restore (use: make db-restore BACKUP=backup_20231201_120000.sql)
-db-restore:
-	@if [ -z "$(BACKUP)" ]; then echo "Usage: make db-restore BACKUP=backup_file.sql"; exit 1; fi
-	docker compose exec -T postgres psql -U remnawave_user -d remnawave_bot < backups/$(BACKUP)
-	@echo "Database restored from $(BACKUP)"
-
-# Open shell in bot container
-shell-bot:
-	docker compose exec bot /bin/bash
-
-# Open shell in database container
-shell-db:
-	docker compose exec postgres psql -U remnawave_user -d remnawave_bot
-
-# Check services status
-status:
-	docker compose ps
-
-# View service resource usage
-stats:
-	docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"

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,170 +41,329 @@
 <td width="50%">
 
 ### 👤 **Для пользователей**
-- 💰 **Управление балансом** - Telegram Stars + P2P через поддержку
-- 🛒 **Покупка подписок** - различные тарифы с настройкой squad
-- 📱 **Управление подписками** - просмотр, продление, ссылки
-- 🎁 **Промокоды** - денежные бонусы
-- 👥 **Реферальная программа** - зарабатывай с друзей
-- 🎰 **Игра удачи** - ежедневные бонусы
+- 💰 **Управление балансом** - Telegram Stars + Telegram Tribute
+- 🛒 **Покупка подписки** - Гибкая конфигурация подписки
+- 📱 **Управление подписками** - просмотр, продление, ссылки, настройка автопродления. Полня конфигурация своей подписки: выбор лимита трафика, выбор стран(Работает через сквады Remnawave), выбор кол-ва устройств. Возможность платно сбросить, увеличить кол-во трафика на подписке, изменить подключенные сервера(сквады) у подписки
+- 🎁 **Промокоды** - денежные бонусы, дни подписки(На отладке) + триал подписка по коду(На отладке)
+- 👥 **Реферальная программа** - зарабатывай с друзей и их последующих покупок
 - 🆓 **Тестовая подписка** - бесплатная пробная версия
-- ♾️ **Автопродление** - настраиваемое автообновление
-- 🌐 **Мультиязычность** - русский и английский
+- 💬 **Уведомления об истечении подписки**
+- 📖 **Правила сервиса**
 
 </td>
 <td width="50%">
 
 ### ⚙️ **Для администраторов**
-- 📊 **Детальная статистика** - пользователи, платежи, подписки
+- 📊 **Детальная статистика** - пользователи, подписки
 - 👥 **Управление пользователями** - поиск, редактирование, баланс
-- 💳 **Управление платежами** - одобрение, история, Telegram Stars
 - 🎫 **Управление промокодами** - создание, статистика, массовые операции
-- 🖥 **Мониторинг системы** - состояние нод, синхронизация с Remnawave
-- 📨 **Рассылки** - уведомления пользователям
-- 🔍 **Мониторинг подписок** - автоуведомления об истечении
+- 🖥 **Мониторинг системы** - состояние нод/панели, синхронизация с Remnawave, просмотр сквадов и их создание
+- 📨 **Рассылки** - уведомления пользователям по критериям 
+- 🔍 **Мониторинг подписок** - Включение/отключение мониторинга, просмотр настроек, лога, тестирование сервиса
 - 📋 **Правила сервиса** - настройка через админ-панель
-- ♾️ **Статистика автопродления** - полный контроль
+- 💰 **Рефералы** - статистика рефералов
 
 </td>
 </tr>
 </table>
 
----
+## Структура проекта
 
-## 🚀 Быстрый старт
+После установки в `/opt/bedolaga-bot/`:
 
-### ⚡ Автоматическая установка (Ubuntu)
-
-Установите бота **одной командой** с интерактивным мастером настройки:
-
-```bash
-curl -sSL https://github.com/Fr1ngg/remnawave-bedolaga-telegram-bot/raw/main/bedolaga.sh | sudo bash
+```
+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/                      # Логи
 ```
 
-<details>
-<summary>🔧 Что делает установщик</summary>
-
-- ✅ Обновляет систему Ubuntu
-- ✅ Устанавливает Docker и зависимости  
-- ✅ Создает структуру проекта в `/opt/bedolaga-bot`
-- ✅ Интерактивная настройка всех параметров
-- ✅ Создает systemd службу (опционально)
-- ✅ Запускает удобное меню управления
-
-</details>
-
-### 🎛 Интерактивное меню управления
-
-После установки вы получаете полнофункциональное меню:
-
-<img width="500" alt="Интерфейс управления ботом" src="https://github.com/user-attachments/assets/9ab876f5-2758-4c52-93dd-6c9c654a07aa">
-
-**Доступные действия:**
-- 🚀 Запуск/остановка/перезапуск бота
-- 📺 Просмотр логов в реальном времени
-- 💾 Создание и восстановление резервных копий БД
-- ✏️ Редактирование конфигурации
-- 🩺 Диагностика и устранение проблем
-- 🔄 Автообновление бота
-
 ---
 
-## 📖 Документация
-
-### 🎯 Варианты установки
-
-<table>
-<tr>
-<th>Сценарий</th>
-<th>Описание</th>
-<th>Команда</th>
-</tr>
-<tr>
-<td>🏠 <strong>Локальная установка</strong></td>
-<td>Панель + бот на одном сервере</td>
-<td><code>./bedolaga.sh</code> → вариант 2</td>
-</tr>
-<tr>
-<td>🌐 <strong>Удаленная установка</strong></td>
-<td>Бот отдельно от панели</td>
-<td><code>./bedolaga.sh</code> → вариант 1</td>
-</tr>
-<tr>
-<td>⚡ <strong>Расширенная</strong></td>
-<td>С Redis и Nginx</td>
-<td><code>./bedolaga.sh</code> → вариант 3</td>
-</tr>
-</table>
-
-### ⚙️ Ключевые настройки
-
 <details>
-<summary>📋 Основные параметры</summary>
+<summary>⚙️ Env параметры</summary>
+
+### 3. Конфигурация
+
+Скопируйте `.env.example` в `.env` и заполните переменные согласно таблицам ниже:
+
+#### 🤖 Основные настройки бота
 
 | Переменная | Описание | Пример |
 |------------|----------|---------|
-| `BOT_TOKEN` | Токен от [@BotFather](https://t.me/BotFather) | `123456:ABC-DEF...` |
-| `BOT_USERNAME` | Username бота (без @) | `your_bot` |
-| `REMNAWAVE_URL` | URL панели Remnawave | `https://panel.com` |
-| `REMNAWAVE_TOKEN` | API токен панели | `your_api_token` |
-| `ADMIN_IDS` | ID администраторов | `123456789,987654321` |
+| `BOT_TOKEN` | Токен Telegram бота | `1234567890:AABBCCddEEffGGhhIIjjKKllMM` |
+| `ADMIN_IDS` | ID администраторов (через запятую) | `123456789,987654321` |
+| `SUPPORT_USERNAME` | Username техподдержки | `@support_bot` |
 
-</details>
-
-<details>
-<summary>🎁 Реферальная программа</summary>
-
-| Переменная | Описание | По умолчанию |
-|------------|----------|--------------|
-| `REFERRAL_FIRST_REWARD` | Награда за первого реферала | `100.0` |
-| `REFERRAL_REFERRED_BONUS` | Бонус приглашенному | `100.0` |
-| `REFERRAL_THRESHOLD` | Порог активации (руб.) | `200.0` |
-| `REFERRAL_PERCENTAGE` | % с последующих платежей | `0.2` (20%) |
-
-</details>
-
-<details>
-<summary>⭐ Telegram Stars</summary>
+#### 🗄️ База данных и кеширование
 
 | Переменная | Описание | Пример |
 |------------|----------|---------|
-| `STARS_ENABLED` | Включить оплату звездами | `true` |
-| `STARS_100_RATE` | Курс 100 звезд → рублей | `110` |
-| `STARS_250_RATE` | Курс 250 звезд → рублей | `280` |
-| `STARS_500_RATE` | Курс 500 звезд → рублей | `550` |
+| `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>
+
+1) Регистрируемся и проходим верификацию в Tribute
+2) Создаем донат ссылку, копируем вставляем в .env бота, конфигурируем остальные параметры из .env.example для работы Tribute
+3) Настраиваем обратное прокси на /tribute-webhook
+
+3.1 Пример для докера Caddy 
+
+    https://test.example.com {
+        # Tribute webhook endpoint
+        handle /tribute-webhook* {
+            reverse_proxy localhost:8081 {
+                header_up Host {host}
+                header_up X-Real-IP {remote_host}
+            }
+        }
+    
+        # Health check для webhook сервиса
+        handle /webhook-health {
+            reverse_proxy localhost:8081/health {
+                header_up Host {host}
+                header_up X-Real-IP {remote_host}
+            }
+        }
+
+3.2 Пример для докера с Nginx 
+
+     server {
+        listen 80;
+        server_name yourdomain.com;
+
+        location /tribute-webhook {
+            proxy_pass http://127.0.0.1:8081;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+        
+            proxy_connect_timeout 60s;
+            proxy_send_timeout 60s;
+            proxy_read_timeout 60s;
+        
+            client_max_body_size 10M;
+        }
+
+        location /webhook-health {
+            proxy_pass http://127.0.0.1:8081/health;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+        }
+    }
+
+3.3 Рестартим Бота, рестратим Caddy/Nginx   
+
+4) Указываем ссылку на наш хук в настройках Tribute: https://test.example.com/tribute-webhook, создаем API ключ вписываем в .env бота
+
+5) Делаем тест - если успешно, значит все настроили правильно. Не успешный тест - проверяй доступность хука, где-то ты что-то не так настроил
+   
+6) Тестируем пополнение через бота
+
 
 </details>
-### 🐳 Docker Compose примеры
+
+🐳 Docker Compose примеры
 
 <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:
@@ -219,9 +392,12 @@ 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
+    ports:
+      - "8081:8081"
     networks:
       - remnawave-network
 
@@ -229,9 +405,11 @@ volumes:
   postgres_data:
 
 networks:
-  remnawave-network:
-    name: remnawave-network
-    external: true
+  bot_network:
+    driver: bridge
+    ipam:
+      config:
+        - subnet: 172.20.0.0/16
 ```
 
 </details>
@@ -270,42 +448,85 @@ services:
     volumes:
       - ./logs:/app/logs
       - ./data:/app/data
+    ports:
+      - "8081:8081"
+    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:
     driver: bridge
+    ipam:
+      config:
+        - subnet: 172.20.0.0/16
 ```
 
 </details>
 
 ---
 
+### 🔧 Первичная настройка в боте
+
+После успешного запуска бота необходимо выполнить синхронизацию данных:
+
+#### 📡 Синхронизация серверов (обязательно)
+
+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** → мониторинг нод/панели, синхронизация
 - **📊 Статистика** → подробная аналитика
 
 ---
@@ -323,10 +544,10 @@ networks:
 
 ### ⚡ Оптимизация
 
-- **Redis** → включите для кэширования (`--profile with-redis`)
+- **Redis** → включите для кэширования
 - **PostgreSQL** → настройте для production нагрузок
-- **Nginx** → используйте как reverse proxy (`--profile with-nginx`)
-- **Мониторинг** → отслеживайте через `docker stats`
+- **Nginx** → используйте как reverse proxy 
+- **Мониторинг** → отслеживайте через `
 
 ---
 
@@ -350,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
 ```
-
 ---
 
 ## 🐛 Устранение неполадок
@@ -408,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>
@@ -437,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**
+-----------------------------------------------------------------------------
+---------------------------Версия 2.0.0+-------------------------------------
+- 🌟 Глобальное обновление 2.0 - полное обновление архитектуры, отказ от мультиподписок -> переход к единой конфигурируемой подписке
 
+  
 ### 🎯 В планах
 
 | Версия | Функция | Приоритет | Описание |
 |--------|---------|-----------|----------|
-| **v1.4.0** | ЮKassa интеграция | 🔴 High | Автоматические платежи |
-| **v1.4.0** | Веб-панель управления | 🟡 Medium | Полный веб-интерфейс |
-| **v1.4.0** | Безопасное удаление | 🟡 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, другие чаты |
 
 ### 💡 Хотите добавить функцию?
 
@@ -532,7 +721,8 @@ emergency-fix:
 
 ### 📞 Контакты
 
-- **Telegram:** [@fringg](https://t.me/fringg)
+- **Telegram:** [@fringg](https://t.me/fringg) - Писать исключительно по делу, я бы конечно был рад всем помочь настроить remnawave, ваши ноды, настроить вам бота, настроить вебхуки, но ребят я один и бота пилю тоже в соло, помощь вам занимает крайне много времени, поэтому если надумаете просить помочь что-то настроить, готовьтесь дарить мне шпагу подарком в тг)(
+  
 - **Issues:** [GitHub Issues](https://github.com/Fr1ngg/remnawave-bedolaga-telegram-bot/issues)
 - **Discussions:** [GitHub Discussions](https://github.com/Fr1ngg/remnawave-bedolaga-telegram-bot/discussions)
 
@@ -553,16 +743,45 @@ emergency-fix:
 
 <div align="center">
 
-### 🌟 Понравился проект? Поставьте звезду!
+## ⭐ История проекта
+
+<div align="center">
+
+![Stars](https://img.shields.io/github/stars/Fr1ngg/remnawave-bedolaga-telegram-bot?style=for-the-badge&logo=github&color=yellow)
+![Forks](https://img.shields.io/github/forks/Fr1ngg/remnawave-bedolaga-telegram-bot?style=for-the-badge&logo=github&color=blue)
+![Issues](https://img.shields.io/github/issues/Fr1ngg/remnawave-bedolaga-telegram-bot?style=for-the-badge&logo=github&color=red)
+![Last Commit](https://img.shields.io/github/last-commit/Fr1ngg/remnawave-bedolaga-telegram-bot?style=for-the-badge&logo=github)
 
 [![Star History Chart](https://api.star-history.com/svg?repos=Fr1ngg/remnawave-bedolaga-telegram-bot&type=Date)](https://star-history.com/#Fr1ngg/remnawave-bedolaga-telegram-bot&Date)
 
+</div>
+
+---
+
+### 💝 Донатеры
+
+Спасибо всем, кто поддерживает проект!
+
+| Донатер | Сумма |
+|---------|-------|
+| 1) Илья (@ispanec_nn) | $15 |
+| 2) @pilot_737800 | 1250 руб |
+| 3) @Legacyyy777 | 600 руб |
+| 4) @Legacyyy777 | 400 руб |
+
+---
+
+### Поддержать проект
+[![Donate](https://img.shields.io/badge/Donate-Telegram-blue?style=for-the-badge)](https://t.me/tribute/app?startapp=duUO)
+
 ---
 
 **💝 Создано с любовью для Remnawave сообщества**
 
 *Автор не является профессиональным разработчиком, но прикладывает все усилия для создания удобного бота для ваших сервисов* 💪
 
+*The English Readme is currently being written, with revisions for various payment systems and languages. If you have the opportunity, please help me with local optimization and translations. This would greatly help me in writing an open source project that is accessible to different markets/countries.*
+
 [🔝 Вернуться наверх](#-remnawave-bedolaga-bot)
 
 </div>

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,94 @@
+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}")
+    
+    from aiogram.client.default import DefaultBotProperties
+    from aiogram.enums import ParseMode
+
+    bot = Bot(
+        token=settings.BOT_TOKEN, 
+        default=DefaultBotProperties(parse_mode=ParseMode.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,551 @@
+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 remove_subscription_servers(
+    db: AsyncSession,
+    subscription_id: int,
+    server_squad_ids: List[int]
+) -> bool:
+    try:
+        from app.database.models import SubscriptionServer
+        from sqlalchemy import delete
+        
+        await db.execute(
+            delete(SubscriptionServer)
+            .where(
+                SubscriptionServer.subscription_id == subscription_id,
+                SubscriptionServer.server_squad_id.in_(server_squad_ids)
+            )
+        )
+        
+        await db.commit()
+        logger.info(f"🗑️ Удалены серверы {server_squad_ids} из подписки {subscription_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка удаления серверов из подписки: {e}")
+        await db.rollback()
+        return False
+
+
+async def get_subscription_renewal_cost(
+    db: AsyncSession,
+    subscription_id: int,
+    period_days: int
+) -> int:
+    try:
+        from app.config import PERIOD_PRICES, TRAFFIC_PRICES, settings
+        
+        base_price = PERIOD_PRICES.get(period_days, 0)
+        
+        servers_info = await get_subscription_servers(db, subscription_id)
+        servers_cost = sum(server_info['paid_price_kopeks'] for server_info in servers_info)
+        
+        subscription = await db.get(Subscription, subscription_id)
+        if not subscription:
+            return base_price
+        
+        traffic_cost = 0
+        if subscription.traffic_limit_gb > 0:
+            traffic_cost = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
+        
+        devices_cost = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+        
+        total_cost = base_price + servers_cost + traffic_cost + devices_cost
+        
+        logger.info(f"💰 Расчет продления подписки {subscription_id} на {period_days} дней:")
+        logger.info(f"   📅 Период: {base_price/100}₽")
+        logger.info(f"   🌍 Серверы: {servers_cost/100}₽")
+        logger.info(f"   📊 Трафик: {traffic_cost/100}₽")
+        logger.info(f"   📱 Устройства: {devices_cost/100}₽")
+        logger.info(f"   💎 ИТОГО: {total_cost/100}₽")
+        
+        return total_cost
+        
+    except Exception as e:
+        logger.error(f"Ошибка расчета стоимости продления: {e}")
+        from app.config import PERIOD_PRICES
+        return PERIOD_PRICES.get(period_days, 0)
+
+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,985 @@
+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> {subscription.device_limit}\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"]
+    
+    if user.status == UserStatus.ACTIVE.value:
+        status_text = "✅ Активен"
+    elif user.status == UserStatus.BLOCKED.value:
+        status_text = "🚫 Заблокирован"
+    elif user.status == UserStatus.DELETED.value:
+        status_text = "🗑️ Удален"
+    else:
+        status_text = "❓ Неизвестно"
+    
+    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, user.status, 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 confirm_user_unblock(
+    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_unblock_confirm_{user_id}",
+            f"admin_user_manage_{user_id}",
+            db_user.language
+        )
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def unblock_user(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    user_id = int(callback.data.split('_')[-1])
+    
+    user_service = UserService()
+    success = await user_service.unblock_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_user_statistics(
+    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"
+    
+    text += f"<b>Основная информация:</b>\n"
+    text += f"• Дней с регистрации: {profile['registration_days']}\n"
+    text += f"• Баланс: {settings.format_price(user.balance_kopeks)}\n"
+    text += f"• Транзакций: {profile['transactions_count']}\n"
+    text += f"• Язык: {user.language}\n\n"
+    
+    text += f"<b>Подписка:</b>\n"
+    if subscription:
+        sub_status = "✅ Активна" if subscription.is_active else "❌ Неактивна"
+        sub_type = " (триал)" if subscription.is_trial else " (платная)"
+        text += f"• Статус: {sub_status}{sub_type}\n"
+        text += f"• Трафик: {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ\n"
+        text += f"• Устройства: {subscription.device_limit}\n"
+        text += f"• Стран: {len(subscription.connected_squads)}\n"
+    else:
+        text += f"• Отсутствует\n"
+    
+    text += f"\n<b>Реферальная программа:</b>\n"
+    if user.referred_by_id:
+        text += f"• Пришел по рефералке\n"
+    else:
+        text += f"• Прямая регистрация\n"
+    text += f"• Реферальный код: <code>{user.referral_code}</code>\n"
+    
+    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 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_subscription_")
+    )
+
+    dp.callback_query.register(
+        show_user_transactions,
+        F.data.startswith("admin_user_transactions_")
+    )
+
+    dp.callback_query.register(
+        show_user_statistics,
+        F.data.startswith("admin_user_statistics_")
+    )
+
+    dp.callback_query.register(
+        block_user,
+        F.data.startswith("admin_user_block_confirm_")
+    )
+
+    dp.callback_query.register(
+        delete_user_account,
+        F.data.startswith("admin_user_delete_confirm_")
+    )
+
+    dp.callback_query.register(
+        confirm_user_block,
+        F.data.startswith("admin_user_block_")
+    )
+
+    dp.callback_query.register(
+        unblock_user,
+        F.data.startswith("admin_user_unblock_confirm_")
+    )
+
+    dp.callback_query.register(
+        confirm_user_unblock,
+        F.data.startswith("admin_user_unblock_") & ~F.data.contains("confirm")
+    )
+
+    dp.callback_query.register(
+        confirm_user_delete,
+        F.data.startswith("admin_user_delete_")
+    )
+    
+    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(
+        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,617 @@
+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.database.models import UserStatus
+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, db_user=None):
+    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 = db_user if db_user else await get_user_by_telegram_id(db, message.from_user.id)
+    
+    if user and user.status != UserStatus.DELETED.value:
+        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
+            )
+        )
+        await state.clear()
+        return
+    
+    if user and user.status == UserStatus.DELETED.value:
+        logger.info(f"🔄 Удаленный пользователь {user.telegram_id} начинает повторную регистрацию")
+        
+        try:
+            from app.services.user_service import UserService
+            from app.database.models import (
+                Subscription, Transaction, PromoCodeUse, 
+                ReferralEarning, SubscriptionServer
+            )
+            from sqlalchemy import delete
+            
+            if user.subscription:
+                await db.execute(
+                    delete(SubscriptionServer).where(
+                        SubscriptionServer.subscription_id == user.subscription.id
+                    )
+                )
+                logger.info(f"🗑️ Удалены записи SubscriptionServer")
+            
+            if user.subscription:
+                await db.delete(user.subscription)
+                logger.info(f"🗑️ Удалена подписка пользователя")
+            
+            await db.execute(
+                delete(PromoCodeUse).where(PromoCodeUse.user_id == user.id)
+            )
+            
+            await db.execute(
+                delete(ReferralEarning).where(ReferralEarning.user_id == user.id)
+            )
+            await db.execute(
+                delete(ReferralEarning).where(ReferralEarning.referral_id == user.id)
+            )
+            
+            await db.execute(
+                delete(Transaction).where(Transaction.user_id == user.id)
+            )
+            
+            user.status = UserStatus.ACTIVE.value
+            user.balance_kopeks = 0
+            user.remnawave_uuid = None
+            user.has_had_paid_subscription = False
+            user.referred_by_id = None
+            from app.utils.user_utils import generate_unique_referral_code
+            user.referral_code = await generate_unique_referral_code(db, user.telegram_id)
+            
+            await db.commit()
+            
+            logger.info(f"✅ Пользователь {user.telegram_id} подготовлен к восстановлению")
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка подготовки к восстановлению: {e}")
+            await db.rollback()
+    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 and existing_user.status == UserStatus.ACTIVE.value:
+        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
+    
+    if existing_user and existing_user.status == UserStatus.DELETED.value:
+        logger.info(f"🔄 Восстанавливаем удаленного пользователя {callback.from_user.id}")
+        
+        existing_user.username = callback.from_user.username
+        existing_user.first_name = callback.from_user.first_name
+        existing_user.last_name = callback.from_user.last_name
+        existing_user.language = language
+        existing_user.referred_by_id = referrer_id
+        existing_user.status = UserStatus.ACTIVE.value
+        existing_user.balance_kopeks = 0
+        existing_user.has_had_paid_subscription = False
+        
+        from datetime import datetime
+        existing_user.updated_at = datetime.utcnow()
+        existing_user.last_activity = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(existing_user)
+        
+        user = existing_user
+        logger.info(f"✅ Пользователь {callback.from_user.id} восстановлен")
+        
+    else:
+        logger.info(f"🆕 Создаем нового пользователя {callback.from_user.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}")
+    
+    existing_user = await get_user_by_telegram_id(db, 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
+    
+    if existing_user and existing_user.status == UserStatus.DELETED.value:
+        logger.info(f"🔄 Восстанавливаем удаленного пользователя {message.from_user.id}")
+        
+        existing_user.username = message.from_user.username
+        existing_user.first_name = message.from_user.first_name
+        existing_user.last_name = message.from_user.last_name
+        existing_user.language = language
+        existing_user.referred_by_id = referrer_id
+        existing_user.status = UserStatus.ACTIVE.value
+        existing_user.balance_kopeks = 0
+        existing_user.has_had_paid_subscription = False
+        
+        from datetime import datetime
+        existing_user.updated_at = datetime.utcnow()
+        existing_user.last_activity = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(existing_user)
+        
+        user = existing_user
+        logger.info(f"✅ Пользователь {message.from_user.id} восстановлен")
+        
+    else:
+        logger.info(f"🆕 Создаем нового пользователя {message.from_user.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,577 @@
+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, user_status: str, language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = [
+        [
+            InlineKeyboardButton(text="💰 Баланс", callback_data=f"admin_user_balance_{user_id}"),
+            InlineKeyboardButton(text="📱 Подписка", callback_data=f"admin_user_subscription_{user_id}")
+        ],
+        [
+            InlineKeyboardButton(text="📊 Статистика", callback_data=f"admin_user_statistics_{user_id}"),
+            InlineKeyboardButton(text="📋 Транзакции", callback_data=f"admin_user_transactions_{user_id}")
+        ]
+    ]
+    
+    if user_status == "active":
+        keyboard.append([
+            InlineKeyboardButton(text="🚫 Заблокировать", callback_data=f"admin_user_block_{user_id}"),
+            InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_user_delete_{user_id}")
+        ])
+    elif user_status == "blocked":
+        keyboard.append([
+            InlineKeyboardButton(text="✅ Разблокировать", callback_data=f"admin_user_unblock_{user_id}"),
+            InlineKeyboardButton(text="🗑️ Удалить", callback_data=f"admin_user_delete_{user_id}")
+        ])
+    elif user_status == "deleted":
+        keyboard.append([
+            InlineKeyboardButton(text="❌ Пользователь удален", callback_data="noop")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users_list")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+
+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,774 @@
+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 not is_trial and subscription and subscription.days_left <= 3:
+            keyboard.append([
+                InlineKeyboardButton(text="⏰ Продлить", callback_data="subscription_extend")
+            ])
+        
+        if not is_trial:
+            keyboard.append([
+                InlineKeyboardButton(text="💳 Автоплатеж", callback_data="subscription_autopay")
+            ])
+        
+        if is_trial:
+            keyboard.append([
+                InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="subscription_upgrade")
+            ])
+        else:
+            keyboard.append([
+                InlineKeyboardButton(text="⚙️ Настройки подписки", callback_data="subscription_settings")
+            ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_subscription_settings_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = [
+        [
+            InlineKeyboardButton(text="🌍 Добавить страны", callback_data="subscription_add_countries")
+        ],
+        [
+            InlineKeyboardButton(text="📈 Добавить трафик", callback_data="subscription_add_traffic")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="subscription_reset_traffic")
+        ],
+        [
+            InlineKeyboardButton(text="📱 Добавить устройства", callback_data="subscription_add_devices")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data="subscription_reset_devices")
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+        ]
+    ]
+    
+    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)
+
+def get_extend_subscription_keyboard_with_prices(language: str, prices: dict) -> InlineKeyboardMarkup:
+    from app.localization.texts import get_texts
+    texts = get_texts(language)
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text=f"📅 30 дней - {texts.format_price(prices[30])}", 
+                callback_data="extend_period_30"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=f"📅 90 дней - {texts.format_price(prices[90])}", 
+                callback_data="extend_period_90"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text=f"📅 180 дней - {texts.format_price(prices[180])}", 
+                callback_data="extend_period_180"
+            )
+        ],
+        [
+            InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+        ]
+    ])

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,143 @@
+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 app.database.models import UserStatus
+                    
+                    if db_user.status == UserStatus.BLOCKED.value:
+                        if isinstance(event, Message):
+                            await event.answer("🚫 Ваш аккаунт заблокирован администратором.")
+                        elif isinstance(event, CallbackQuery):
+                            await event.answer("🚫 Ваш аккаунт заблокирован администратором.", show_alert=True)
+                        logger.info(f"🚫 Заблокированный пользователь {user.id} попытался использовать бота")
+                        return
+                    
+                    if db_user.status == UserStatus.DELETED.value:
+                        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_start_or_registration = (
+                            (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_start_or_registration:
+                            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(
+                                    "❌ Ваш аккаунт был удален.\n"
+                                    "🔄 Для повторной регистрации выполните команду /start"
+                                )
+                            elif isinstance(event, CallbackQuery):
+                                await event.answer(
+                                    "❌ Ваш аккаунт был удален. Для повторной регистрации выполните /start",
+                                    show_alert=True
+                                )
+                            logger.info(f"❌ Удаленный пользователь {user.id} попытался использовать бота без /start")
+                            return
+                    
+                    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,319 @@
+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
+                logger.debug(f"🏷️ Сервер {server.display_name}: {server.price_kopeks/100}₽")
+            else:
+                server_prices.append(0)
+                logger.warning(f"⚠️ Сервер ID {server_id} недоступен")
+
+        devices_price = max(0, devices - 1) * settings.PRICE_PER_DEVICE
+        
+        total_price = base_price + traffic_price + total_servers_price + devices_price
+        
+        logger.info(f"💰 Расчет стоимости новой подписки:")
+        logger.info(f"   📅 Период {period_days} дней: {base_price/100}₽")
+        logger.info(f"   📊 Трафик {traffic_gb} ГБ: {traffic_price/100}₽")
+        logger.info(f"   🌍 Серверы ({len(server_squad_ids)}): {total_servers_price/100}₽")
+        logger.info(f"   📱 Устройства ({devices}): {devices_price/100}₽")
+        logger.info(f"   💎 ИТОГО: {total_price/100}₽")
+        
+        return total_price, server_prices
+    
+    async def calculate_renewal_price(
+        self,
+        subscription: Subscription,
+        period_days: int,
+        db: AsyncSession
+    ) -> int:
+        try:
+            from app.config import PERIOD_PRICES, TRAFFIC_PRICES
+            
+            base_price = PERIOD_PRICES.get(period_days, 0)
+            
+            servers_price, _ = await self.get_countries_price_by_uuids(
+                subscription.connected_squads, db
+            )
+            
+            devices_price = max(0, subscription.device_limit - 1) * settings.PRICE_PER_DEVICE
+            
+            traffic_price = TRAFFIC_PRICES.get(subscription.traffic_limit_gb, 0)
+            
+            total_price = base_price + servers_price + devices_price + traffic_price
+            
+            logger.info(f"💰 Расчет стоимости продления для подписки {subscription.id} (по текущим ценам):")
+            logger.info(f"   📅 Период {period_days} дней: {base_price/100}₽")
+            logger.info(f"   🌍 Серверы ({len(subscription.connected_squads)}) по текущим ценам: {servers_price/100}₽")
+            logger.info(f"   📱 Устройства ({subscription.device_limit}): {devices_price/100}₽")
+            logger.info(f"   📊 Трафик ({subscription.traffic_limit_gb} ГБ): {traffic_price/100}₽")
+            logger.info(f"   💎 ИТОГО: {total_price/100}₽")
+            
+            return total_price
+            
+        except Exception as e:
+            logger.error(f"Ошибка расчета стоимости продления: {e}")
+            from app.config import PERIOD_PRICES
+            return PERIOD_PRICES.get(period_days, 0)
+    
+    async def get_countries_price_by_uuids(
+        self, 
+        country_uuids: List[str], 
+        db: AsyncSession
+    ) -> Tuple[int, List[int]]:
+        try:
+            from app.database.crud.server_squad import get_server_squad_by_uuid
+            
+            total_price = 0
+            prices_list = []
+            
+            for country_uuid in country_uuids:
+                server = await get_server_squad_by_uuid(db, country_uuid)
+                if server and server.is_available and not server.is_full:
+                    price = server.price_kopeks
+                    total_price += price
+                    prices_list.append(price)
+                    logger.debug(f"🏷️ Страна {server.display_name}: {price/100}₽")
+                else:
+                    default_price = 1000  
+                    total_price += default_price
+                    prices_list.append(default_price)
+                    logger.warning(f"⚠️ Сервер {country_uuid} недоступен, используем базовую цену: {default_price/100}₽")
+            
+            logger.info(f"💰 Общая стоимость стран: {total_price/100}₽")
+            return total_price, prices_list
+            
+        except Exception as e:
+            logger.error(f"Ошибка получения цен стран: {e}")
+            default_prices = [1000] * len(country_uuids)
+            return sum(default_prices), default_prices
+    
+    async def _get_countries_price(self, country_uuids: List[str], db: AsyncSession) -> int:
+        try:
+            total_price, _ = await self.get_countries_price_by_uuids(country_uuids, db)
+            return total_price
+        except Exception as e:
+            logger.error(f"Ошибка получения цен стран: {e}")
+            return len(country_uuids) * 1000
+    
+    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,454 @@
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict, Any
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import delete
+
+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, Subscription, Transaction, PromoCodeUse, 
+    ReferralEarning, SubscriptionServer
+)
+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
+            
+            if user.remnawave_uuid:
+                try:
+                    from app.services.subscription_service import SubscriptionService
+                    subscription_service = SubscriptionService()
+                    await subscription_service.disable_remnawave_user(user.remnawave_uuid)
+                    logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} деактивирован при блокировке")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка деактивации RemnaWave пользователя при блокировке: {e}")
+            
+            if user.subscription:
+                from app.database.crud.subscription import deactivate_subscription
+                await deactivate_subscription(db, user.subscription)
+            
+            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)
+            
+            if user.subscription:
+                from datetime import datetime
+                from app.database.models import SubscriptionStatus
+                
+                if user.subscription.end_date > datetime.utcnow():
+                    user.subscription.status = SubscriptionStatus.ACTIVE.value
+                    await db.commit()
+                    await db.refresh(user.subscription)
+                    logger.info(f"🔄 Подписка пользователя {user_id} восстановлена")
+                    
+                    if user.remnawave_uuid:
+                        try:
+                            from app.services.subscription_service import SubscriptionService
+                            subscription_service = SubscriptionService()
+                            await subscription_service.update_remnawave_user(db, user.subscription)
+                            logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} восстановлен при разблокировке")
+                        except Exception as e:
+                            logger.error(f"❌ Ошибка восстановления RemnaWave пользователя при разблокировке: {e}")
+                else:
+                    logger.info(f"⏰ Подписка пользователя {user_id} истекла, восстановление невозможно")
+            
+            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:
+                logger.warning(f"Пользователь {user_id} не найден для удаления")
+                return False
+            
+            logger.info(f"🗑️ Начинаем полное удаление пользователя {user_id} (Telegram ID: {user.telegram_id})")
+            
+            if user.remnawave_uuid:
+                try:
+                    from app.services.subscription_service import SubscriptionService
+                    subscription_service = SubscriptionService()
+                    await subscription_service.disable_remnawave_user(user.remnawave_uuid)
+                    logger.info(f"✅ RemnaWave пользователь {user.remnawave_uuid} деактивирован")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка деактивации RemnaWave пользователя: {e}")
+            
+            if user.subscription:
+                try:
+                    await db.execute(
+                        delete(SubscriptionServer).where(
+                            SubscriptionServer.subscription_id == user.subscription.id
+                        )
+                    )
+                    logger.info(f"🗑️ Удалены записи SubscriptionServer для подписки {user.subscription.id}")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка удаления SubscriptionServer: {e}")
+            
+            if user.subscription:
+                try:
+                    await db.delete(user.subscription)
+                    logger.info(f"🗑️ Удалена подписка пользователя {user_id}")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка удаления подписки: {e}")
+            
+            try:
+                await db.execute(
+                    delete(PromoCodeUse).where(PromoCodeUse.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены использования промокодов пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления использований промокодов: {e}")
+            
+            try:
+                await db.execute(
+                    delete(ReferralEarning).where(ReferralEarning.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены реферальные доходы пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления реферальных доходов: {e}")
+            
+            try:
+                await db.execute(
+                    delete(ReferralEarning).where(ReferralEarning.referral_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены реферальные записи о пользователе {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления реферальных записей: {e}")
+            
+            try:
+                from sqlalchemy import update
+                await db.execute(
+                    update(User)
+                    .where(User.referred_by_id == user.id)
+                    .values(referred_by_id=None)
+                )
+                logger.info(f"🗑️ Очищены реферальные ссылки у рефералов пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка очистки реферальных ссылок: {e}")
+            
+            try:
+                await db.execute(
+                    delete(Transaction).where(Transaction.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены транзакции пользователя {user_id}")
+            except Exception as e:
+                logger.error(f"❌ Ошибка удаления транзакций: {e}")
+            
+            try:
+                user.status = UserStatus.DELETED.value
+                user.balance_kopeks = 0
+                user.remnawave_uuid = None
+                user.updated_at = datetime.utcnow()
+                
+                await db.commit()
+                logger.info(f"✅ Пользователь {user_id} помечен как удаленный и обнулен")
+            except Exception as e:
+                logger.error(f"❌ Ошибка обновления статуса пользователя: {e}")
+                await db.rollback()
+                return False
+            
+            logger.info(f"✅ Пользователь {user_id} (Telegram ID: {user.telegram_id}) полностью удален админом {admin_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Критическая ошибка удаления пользователя {user_id}: {e}")
+            await db.rollback()
+            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 self.delete_user_account(db, user.id, 0) 
+                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.referred_by_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,  # 30 минут
-            'has_api': self.api is not None,
-            'has_bot': self.bot is not None
-        }

config.py

@@ -1,145 +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 
-
-    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()
-    )
-
-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}")

docker-compose.yml

@@ -1,102 +0,0 @@
-
-services:
-  # PostgreSQL Database
-  postgres:
-    image: postgres:15-alpine
-    container_name: remnawave_bot_db
-    restart: unless-stopped
-    environment:
-      POSTGRES_DB: remnawave_bot
-      POSTGRES_USER: remnawave_user
-      POSTGRES_PASSWORD: secure_password_123
-      POSTGRES_INITDB_ARGS: "--encoding=UTF-8 --lc-collate=C --lc-ctype=C"
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-      - ./init-db.sql:/docker-entrypoint-initdb.d/init-db.sql:ro
-    ports:
-      - "5432:5432"
-    networks:
-      - bot_network
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U remnawave_user -d remnawave_bot"]
-      interval: 15s
-      timeout: 10s
-      retries: 5
-      start_period: 30s
-
-  # RemnaWave Bot
-  bot:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: remnawave_bot
-    restart: unless-stopped
-    depends_on:
-      postgres:
-        condition: service_healthy
-    env_file:
-      - .env
-    environment:
-      # Override database URL to use PostgreSQL container
-      DATABASE_URL: postgresql+asyncpg://remnawave_user:secure_password_123@postgres:5432/remnawave_bot
-    volumes:
-      - ./logs:/app/logs
-      - ./data:/app/data
-    networks:
-      - bot_network
-    healthcheck:
-      test: ["CMD-SHELL", "python -c 'print(\"Bot is running\")'"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 30s
-
-  # Redis (optional, for caching and session storage)
-  redis:
-    image: redis:7-alpine
-    container_name: remnawave_bot_redis
-    restart: unless-stopped
-    command: redis-server --appendonly yes --requirepass redis_password_123
-    volumes:
-      - redis_data:/data
-    ports:
-      - "6379:6379"
-    networks:
-      - bot_network
-    healthcheck:
-      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
-      interval: 10s
-      timeout: 3s
-      retries: 5
-
-  # Nginx (optional, for serving static files or reverse proxy)
-  nginx:
-    image: nginx:alpine
-    container_name: remnawave_bot_nginx
-    restart: unless-stopped
-    ports:
-      - "80:80"
-      - "443:443"
-    volumes:
-      - ./nginx.conf:/etc/nginx/nginx.conf:ro
-      - ./ssl:/etc/nginx/ssl:ro
-      - ./static:/usr/share/nginx/html:ro
-    networks:
-      - bot_network
-    depends_on:
-      - bot
-    profiles:
-      - with-nginx
-
-volumes:
-  postgres_data:
-    driver: local
-  redis_data:
-    driver: local
-
-networks:
-  bot_network:
-    driver: bridge
-    ipam:
-      config:
-        - subnet: 172.20.0.0/16

emergency_fix.py

@@ -1,100 +0,0 @@
-"""
-Экстренное исправление проблемы с отображением подписок
-Этот патч добавляет недостающие поля в таблицу user_subscriptions
-"""
-
-import asyncio
-import sys
-import os
-from pathlib import Path
-
-# Добавляем корневую директорию в путь
-sys.path.insert(0, str(Path(__file__).parent))
-
-from config import load_config
-from database import Database
-from sqlalchemy import text
-import logging
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-async def check_and_add_column(db, column_name, column_definition):
-    """Проверяет и добавляет колонку в таблицу"""
-    try:
-        # Отдельная транзакция для проверки
-        async with db.engine.begin() as conn:
-            await conn.execute(text(f"SELECT {column_name} FROM user_subscriptions LIMIT 1"))
-            logger.info(f"✅ Поле {column_name} уже существует")
-            return True
-    except Exception:
-        # Отдельная транзакция для добавления колонки
-        try:
-            async with db.engine.begin() as conn:
-                logger.info(f"➕ Добавляю поле {column_name}...")
-                await conn.execute(text(f"""
-                    ALTER TABLE user_subscriptions 
-                    ADD COLUMN {column_name} {column_definition}
-                """))
-                logger.info(f"✅ Поле {column_name} добавлено")
-                return True
-        except Exception as e:
-            logger.error(f"❌ Ошибка при добавлении {column_name}: {e}")
-            return False
-
-async def emergency_fix():
-    """Экстренное исправление базы данных"""
-    
-    try:
-        # Загружаем конфигурацию
-        config = load_config()
-        
-        # Подключаемся к базе данных  
-        db = Database(config.DATABASE_URL)
-        
-        logger.info("🔧 Выполняю экстренное исправление базы данных...")
-        
-        # Проверяем существование таблицы user_subscriptions
-        try:
-            async with db.engine.begin() as conn:
-                result = await conn.execute(text("SELECT COUNT(*) FROM user_subscriptions"))
-                count = result.scalar()
-                logger.info(f"📊 Найдено {count} подписок в таблице user_subscriptions")
-        except Exception as e:
-            logger.error(f"❌ Таблица user_subscriptions не найдена: {e}")
-            await db.close()
-            return
-
-        # Добавляем поля по одному в отдельных транзакциях
-        success1 = await check_and_add_column(db, "auto_pay_enabled", "BOOLEAN DEFAULT FALSE")
-        success2 = await check_and_add_column(db, "auto_pay_days_before", "INTEGER DEFAULT 3")
-        
-        # Финальная проверка в отдельной транзакции
-        if success1 and success2:
-            try:
-                async with db.engine.begin() as conn:
-                    result = await conn.execute(text("""
-                        SELECT id, auto_pay_enabled, auto_pay_days_before 
-                        FROM user_subscriptions LIMIT 1
-                    """))
-                    row = result.fetchone()
-                    if row:
-                        logger.info("✅ Все поля доступны для чтения")
-                        logger.info(f"🔍 Пример записи: id={row[0]}, auto_pay_enabled={row[1]}, auto_pay_days_before={row[2]}")
-                    else:
-                        logger.info("✅ Все поля доступны, но таблица пуста")
-                        
-            except Exception as e:
-                logger.error(f"❌ Поля все еще недоступны: {e}")
-        else:
-            logger.error("❌ Не удалось добавить все необходимые поля")
-                
-        await db.close()
-        logger.info("🎉 Экстренное исправление завершено!")
-        
-    except Exception as e:
-        logger.error(f"💥 Критическая ошибка: {e}")
-        raise
-
-if __name__ == "__main__":
-    asyncio.run(emergency_fix())

keyboards.py

@@ -1,930 +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 = True) -> 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 = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        # [InlineKeyboardButton(text="💳 " + t('topup_card', lang), callback_data="topup_card")],
-        [InlineKeyboardButton(text="👨‍💼 " + t('topup_support', lang), callback_data="topup_support")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="balance")]
-    ])
-    return 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 topup_keyboard(lang: str = 'ru') -> InlineKeyboardMarkup:
-    keyboard = InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="⭐ Telegram Stars", callback_data="topup_stars")],
-        [InlineKeyboardButton(text="👨‍💼 " + t('topup_support', lang), callback_data="topup_support")],
-        [InlineKeyboardButton(text="🔙 " + t('back', lang), callback_data="balance")]
-    ])
-    return keyboard
-
-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,351 +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
-
-    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_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_database(self):
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                await self.db.init_db()
-                logger.info("Database initialized successfully")
-                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
-        })
-        
-        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.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.7.0
+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 @@
-