Update README.md

Maintenance mode

.env.example

@@ -11,6 +11,17 @@ REDIS_URL=redis://localhost:6379/0
 REMNAWAVE_API_URL=
 REMNAWAVE_API_KEY=
 
+# === NEW: Traffic Selection Mode Settings ===
+# Режим выбора трафика:
+# "selectable" - пользователи выбирают пакеты трафика (по умолчанию)
+# "fixed" - фиксированный лимит трафика для всех подписок, доступно 5/10/25/50/100/250/0 (0 безлимит) гб 
+TRAFFIC_SELECTION_MODE=selectable
+
+# Фиксированный лимит трафика в ГБ (используется только в режиме "fixed")
+# 0 = безлимит
+# для "fixed" обязательно должы быть проставлены цены на пакеты 5/10/25/50/100/250/0 можно постать 0 руб - будет беслпатно
+FIXED_TRAFFIC_LIMIT_GB=0
+
 # TRIAL SUBSCRIPTION SETTINGS
 TRIAL_DURATION_DAYS=3
 TRIAL_TRAFFIC_LIMIT_GB=10
@@ -18,6 +29,12 @@ TRIAL_DEVICE_LIMIT=2
 TRIAL_SQUAD_UUID=
 DEFAULT_TRAFFIC_RESET_STRATEGY=MONTH
 
+# === УПРАВЛЕНИЕ ПЕРИОДАМИ ПОДПИСКИ ===
+# Доступные периоды подписки (через запятую)
+# Возможные значения: 14,30,60,90,180,360
+AVAILABLE_SUBSCRIPTION_PERIODS=14,30,60,90,180,360
+AVAILABLE_RENEWAL_PERIODS=30,90,180
+
 # SUBSCRIPTION PRICING (в копейках для точности)
 BASE_SUBSCRIPTION_PRICE=50000
 
@@ -43,6 +60,14 @@ REFERRAL_REGISTRATION_REWARD=5000
 REFERRED_USER_REWARD=10000
 REFERRAL_COMMISSION_PERCENT=25
 
+# Режим работы кнопки "Подключиться"
+# guide - открывает гайд подключения (режим 1)
+# miniapp_subscription - открывает ссылку подписки в мини-приложении (режим 2)
+# miniapp_custom - открывает заданную ссылку в мини-приложении (режим 3)
+CONNECT_BUTTON_MODE=miniapp_subscription
+# URL для режима miniapp_custom (обязателен при CONNECT_BUTTON_MODE=miniapp_custom)
+# MINIAPP_CUSTOM_URL=
+
 # AUTO-PAYMENT SETTINGS
 AUTOPAY_WARNING_DAYS=3,1
 
@@ -64,6 +89,61 @@ TRIBUTE_DONATE_LINK=https://t.me/tribute/app?startapp=XXXX
 TRIBUTE_WEBHOOK_PATH=/tribute-webhook
 TRIBUTE_WEBHOOK_PORT=8081
 
+# === НОВЫЕ НАСТРОЙКИ YOOKASSA ===
+# Включение/выключение YooKassa
+YOOKASSA_ENABLED=false
+
+# Основные настройки YooKassa (получить в личном кабинете)
+YOOKASSA_SHOP_ID=your_shop_id_here
+YOOKASSA_SECRET_KEY=your_secret_key_here
+
+# URL для возврата после оплаты (необязательно, по умолчанию t.me/your_bot)
+YOOKASSA_RETURN_URL=https://yourdomain.com/payment-success
+
+# Email по умолчанию для чеков (если пользователь не указал свой)
+YOOKASSA_DEFAULT_RECEIPT_EMAIL=receipts@yourdomain.com
+
+# Настройки чеков для налоговой
+YOOKASSA_VAT_CODE=1
+# Коды НДС:
+# 1 - НДС не облагается
+# 2 - НДС 0%  
+# 3 - НДС 10%
+# 4 - НДС 20%
+# 5 - НДС 10/110
+# 6 - НДС 20/120
+
+YOOKASSA_PAYMENT_MODE=full_payment
+# Способы расчета:
+# full_payment - полная оплата
+# partial_payment - частичная оплата  
+# advance - аванс
+# full_prepayment - полная предоплата
+# partial_prepayment - частичная предоплата
+# credit - передача в кредит
+# credit_payment - оплата кредита
+
+YOOKASSA_PAYMENT_SUBJECT=service
+# Предметы расчета:
+# commodity - товар
+# excise - подакцизный товар  
+# job - работа
+# service - услуга
+# gambling_bet - ставка в азартной игре
+# gambling_prize - выигрыш в азартной игре
+# lottery - лотерейный билет
+# lottery_prize - выигрыш в лотерее
+# intellectual_activity - результат интеллектуальной деятельности
+# payment - платеж
+# agent_commission - агентское вознаграждение
+# composite - составной предмет расчета
+# another - другое
+
+# Webhook для получения уведомлений от YooKassa
+YOOKASSA_WEBHOOK_PATH=/yookassa-webhook
+YOOKASSA_WEBHOOK_PORT=8082
+YOOKASSA_WEBHOOK_SECRET=ваш_секретный_ключ_для_webhook
+
 WEBHOOK_URL=https://example.com
 WEBHOOK_PATH=/webhook
 

.gitignore

@@ -1,2 +1,30 @@
-/screens
-/assets
+# Игнорируем все файлы и папки по умолчанию
+*
+
+# Исключения: разрешаем только нужные файлы
+!.env.example
+!Dockerfile
+!app-config.json
+!main.py
+!requirements.txt
+
+# Разрешаем папку app/ и все её содержимое рекурсивно
+!app/
+!app/**
+
+# Дополнительно разрешаем README и лицензию (опционально)
+!README.md
+!LICENSE
+
+# Разрешаем .gitignore чтобы он попал в репозиторий
+!.gitignore
+
+# Внутри разрешенных папок игнорируем служебные файлы
+app/__pycache__/
+app/**/__pycache__/
+app/**/*.pyc
+app/**/*.pyo
+app/**/*.pyd
+*.pyc
+*.pyo
+*.pyd

Dockerfile

@@ -1,3 +1,4 @@
+
 FROM python:3.11-slim
 
 WORKDIR /app
@@ -26,8 +27,9 @@ RUN useradd --create-home --shell /bin/bash app
 RUN chown -R app:app /app
 USER app
 
-# Expose port (if needed for webhooks)
-EXPOSE 8000
+# Expose webhook ports для платежных систем
+EXPOSE 8081
+EXPOSE 8082
 
 # Run the application
 CMD ["python", "main.py"]

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

app/bot.py

@@ -8,6 +8,9 @@ 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.middlewares.subscription_checker import SubscriptionStatusMiddleware
+from app.middlewares.maintenance import MaintenanceMiddleware  
+from app.services.maintenance_service import maintenance_service
 from app.utils.cache import cache 
 
 from app.handlers import (
@@ -19,7 +22,8 @@ from app.handlers.admin import (
     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  
+    statistics as admin_statistics, servers as admin_servers,
+    maintenance as admin_maintenance  
 )
 
 logger = logging.getLogger(__name__)
@@ -36,31 +40,39 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     
     try:
         await cache.connect()
-        logger.info("✅ Кеш инициализирован")
+        logger.info("Кеш инициализирован")
     except Exception as e:
-        logger.warning(f"⚠️ Кеш не инициализирован: {e}")
+        logger.warning(f"Кеш не инициализирован: {e}")
     
-    bot = Bot(token=settings.BOT_TOKEN, parse_mode="HTML")
+    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")
+        logger.info("Подключено к Redis для FSM storage")
     except Exception as e:
-        logger.warning(f"⚠️ Не удалось подключиться к Redis: {e}")
-        logger.info("🔄 Используется MemoryStorage для FSM")
+        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(MaintenanceMiddleware())
+    dp.callback_query.middleware(MaintenanceMiddleware())
     dp.message.middleware(ThrottlingMiddleware())
     dp.callback_query.middleware(ThrottlingMiddleware())
-
+    dp.message.middleware(SubscriptionStatusMiddleware())
+    dp.callback_query.middleware(SubscriptionStatusMiddleware())
     start.register_handlers(dp)
     menu.register_handlers(dp)
     subscription.register_handlers(dp)
@@ -68,7 +80,6 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     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)
@@ -80,9 +91,31 @@ async def setup_bot() -> tuple[Bot, Dispatcher]:
     admin_rules.register_handlers(dp)
     admin_remnawave.register_handlers(dp)
     admin_statistics.register_handlers(dp)
+    admin_maintenance.register_handlers(dp)
 
     common.register_handlers(dp)
     
-    logger.info("✅ Бот успешно настроен")
+    try:
+        await maintenance_service.start_monitoring()
+        logger.info("Мониторинг техработ запущен")
+    except Exception as e:
+        logger.error(f"Ошибка запуска мониторинга техработ: {e}")
     
-    return bot, dp
+    logger.info("Бот успешно настроен")
+    
+    return bot, dp
+
+
+async def shutdown_bot():
+    """Корректное завершение работы бота"""
+    try:
+        await maintenance_service.stop_monitoring()
+        logger.info("Мониторинг техработ остановлен")
+    except Exception as e:
+        logger.error(f"Ошибка остановки мониторинга: {e}")
+    
+    try:
+        await cache.close()
+        logger.info("Соединения с кешем закрыты")
+    except Exception as e:
+        logger.error(f"Ошибка закрытия кеша: {e}")

app/config.py

@@ -20,6 +20,8 @@ class Settings(BaseSettings):
     TRIAL_DURATION_DAYS: int = 3
     TRIAL_TRAFFIC_LIMIT_GB: int = 10
     TRIAL_DEVICE_LIMIT: int = 2
+    DEFAULT_TRAFFIC_LIMIT_GB: int = 100
+    DEFAULT_DEVICE_LIMIT: int = 1
     TRIAL_SQUAD_UUID: str
     DEFAULT_TRAFFIC_RESET_STRATEGY: str = "MONTH"
     
@@ -31,7 +33,9 @@ class Settings(BaseSettings):
     NOTIFICATION_CACHE_HOURS: int = 24  
     
     BASE_SUBSCRIPTION_PRICE: int = 50000
-    
+
+    AVAILABLE_SUBSCRIPTION_PERIODS: str = "14,30,60,90,180,360"
+    AVAILABLE_RENEWAL_PERIODS: str = "30,90,180"
     PRICE_14_DAYS: int = 50000
     PRICE_30_DAYS: int = 99000
     PRICE_60_DAYS: int = 189000
@@ -49,6 +53,9 @@ class Settings(BaseSettings):
     
     PRICE_PER_DEVICE: int = 5000
     
+    TRAFFIC_SELECTION_MODE: str = "selectable" 
+    FIXED_TRAFFIC_LIMIT_GB: int = 100 
+    
     REFERRAL_REGISTRATION_REWARD: int = 5000
     REFERRED_USER_REWARD: int = 2500
     REFERRAL_COMMISSION_PERCENT: int = 10
@@ -60,6 +67,11 @@ class Settings(BaseSettings):
     
     MONITORING_INTERVAL: int = 60
     INACTIVE_USER_DELETE_MONTHS: int = 3
+
+    MAINTENANCE_MODE: bool = False
+    MAINTENANCE_CHECK_INTERVAL: int = 30 
+    MAINTENANCE_AUTO_ENABLE: bool = True 
+    MAINTENANCE_MESSAGE: str = "🔧 Ведутся технические работы. Сервис временно недоступен. Попробуйте позже."
     
     TELEGRAM_STARS_ENABLED: bool = True
     
@@ -69,6 +81,21 @@ class Settings(BaseSettings):
     TRIBUTE_DONATE_LINK: Optional[str] = None
     TRIBUTE_WEBHOOK_PATH: str = "/tribute-webhook"
     TRIBUTE_WEBHOOK_PORT: int = 8081
+
+    YOOKASSA_ENABLED: bool = False
+    YOOKASSA_SHOP_ID: Optional[str] = None
+    YOOKASSA_SECRET_KEY: Optional[str] = None
+    YOOKASSA_RETURN_URL: Optional[str] = None
+    YOOKASSA_DEFAULT_RECEIPT_EMAIL: Optional[str] = None
+    YOOKASSA_VAT_CODE: int = 1 
+    YOOKASSA_PAYMENT_MODE: str = "full_payment" 
+    YOOKASSA_PAYMENT_SUBJECT: str = "service"
+    YOOKASSA_WEBHOOK_PATH: str = "/yookassa-webhook"
+    YOOKASSA_WEBHOOK_PORT: int = 8082
+    YOOKASSA_WEBHOOK_SECRET: Optional[str] = None
+
+    CONNECT_BUTTON_MODE: str = "guide"
+    MINIAPP_CUSTOM_URL: str = ""
     
     DEFAULT_LANGUAGE: str = "ru"
     AVAILABLE_LANGUAGES: str = "ru,en"
@@ -82,7 +109,7 @@ class Settings(BaseSettings):
     
     APP_CONFIG_PATH: str = "app-config.json"
     ENABLE_DEEP_LINKS: bool = True
-    APP_CONFIG_CACHE_TTL: int = 3600  # 1 час
+    APP_CONFIG_CACHE_TTL: int = 3600 
     
     @field_validator('LOG_FILE', mode='before')
     @classmethod
@@ -159,6 +186,77 @@ class Settings(BaseSettings):
     def get_app_config_cache_ttl(self) -> int:
         return self.APP_CONFIG_CACHE_TTL
     
+    def is_traffic_selectable(self) -> bool:
+        return self.TRAFFIC_SELECTION_MODE.lower() == "selectable"
+    
+    def is_traffic_fixed(self) -> bool:
+        return self.TRAFFIC_SELECTION_MODE.lower() == "fixed"
+    
+    def get_fixed_traffic_limit(self) -> int:
+        return self.FIXED_TRAFFIC_LIMIT_GB
+    
+    def is_yookassa_enabled(self) -> bool:
+        return (self.YOOKASSA_ENABLED and 
+                self.YOOKASSA_SHOP_ID is not None and 
+                self.YOOKASSA_SECRET_KEY is not None)
+    
+    def get_yookassa_return_url(self) -> str:
+        if self.YOOKASSA_RETURN_URL:
+            return self.YOOKASSA_RETURN_URL
+        elif self.WEBHOOK_URL:
+            return f"{self.WEBHOOK_URL}/payment-success"
+        return "https://t.me/"
+
+    def is_maintenance_mode(self) -> bool:
+        return self.MAINTENANCE_MODE
+    
+    def get_maintenance_message(self) -> str:
+        return self.MAINTENANCE_MESSAGE
+    
+    def get_maintenance_check_interval(self) -> int:
+        return self.MAINTENANCE_CHECK_INTERVAL
+    
+    def is_maintenance_auto_enable(self) -> bool:
+        return self.MAINTENANCE_AUTO_ENABLE
+
+    def get_available_subscription_periods(self) -> List[int]:
+        try:
+            periods_str = self.AVAILABLE_SUBSCRIPTION_PERIODS
+            if not periods_str.strip():
+                return [30, 90, 180] 
+            
+            periods = []
+            for period_str in periods_str.split(','):
+                period_str = period_str.strip()
+                if period_str:
+                    period = int(period_str)
+                    if period in PERIOD_PRICES:
+                        periods.append(period)
+            
+            return periods if periods else [30, 90, 180]
+            
+        except (ValueError, AttributeError):
+            return [30, 90, 180]
+    
+    def get_available_renewal_periods(self) -> List[int]:
+        try:
+            periods_str = self.AVAILABLE_RENEWAL_PERIODS
+            if not periods_str.strip():
+                return [30, 90, 180] 
+            
+            periods = []
+            for period_str in periods_str.split(','):
+                period_str = period_str.strip()
+                if period_str:
+                    period = int(period_str)
+                    if period in PERIOD_PRICES:
+                        periods.append(period)
+            
+            return periods if periods else [30, 90, 180]
+            
+        except (ValueError, AttributeError):
+            return [30, 90, 180]
+    
     model_config = {
         "env_file": ".env",
         "env_file_encoding": "utf-8"

app/database/crud/subscription.py

@@ -19,8 +19,15 @@ async def get_subscription_by_user_id(db: AsyncSession, user_id: int) -> Optiona
         select(Subscription)
         .options(selectinload(Subscription.user))
         .where(Subscription.user_id == user_id)
+        .order_by(Subscription.created_at.desc())
+        .limit(1) 
     )
-    return result.scalar_one_or_none()
+    subscription = result.scalar_one_or_none()
+    
+    if subscription:
+        subscription = await check_and_update_subscription_status(db, subscription)
+    
+    return subscription
 
 
 async def create_trial_subscription(
@@ -93,17 +100,30 @@ async def extend_subscription(
     subscription: Subscription,
     days: int
 ) -> Subscription:
+    current_time = datetime.utcnow()
     
-    subscription.extend_subscription(days)
+    logger.info(f"🔄 Продление подписки {subscription.id} на {days} дней")
+    logger.info(f"📊 Текущие параметры: статус={subscription.status}, окончание={subscription.end_date}")
+    
+    if subscription.end_date > current_time:
+        subscription.end_date = subscription.end_date + timedelta(days=days)
+        logger.info(f"📅 Подписка активна, добавляем {days} дней к текущей дате окончания")
+    else:
+        subscription.end_date = current_time + timedelta(days=days)
+        logger.info(f"📅 Подписка истекла, устанавливаем новую дату окончания")
     
     if subscription.status == SubscriptionStatus.EXPIRED.value:
         subscription.status = SubscriptionStatus.ACTIVE.value
+        logger.info(f"🔄 Статус изменён с EXPIRED на ACTIVE")
+    
+    subscription.updated_at = current_time
     
-    subscription.updated_at = datetime.utcnow()
     await db.commit()
     await db.refresh(subscription)
     
-    logger.info(f"⏰ Подписка пользователя {subscription.user_id} продлена на {days} дней")
+    logger.info(f"✅ Подписка продлена до: {subscription.end_date}")
+    logger.info(f"📊 Новые параметры: статус={subscription.status}, окончание={subscription.end_date}")
+    
     return subscription
 
 
@@ -444,6 +464,107 @@ async def get_subscription_servers(
     
     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 expire_subscription(
+    db: AsyncSession,
+    subscription: Subscription
+) -> Subscription:
+    
+    subscription.status = SubscriptionStatus.EXPIRED.value
+    subscription.updated_at = datetime.utcnow()
+    
+    await db.commit()
+    await db.refresh(subscription)
+    
+    logger.info(f"⏰ Подписка пользователя {subscription.user_id} помечена как истёкшая")
+    return subscription
+
+
+async def check_and_update_subscription_status(
+    db: AsyncSession,
+    subscription: Subscription
+) -> Subscription:
+    
+    current_time = datetime.utcnow()
+    
+    if (subscription.status == SubscriptionStatus.ACTIVE.value and 
+        subscription.end_date <= current_time):
+        
+        subscription.status = SubscriptionStatus.EXPIRED.value
+        subscription.updated_at = current_time
+        
+        await db.commit()
+        await db.refresh(subscription)
+        
+        logger.info(f"⏰ Статус подписки пользователя {subscription.user_id} изменен на 'expired'")
+    
+    return subscription
+
 async def create_subscription(
     db: AsyncSession,
     user_id: int,
@@ -482,4 +603,4 @@ async def create_subscription(
     await db.refresh(subscription)
     
     logger.info(f"✅ Создана подписка для пользователя {user_id}")
-    return subscription
+    return subscription

app/database/crud/transaction.py

@@ -275,4 +275,84 @@ async def get_revenue_by_period(
         .order_by(func.date(Transaction.created_at))
     )
     
-    return [{"date": row.date, "amount_kopeks": row.amount} for row in result]
+    return [{"date": row.date, "amount_kopeks": row.amount} for row in result]
+
+async def find_tribute_transactions_by_payment_id(
+    db: AsyncSession, 
+    payment_id: str, 
+    user_telegram_id: Optional[int] = None
+) -> List[Transaction]:
+    """Найти все Tribute транзакции по payment_id"""
+    
+    query = select(Transaction).options(selectinload(Transaction.user))
+    
+    conditions = [
+        Transaction.external_id == f"donation_{payment_id}",
+        Transaction.external_id == payment_id,
+        Transaction.external_id.like(f"%{payment_id}%")
+    ]
+    
+    query = query.where(
+        and_(
+            Transaction.payment_method == PaymentMethod.TRIBUTE.value,
+            or_(*conditions)
+        )
+    )
+    
+    if user_telegram_id:
+        from app.database.models import User
+        query = query.join(User).where(User.telegram_id == user_telegram_id)
+    
+    result = await db.execute(query.order_by(Transaction.created_at.desc()))
+    return result.scalars().all()
+
+
+async def check_tribute_payment_duplicate(
+    db: AsyncSession,
+    payment_id: str,
+    amount_kopeks: int,
+    user_telegram_id: int
+) -> Optional[Transaction]:
+    
+    transactions = await find_tribute_transactions_by_payment_id(
+        db, payment_id, user_telegram_id
+    )
+    
+    for transaction in transactions:
+        if (transaction.amount_kopeks == amount_kopeks and 
+            transaction.is_completed and
+            transaction.user.telegram_id == user_telegram_id):
+            return transaction
+    
+    return None
+
+
+async def create_unique_tribute_transaction(
+    db: AsyncSession,
+    user_id: int,
+    payment_id: str,
+    amount_kopeks: int,
+    description: str
+) -> Transaction:
+    """Создать уникальную Tribute транзакцию с защитой от дубликатов"""
+    
+    external_id = f"donation_{payment_id}"
+    
+    existing = await get_transaction_by_external_id(db, external_id, PaymentMethod.TRIBUTE)
+    
+    if existing:
+        timestamp = int(datetime.utcnow().timestamp())
+        external_id = f"donation_{payment_id}_{amount_kopeks}_{timestamp}"
+        
+        logger.info(f"Создан уникальный external_id для избежания дубликатов: {external_id}")
+    
+    return await create_transaction(
+        db=db,
+        user_id=user_id,
+        type=TransactionType.DEPOSIT,
+        amount_kopeks=amount_kopeks,
+        description=description,
+        payment_method=PaymentMethod.TRIBUTE,
+        external_id=external_id,
+        is_completed=True
+    )

app/database/crud/user.py

@@ -126,57 +126,88 @@ async def add_user_balance(
     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
+) -> bool:
+    try:
+        old_balance = user.balance_kopeks
+        user.balance_kopeks += 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} изменен: {old_balance} → {user.balance_kopeks} (изменение: +{amount_kopeks})")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка изменения баланса пользователя {user.id}: {e}")
+        await db.rollback()
+        return False
 
+async def add_user_balance_by_id(
+    db: AsyncSession,
+    telegram_id: int, 
+    amount_kopeks: int,
+    description: str = "Пополнение баланса"
+) -> bool:
+    try:
+        user = await get_user_by_telegram_id(db, telegram_id)
+        if not user:
+            logger.error(f"Пользователь с telegram_id {telegram_id} не найден")
+            return False
+        
+        return await add_user_balance(db, user, amount_kopeks, description)
+        
+    except Exception as e:
+        logger.error(f"Ошибка пополнения баланса пользователя {telegram_id}: {e}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка пополнения баланса пользователя {user_id}: {e}")
+        await db.rollback()
+        return False
 
 async def subtract_user_balance(
-    db: AsyncSession,
-    user: User,
-    amount_kopeks: int,
-    description: str = "Списание с баланса"
+    db: AsyncSession, 
+    user: User, 
+    amount_kopeks: int, 
+    description: str
 ) -> bool:
+    logger.error(f"💸 ОТЛАДКА subtract_user_balance:")
+    logger.error(f"   👤 User ID: {user.id} (TG: {user.telegram_id})")
+    logger.error(f"   💰 Баланс до списания: {user.balance_kopeks} копеек")
+    logger.error(f"   💸 Сумма к списанию: {amount_kopeks} копеек")
+    logger.error(f"   📝 Описание: {description}")
     
-    if not user.subtract_balance(amount_kopeks):
+    if user.balance_kopeks < amount_kopeks:
+        logger.error(f"   ❌ НЕДОСТАТОЧНО СРЕДСТВ!")
         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
+    try:
+        old_balance = user.balance_kopeks
+        user.balance_kopeks -= amount_kopeks
+        user.updated_at = datetime.utcnow()
+        
+        await db.commit()
+        await db.refresh(user)
+        
+        logger.error(f"   ✅ Средства списаны: {old_balance} → {user.balance_kopeks}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"   ❌ ОШИБКА СПИСАНИЯ: {e}")
+        await db.rollback()
+        return False
 
 
 async def get_users_list(
@@ -324,4 +355,4 @@ async def get_users_statistics(db: AsyncSession) -> dict:
         "new_today": new_today,
         "new_week": new_week,
         "new_month": new_month
-    }
+    }

app/database/crud/yookassa.py

@@ -0,0 +1,276 @@
+import logging
+from typing import Optional, List
+from datetime import datetime
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, and_
+from sqlalchemy.orm import selectinload
+
+from app.database.models import YooKassaPayment, User, Transaction
+
+logger = logging.getLogger(__name__)
+
+
+async def create_yookassa_payment(
+    db: AsyncSession,
+    user_id: int,
+    yookassa_payment_id: str,
+    amount_kopeks: int,
+    currency: str,
+    description: str,
+    status: str,
+    confirmation_url: Optional[str] = None,
+    metadata_json: Optional[dict] = None,
+    payment_method_type: Optional[str] = None,
+    yookassa_created_at: Optional[datetime] = None,
+    test_mode: bool = False
+) -> YooKassaPayment:
+    
+    payment = YooKassaPayment(
+        user_id=user_id,
+        yookassa_payment_id=yookassa_payment_id,
+        amount_kopeks=amount_kopeks,
+        currency=currency,
+        description=description,
+        status=status,
+        confirmation_url=confirmation_url,
+        metadata_json=metadata_json,
+        payment_method_type=payment_method_type,
+        yookassa_created_at=yookassa_created_at,
+        test_mode=test_mode
+    )
+    
+    db.add(payment)
+    await db.commit()
+    await db.refresh(payment)
+    
+    logger.info(f"Создан платеж YooKassa: {yookassa_payment_id} на {amount_kopeks/100}₽ для пользователя {user_id}")
+    return payment
+
+
+async def get_yookassa_payment_by_id(
+    db: AsyncSession,
+    yookassa_payment_id: str
+) -> Optional[YooKassaPayment]:
+    
+    result = await db.execute(
+        select(YooKassaPayment)
+        .options(selectinload(YooKassaPayment.user))
+        .where(YooKassaPayment.yookassa_payment_id == yookassa_payment_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_yookassa_payment_by_local_id(
+    db: AsyncSession,
+    local_id: int
+) -> Optional[YooKassaPayment]:
+    
+    result = await db.execute(
+        select(YooKassaPayment)
+        .options(selectinload(YooKassaPayment.user))
+        .where(YooKassaPayment.id == local_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def update_yookassa_payment_status(
+    db: AsyncSession,
+    yookassa_payment_id: str,
+    status: str,
+    is_paid: bool = False,
+    is_captured: bool = False,
+    captured_at: Optional[datetime] = None,
+    payment_method_type: Optional[str] = None
+) -> Optional[YooKassaPayment]:
+    
+    update_data = {
+        "status": status,
+        "is_paid": is_paid,
+        "is_captured": is_captured,
+        "updated_at": datetime.utcnow()
+    }
+    
+    if captured_at:
+        update_data["captured_at"] = captured_at
+    
+    if payment_method_type:
+        update_data["payment_method_type"] = payment_method_type
+    
+    await db.execute(
+        update(YooKassaPayment)
+        .where(YooKassaPayment.yookassa_payment_id == yookassa_payment_id)
+        .values(**update_data)
+    )
+    await db.commit()
+    
+    result = await db.execute(
+        select(YooKassaPayment)
+        .options(selectinload(YooKassaPayment.user))
+        .where(YooKassaPayment.yookassa_payment_id == yookassa_payment_id)
+    )
+    payment = result.scalar_one_or_none()
+    
+    if payment:
+        logger.info(f"Обновлен статус платежа YooKassa {yookassa_payment_id}: {status}, paid={is_paid}")
+    
+    return payment
+
+
+async def link_yookassa_payment_to_transaction(
+    db: AsyncSession,
+    yookassa_payment_id: str,
+    transaction_id: int
+) -> Optional[YooKassaPayment]:
+    
+    await db.execute(
+        update(YooKassaPayment)
+        .where(YooKassaPayment.yookassa_payment_id == yookassa_payment_id)
+        .values(transaction_id=transaction_id, updated_at=datetime.utcnow())
+    )
+    await db.commit()
+    
+    result = await db.execute(
+        select(YooKassaPayment)
+        .options(selectinload(YooKassaPayment.user), selectinload(YooKassaPayment.transaction))
+        .where(YooKassaPayment.yookassa_payment_id == yookassa_payment_id)
+    )
+    payment = result.scalar_one_or_none()
+    
+    if payment:
+        logger.info(f"Платеж YooKassa {yookassa_payment_id} связан с транзакцией {transaction_id}")
+    
+    return payment
+
+
+async def get_user_yookassa_payments(
+    db: AsyncSession,
+    user_id: int,
+    limit: int = 50,
+    offset: int = 0
+) -> List[YooKassaPayment]:
+    
+    result = await db.execute(
+        select(YooKassaPayment)
+        .options(selectinload(YooKassaPayment.transaction))
+        .where(YooKassaPayment.user_id == user_id)
+        .order_by(YooKassaPayment.created_at.desc())
+        .limit(limit)
+        .offset(offset)
+    )
+    return result.scalars().all()
+
+
+async def get_pending_yookassa_payments(
+    db: AsyncSession,
+    user_id: Optional[int] = None,
+    limit: int = 100
+) -> List[YooKassaPayment]:
+    
+    query = select(YooKassaPayment).options(selectinload(YooKassaPayment.user))
+    
+    conditions = [YooKassaPayment.status.in_(["pending", "waiting_for_capture"])]
+    if user_id:
+        conditions.append(YooKassaPayment.user_id == user_id)
+    
+    result = await db.execute(
+        query.where(and_(*conditions))
+        .order_by(YooKassaPayment.created_at.desc())
+        .limit(limit)
+    )
+    return result.scalars().all()
+
+
+async def get_succeeded_yookassa_payments_without_transaction(
+    db: AsyncSession,
+    limit: int = 50
+) -> List[YooKassaPayment]:
+    
+    result = await db.execute(
+        select(YooKassaPayment)
+        .options(selectinload(YooKassaPayment.user))
+        .where(
+            and_(
+                YooKassaPayment.status == "succeeded",
+                YooKassaPayment.is_paid == True,
+                YooKassaPayment.transaction_id == None
+            )
+        )
+        .order_by(YooKassaPayment.captured_at.desc())
+        .limit(limit)
+    )
+    return result.scalars().all()
+
+
+async def delete_yookassa_payment(
+    db: AsyncSession,
+    yookassa_payment_id: str
+) -> bool:
+    
+    result = await db.execute(
+        select(YooKassaPayment)
+        .where(YooKassaPayment.yookassa_payment_id == yookassa_payment_id)
+    )
+    payment = result.scalar_one_or_none()
+    
+    if payment:
+        await db.delete(payment)
+        await db.commit()
+        logger.info(f"Удален платеж YooKassa: {yookassa_payment_id}")
+        return True
+    
+    return False
+
+
+async def get_yookassa_payments_stats(
+    db: AsyncSession,
+    user_id: Optional[int] = None
+) -> dict:
+    
+    from sqlalchemy import func, case
+    
+    query = select(
+        func.count(YooKassaPayment.id).label('total_payments'),
+        func.sum(YooKassaPayment.amount_kopeks).label('total_amount_kopeks'),
+        func.sum(
+            case(
+                (YooKassaPayment.status == 'succeeded', YooKassaPayment.amount_kopeks),
+                else_=0
+            )
+        ).label('succeeded_amount_kopeks'),
+        func.count(
+            case(
+                (YooKassaPayment.status == 'succeeded', 1),
+                else_=None
+            )
+        ).label('succeeded_count'),
+        func.count(
+            case(
+                (YooKassaPayment.status == 'pending', 1),
+                else_=None
+            )
+        ).label('pending_count'),
+        func.count(
+            case(
+                (YooKassaPayment.status.in_(['canceled', 'failed']), 1),
+                else_=None
+            )
+        ).label('failed_count')
+    ).select_from(YooKassaPayment)
+    
+    if user_id:
+        query = query.where(YooKassaPayment.user_id == user_id)
+    
+    result = await db.execute(query)
+    stats = result.first()
+    
+    return {
+        'total_payments': stats.total_payments or 0,
+        'total_amount_kopeks': stats.total_amount_kopeks or 0,
+        'total_amount_rubles': (stats.total_amount_kopeks or 0) / 100,
+        'succeeded_amount_kopeks': stats.succeeded_amount_kopeks or 0,
+        'succeeded_amount_rubles': (stats.succeeded_amount_kopeks or 0) / 100,
+        'succeeded_count': stats.succeeded_count or 0,
+        'pending_count': stats.pending_count or 0,
+        'failed_count': stats.failed_count or 0,
+        'success_rate': (stats.succeeded_count / stats.total_payments * 100) if stats.total_payments > 0 else 0
+    }

app/database/models.py

@@ -31,7 +31,7 @@ class TransactionType(Enum):
     DEPOSIT = "deposit"  
     WITHDRAWAL = "withdrawal"  
     SUBSCRIPTION_PAYMENT = "subscription_payment"  
-    REFUND = "refund"  # Возврат
+    REFUND = "refund" 
     REFERRAL_REWARD = "referral_reward"  
 
 
@@ -44,8 +44,57 @@ class PromoCodeType(Enum):
 class PaymentMethod(Enum):
     TELEGRAM_STARS = "telegram_stars"
     TRIBUTE = "tribute"
+    YOOKASSA = "yookassa" 
     MANUAL = "manual"  
 
+class YooKassaPayment(Base):
+    __tablename__ = "yookassa_payments"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    yookassa_payment_id = Column(String(255), unique=True, nullable=False, index=True)
+    amount_kopeks = Column(Integer, nullable=False)
+    currency = Column(String(3), default="RUB", nullable=False)
+    description = Column(Text, nullable=True)
+    status = Column(String(50), nullable=False)  
+    is_paid = Column(Boolean, default=False)
+    is_captured = Column(Boolean, default=False)
+    confirmation_url = Column(Text, nullable=True)
+    metadata_json = Column(JSON, nullable=True)
+    transaction_id = Column(Integer, ForeignKey("transactions.id"), nullable=True)
+    payment_method_type = Column(String(50), nullable=True) 
+    refundable = Column(Boolean, default=False)
+    test_mode = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    yookassa_created_at = Column(DateTime, nullable=True) 
+    captured_at = Column(DateTime, nullable=True) 
+    user = relationship("User", backref="yookassa_payments")
+    transaction = relationship("Transaction", backref="yookassa_payment")
+    
+    @property
+    def amount_rubles(self) -> float:
+        return self.amount_kopeks / 100
+    
+    @property
+    def is_pending(self) -> bool:
+        return self.status == "pending"
+    
+    @property
+    def is_succeeded(self) -> bool:
+        return self.status == "succeeded" and self.is_paid
+    
+    @property
+    def is_failed(self) -> bool:
+        return self.status in ["canceled", "failed"]
+    
+    @property
+    def can_be_captured(self) -> bool:
+        return self.status == "waiting_for_capture"
+    
+    def __repr__(self):
+        return f"<YooKassaPayment(id={self.id}, yookassa_id={self.yookassa_payment_id}, amount={self.amount_rubles}₽, status={self.status})>"
+
 
 class User(Base):
     __tablename__ = "users"
@@ -55,31 +104,27 @@ class User(Base):
     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")
+    lifetime_used_traffic_bytes = Column(BigInteger, default=0)
+    last_remnawave_sync = Column(DateTime, nullable=True)
+    trojan_password = Column(String(255), nullable=True)
+    vless_uuid = Column(String(255), nullable=True)
+    ss_password = Column(String(255), nullable=True)
     
     @property
     def balance_rubles(self) -> float:
@@ -104,7 +149,7 @@ class Subscription(Base):
     __tablename__ = "subscriptions"
     
     id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False, unique=True)
     
     status = Column(String(20), default=SubscriptionStatus.TRIAL.value)
     is_trial = Column(Boolean, default=True)
@@ -133,21 +178,111 @@ class Subscription(Base):
     
     @property
     def is_active(self) -> bool:
+        current_time = datetime.utcnow()
         return (
             self.status == SubscriptionStatus.ACTIVE.value and 
-            self.end_date > datetime.utcnow()
+            self.end_date > current_time
         )
     
     @property
     def is_expired(self) -> bool:
+        """Проверяет, истёк ли срок подписки"""
         return self.end_date <= datetime.utcnow()
-    
+
+    @property
+    def should_be_expired(self) -> bool:
+        current_time = datetime.utcnow()
+        return (
+            self.status == SubscriptionStatus.ACTIVE.value and 
+            self.end_date <= current_time
+        )
+
+    @property
+    def actual_status(self) -> str:
+        current_time = datetime.utcnow()
+        
+        if self.status == SubscriptionStatus.EXPIRED.value:
+            return "expired"
+        
+        if self.status == SubscriptionStatus.DISABLED.value:
+            return "disabled"
+        
+        if self.status == SubscriptionStatus.ACTIVE.value:
+            if self.end_date <= current_time:
+                return "expired"
+            else:
+                return "active"
+        
+        if self.status == SubscriptionStatus.TRIAL.value:
+            if self.end_date <= current_time:
+                return "expired"
+            else:
+                return "trial"
+        
+        return self.status
+
+    @property
+    def status_display(self) -> str:
+        actual_status = self.actual_status
+        current_time = datetime.utcnow()
+        
+        if actual_status == "expired":
+            return "🔴 Истекла"
+        elif actual_status == "active":
+            if self.is_trial:
+                return "🎯 Тестовая"
+            else:
+                return "🟢 Активна"
+        elif actual_status == "disabled":
+            return "⚫ Отключена"
+        elif actual_status == "trial":
+            return "🎯 Тестовая"
+        
+        return "❓ Неизвестно"
+
+    @property
+    def status_emoji(self) -> str:
+        actual_status = self.actual_status
+        
+        if actual_status == "expired":
+            return "🔴"
+        elif actual_status == "active":
+            if self.is_trial:
+                return "🎁"
+            else:
+                return "💎"
+        elif actual_status == "disabled":
+            return "⚫"
+        elif actual_status == "trial":
+            return "🎁"
+        
+        return "❓"
+
     @property
     def days_left(self) -> int:
-        if self.is_expired:
+        current_time = datetime.utcnow()
+        if self.end_date <= current_time:
             return 0
-        delta = self.end_date - datetime.utcnow()
-        return delta.days
+        delta = self.end_date - current_time
+        return max(0, delta.days)
+
+    @property
+    def time_left_display(self) -> str:
+        current_time = datetime.utcnow()
+        if self.end_date <= current_time:
+            return "истёк"
+        
+        delta = self.end_date - current_time
+        days = delta.days
+        hours = delta.seconds // 3600
+        minutes = (delta.seconds % 3600) // 60
+        
+        if days > 0:
+            return f"{days} дн."
+        elif hours > 0:
+            return f"{hours} ч."
+        else:
+            return f"{minutes} мин."
     
     @property
     def traffic_used_percent(self) -> float:
@@ -418,4 +553,4 @@ class SubscriptionServer(Base):
     paid_price_kopeks = Column(Integer, default=0)
     
     subscription = relationship("Subscription", backref="subscription_servers")
-    server_squad = relationship("ServerSquad", backref="subscription_servers")
+    server_squad = relationship("ServerSquad", backref="subscription_servers")

app/database/universal_migration.py

@@ -0,0 +1,375 @@
+import logging
+from sqlalchemy import text, inspect
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.database.database import engine
+
+logger = logging.getLogger(__name__)
+
+async def get_database_type():
+    return engine.dialect.name
+
+async def check_table_exists(table_name: str) -> bool:
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+            
+            if db_type == 'sqlite':
+                result = await conn.execute(text(f"""
+                    SELECT name FROM sqlite_master 
+                    WHERE type='table' AND name='{table_name}'
+                """))
+                return result.fetchone() is not None
+                
+            elif db_type == 'postgresql':
+                result = await conn.execute(text("""
+                    SELECT table_name FROM information_schema.tables 
+                    WHERE table_schema = 'public' AND table_name = :table_name
+                """), {"table_name": table_name})
+                return result.fetchone() is not None
+                
+            elif db_type == 'mysql':
+                result = await conn.execute(text("""
+                    SELECT table_name FROM information_schema.tables 
+                    WHERE table_schema = DATABASE() AND table_name = :table_name
+                """), {"table_name": table_name})
+                return result.fetchone() is not None
+                
+            return False
+            
+    except Exception as e:
+        logger.error(f"Ошибка проверки существования таблицы {table_name}: {e}")
+        return False
+
+async def check_column_exists(table_name: str, column_name: str) -> bool:
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+            
+            if db_type == 'sqlite':
+                result = await conn.execute(text(f"PRAGMA table_info({table_name})"))
+                columns = result.fetchall()
+                return any(col[1] == column_name for col in columns)
+                
+            elif db_type == 'postgresql':
+                result = await conn.execute(text("""
+                    SELECT column_name 
+                    FROM information_schema.columns 
+                    WHERE table_name = :table_name 
+                    AND column_name = :column_name
+                """), {"table_name": table_name, "column_name": column_name})
+                return result.fetchone() is not None
+                
+            elif db_type == 'mysql':
+                result = await conn.execute(text("""
+                    SELECT COLUMN_NAME 
+                    FROM information_schema.COLUMNS 
+                    WHERE TABLE_NAME = :table_name 
+                    AND COLUMN_NAME = :column_name
+                """), {"table_name": table_name, "column_name": column_name})
+                return result.fetchone() is not None
+                
+            return False
+            
+    except Exception as e:
+        logger.error(f"Ошибка проверки существования колонки {column_name}: {e}")
+        return False
+
+async def create_yookassa_payments_table():
+    
+    table_exists = await check_table_exists('yookassa_payments')
+    if table_exists:
+        logger.info("Таблица yookassa_payments уже существует")
+        return True
+    
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+            
+            if db_type == 'sqlite':
+                create_sql = """
+                CREATE TABLE yookassa_payments (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id INTEGER NOT NULL,
+                    yookassa_payment_id VARCHAR(255) UNIQUE NOT NULL,
+                    amount_kopeks INTEGER NOT NULL,
+                    currency VARCHAR(3) DEFAULT 'RUB' NOT NULL,
+                    description TEXT NULL,
+                    status VARCHAR(50) NOT NULL,
+                    is_paid BOOLEAN DEFAULT 0,
+                    is_captured BOOLEAN DEFAULT 0,
+                    confirmation_url TEXT NULL,
+                    metadata_json TEXT NULL,
+                    transaction_id INTEGER NULL,
+                    payment_method_type VARCHAR(50) NULL,
+                    refundable BOOLEAN DEFAULT 0,
+                    test_mode BOOLEAN DEFAULT 0,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    yookassa_created_at DATETIME NULL,
+                    captured_at DATETIME NULL,
+                    FOREIGN KEY (user_id) REFERENCES users(id),
+                    FOREIGN KEY (transaction_id) REFERENCES transactions(id)
+                );
+                
+                CREATE INDEX idx_yookassa_payments_user_id ON yookassa_payments(user_id);
+                CREATE INDEX idx_yookassa_payments_yookassa_id ON yookassa_payments(yookassa_payment_id);
+                CREATE INDEX idx_yookassa_payments_status ON yookassa_payments(status);
+                """
+                
+            elif db_type == 'postgresql':
+                create_sql = """
+                CREATE TABLE yookassa_payments (
+                    id SERIAL PRIMARY KEY,
+                    user_id INTEGER NOT NULL,
+                    yookassa_payment_id VARCHAR(255) UNIQUE NOT NULL,
+                    amount_kopeks INTEGER NOT NULL,
+                    currency VARCHAR(3) DEFAULT 'RUB' NOT NULL,
+                    description TEXT NULL,
+                    status VARCHAR(50) NOT NULL,
+                    is_paid BOOLEAN DEFAULT FALSE,
+                    is_captured BOOLEAN DEFAULT FALSE,
+                    confirmation_url TEXT NULL,
+                    metadata_json JSONB NULL,
+                    transaction_id INTEGER NULL,
+                    payment_method_type VARCHAR(50) NULL,
+                    refundable BOOLEAN DEFAULT FALSE,
+                    test_mode BOOLEAN DEFAULT FALSE,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    yookassa_created_at TIMESTAMP NULL,
+                    captured_at TIMESTAMP NULL,
+                    FOREIGN KEY (user_id) REFERENCES users(id),
+                    FOREIGN KEY (transaction_id) REFERENCES transactions(id)
+                );
+                
+                CREATE INDEX idx_yookassa_payments_user_id ON yookassa_payments(user_id);
+                CREATE INDEX idx_yookassa_payments_yookassa_id ON yookassa_payments(yookassa_payment_id);
+                CREATE INDEX idx_yookassa_payments_status ON yookassa_payments(status);
+                """
+                
+            elif db_type == 'mysql':
+                create_sql = """
+                CREATE TABLE yookassa_payments (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    user_id INT NOT NULL,
+                    yookassa_payment_id VARCHAR(255) UNIQUE NOT NULL,
+                    amount_kopeks INT NOT NULL,
+                    currency VARCHAR(3) DEFAULT 'RUB' NOT NULL,
+                    description TEXT NULL,
+                    status VARCHAR(50) NOT NULL,
+                    is_paid BOOLEAN DEFAULT FALSE,
+                    is_captured BOOLEAN DEFAULT FALSE,
+                    confirmation_url TEXT NULL,
+                    metadata_json JSON NULL,
+                    transaction_id INT NULL,
+                    payment_method_type VARCHAR(50) NULL,
+                    refundable BOOLEAN DEFAULT FALSE,
+                    test_mode BOOLEAN DEFAULT FALSE,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+                    yookassa_created_at DATETIME NULL,
+                    captured_at DATETIME NULL,
+                    FOREIGN KEY (user_id) REFERENCES users(id),
+                    FOREIGN KEY (transaction_id) REFERENCES transactions(id)
+                );
+                
+                CREATE INDEX idx_yookassa_payments_user_id ON yookassa_payments(user_id);
+                CREATE INDEX idx_yookassa_payments_yookassa_id ON yookassa_payments(yookassa_payment_id);
+                CREATE INDEX idx_yookassa_payments_status ON yookassa_payments(status);
+                """
+            else:
+                logger.error(f"Неподдерживаемый тип БД для создания таблицы: {db_type}")
+                return False
+            
+            await conn.execute(text(create_sql))
+            logger.info("Таблица yookassa_payments успешно создана")
+            return True
+            
+    except Exception as e:
+        logger.error(f"Ошибка создания таблицы yookassa_payments: {e}")
+        return False
+
+async def add_remnawave_v2_columns():
+    
+    columns_to_add = {
+        'lifetime_used_traffic_bytes': 'BIGINT DEFAULT 0',
+        'last_remnawave_sync': 'TIMESTAMP NULL',
+        'trojan_password': 'VARCHAR(255) NULL',
+        'vless_uuid': 'VARCHAR(255) NULL',
+        'ss_password': 'VARCHAR(255) NULL'
+    }
+    
+    logger.info("=== ПРОВЕРКА КОЛОНОК REMNAWAVE V2.1.5 ===")
+    
+    try:
+        async with engine.begin() as conn:
+            db_type = await get_database_type()
+            columns_added = 0
+            
+            for column_name, column_def in columns_to_add.items():
+                exists = await check_column_exists('users', column_name)
+                
+                if not exists:
+                    logger.info(f"Добавление колонки {column_name} в таблицу users")
+                    
+                    if db_type == 'sqlite':
+                        if column_def.startswith('BIGINT'):
+                            column_def = column_def.replace('BIGINT', 'INTEGER')
+                        column_def = column_def.replace('TIMESTAMP', 'DATETIME')
+                    elif db_type == 'mysql':
+                        column_def = column_def.replace('TIMESTAMP', 'DATETIME')
+                    
+                    try:
+                        await conn.execute(text(f"ALTER TABLE users ADD COLUMN {column_name} {column_def}"))
+                        columns_added += 1
+                        logger.info(f"Колонка {column_name} успешно добавлена")
+                    except Exception as e:
+                        logger.error(f"Ошибка добавления колонки {column_name}: {e}")
+                        continue
+                        
+                else:
+                    logger.debug(f"Колонка {column_name} уже существует")
+            
+            if columns_added > 0:
+                logger.info(f"Добавлено {columns_added} новых колонок для RemnaWave v2.1.5")
+            else:
+                logger.info("Все колонки RemnaWave v2.1.5 уже существуют")
+                
+            return columns_added
+            
+    except Exception as e:
+        logger.error(f"Ошибка при добавлении колонок RemnaWave v2.1.5: {e}")
+        return 0
+
+async def fix_subscription_duplicates_universal():
+    
+    async with engine.begin() as conn:
+        db_type = await get_database_type()
+        logger.info(f"Обнаружен тип базы данных: {db_type}")
+        
+        try:
+            result = await conn.execute(text("""
+                SELECT user_id, COUNT(*) as count 
+                FROM subscriptions 
+                GROUP BY user_id 
+                HAVING COUNT(*) > 1
+            """))
+            
+            duplicates = result.fetchall()
+            
+            if not duplicates:
+                logger.info("Дублирующихся подписок не найдено")
+                return 0
+                
+            logger.info(f"Найдено {len(duplicates)} пользователей с дублирующимися подписками")
+            
+            total_deleted = 0
+            
+            for user_id_row, count in duplicates:
+                user_id = user_id_row
+                
+                if db_type == 'sqlite':
+                    delete_result = await conn.execute(text("""
+                        DELETE FROM subscriptions 
+                        WHERE user_id = :user_id AND id NOT IN (
+                            SELECT MAX(id) 
+                            FROM subscriptions 
+                            WHERE user_id = :user_id
+                        )
+                    """), {"user_id": user_id})
+                    
+                elif db_type in ['postgresql', 'mysql']:
+                    delete_result = await conn.execute(text("""
+                        DELETE FROM subscriptions 
+                        WHERE user_id = :user_id AND id NOT IN (
+                            SELECT max_id FROM (
+                                SELECT MAX(id) as max_id
+                                FROM subscriptions 
+                                WHERE user_id = :user_id
+                            ) as subquery
+                        )
+                    """), {"user_id": user_id})
+                
+                else:
+                    subs_result = await conn.execute(text("""
+                        SELECT id FROM subscriptions 
+                        WHERE user_id = :user_id 
+                        ORDER BY created_at DESC, id DESC
+                    """), {"user_id": user_id})
+                    
+                    sub_ids = [row[0] for row in subs_result.fetchall()]
+                    
+                    if len(sub_ids) > 1:
+                        ids_to_delete = sub_ids[1:]
+                        for sub_id in ids_to_delete:
+                            await conn.execute(text("""
+                                DELETE FROM subscriptions WHERE id = :id
+                            """), {"id": sub_id})
+                        delete_result = type('Result', (), {'rowcount': len(ids_to_delete)})()
+                    else:
+                        delete_result = type('Result', (), {'rowcount': 0})()
+                
+                deleted_count = delete_result.rowcount
+                total_deleted += deleted_count
+                logger.info(f"Удалено {deleted_count} дублирующихся подписок для пользователя {user_id}")
+            
+            logger.info(f"Всего удалено дублирующихся подписок: {total_deleted}")
+            return total_deleted
+            
+        except Exception as e:
+            logger.error(f"Ошибка при очистке дублирующихся подписок: {e}")
+            raise
+
+async def run_universal_migration():
+    
+    logger.info("=== НАЧАЛО УНИВЕРСАЛЬНОЙ МИГРАЦИИ ===")
+    
+    try:
+        db_type = await get_database_type()
+        logger.info(f"Тип базы данных: {db_type}")
+        
+        await add_remnawave_v2_columns()
+        
+        logger.info("=== СОЗДАНИЕ ТАБЛИЦЫ YOOKASSA ===")
+        yookassa_created = await create_yookassa_payments_table()
+        if yookassa_created:
+            logger.info("✅ Таблица YooKassa payments готова")
+        else:
+            logger.warning("⚠️ Проблемы с таблицей YooKassa payments")
+        
+        async with engine.begin() as conn:
+            total_subs = await conn.execute(text("SELECT COUNT(*) FROM subscriptions"))
+            unique_users = await conn.execute(text("SELECT COUNT(DISTINCT user_id) FROM subscriptions"))
+            
+            total_count = total_subs.fetchone()[0]
+            unique_count = unique_users.fetchone()[0]
+            
+            logger.info(f"Всего подписок: {total_count}")
+            logger.info(f"Уникальных пользователей: {unique_count}")
+            
+            if total_count == unique_count:
+                logger.info("База данных уже в корректном состоянии")
+                return True
+        
+        deleted_count = await fix_subscription_duplicates_universal()
+        
+        async with engine.begin() as conn:
+            final_check = await conn.execute(text("""
+                SELECT user_id, COUNT(*) as count 
+                FROM subscriptions 
+                GROUP BY user_id 
+                HAVING COUNT(*) > 1
+            """))
+            
+            remaining_duplicates = final_check.fetchall()
+            
+            if remaining_duplicates:
+                logger.warning(f"Остались дубликаты у {len(remaining_duplicates)} пользователей")
+                return False
+            else:
+                logger.info("=== МИГРАЦИЯ ЗАВЕРШЕНА УСПЕШНО ===")
+                return True
+                
+    except Exception as e:
+        logger.error(f"=== ОШИБКА ВЫПОЛНЕНИЯ МИГРАЦИИ: {e} ===")
+        return False

app/external/remnawave_api.py

@@ -1,7 +1,9 @@
 import asyncio
 import json
+import ssl
 from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Union, Any
+from urllib.parse import urlparse
 import aiohttp
 import logging
 from dataclasses import dataclass
@@ -31,7 +33,7 @@ class RemnaWaveUser:
     username: str
     status: UserStatus
     used_traffic_bytes: int
-    lifetime_used_traffic_bytes: int
+    lifetime_used_traffic_bytes: int  # Новое поле
     traffic_limit_bytes: int
     traffic_limit_strategy: TrafficLimitStrategy
     expire_at: datetime
@@ -44,6 +46,16 @@ class RemnaWaveUser:
     active_internal_squads: List[Dict[str, str]]
     created_at: datetime
     updated_at: datetime
+    sub_last_user_agent: Optional[str] = None
+    sub_last_opened_at: Optional[datetime] = None
+    online_at: Optional[datetime] = None
+    sub_revoked_at: Optional[datetime] = None
+    last_traffic_reset_at: Optional[datetime] = None
+    trojan_password: Optional[str] = None
+    vless_uuid: Optional[str] = None
+    ss_password: Optional[str] = None
+    first_connected_at: Optional[datetime] = None
+    last_triggered_threshold: int = 0
 
 
 @dataclass
@@ -85,13 +97,65 @@ class RemnaWaveAPI:
         self.api_key = api_key
         self.session: Optional[aiohttp.ClientSession] = None
         
+    def _detect_connection_type(self) -> str:
+        parsed = urlparse(self.base_url)
+        
+        local_hosts = [
+            'localhost', '127.0.0.1', 'remnawave', 
+            'remnawave-backend', 'app', 'api'
+        ]
+        
+        if parsed.hostname in local_hosts:
+            return "local"
+            
+        if parsed.hostname:
+            if (parsed.hostname.startswith('192.168.') or 
+                parsed.hostname.startswith('10.') or 
+                parsed.hostname.startswith('172.') or
+                parsed.hostname.endswith('.local')):
+                return "local"
+        
+        return "external"
+        
     async def __aenter__(self):
+        conn_type = self._detect_connection_type()
+        
+        logger.info(f"🔗 Подключение к RemnaWave: {self.base_url} (тип: {conn_type})")
+            
+        headers = {
+            'Authorization': f'Bearer {self.api_key}',
+            'Content-Type': 'application/json'
+        }
+        
+        connector_kwargs = {}
+        
+        if conn_type == "local":
+            logger.debug("🏠 Использую локальные заголовки proxy")
+            headers.update({
+                'X-Forwarded-For': '127.0.0.1',
+                'X-Forwarded-Proto': 'https',
+                'X-Forwarded-Host': 'localhost',
+                'X-Real-IP': '127.0.0.1',
+                'Host': 'localhost'
+            })
+            
+            if self.base_url.startswith('https://'):
+                ssl_context = ssl.create_default_context()
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
+                connector_kwargs['ssl'] = ssl_context
+                logger.debug("🔓 SSL проверка отключена для локального HTTPS")
+                
+        elif conn_type == "external":
+            logger.debug("🌐 Использую внешнее подключение с полной SSL проверкой")
+            pass
+            
+        connector = aiohttp.TCPConnector(**connector_kwargs)
+        
         self.session = aiohttp.ClientSession(
             timeout=aiohttp.ClientTimeout(total=30),
-            headers={
-                'Authorization': f'Bearer {self.api_key}',
-                'Content-Type': 'application/json'
-            }
+            headers=headers,
+            connector=connector
         )
         return self
         
@@ -375,6 +439,56 @@ class RemnaWaveAPI:
         return response['response']
     
     
+    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
+    
+    
     def _parse_user(self, user_data: Dict) -> RemnaWaveUser:
         return RemnaWaveUser(
             uuid=user_data['uuid'],
@@ -394,8 +508,23 @@ class RemnaWaveAPI:
             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'))
+            updated_at=datetime.fromisoformat(user_data['updatedAt'].replace('Z', '+00:00')),
+            sub_last_user_agent=user_data.get('subLastUserAgent'),
+            sub_last_opened_at=self._parse_optional_datetime(user_data.get('subLastOpenedAt')),
+            online_at=self._parse_optional_datetime(user_data.get('onlineAt')),
+            sub_revoked_at=self._parse_optional_datetime(user_data.get('subRevokedAt')),
+            last_traffic_reset_at=self._parse_optional_datetime(user_data.get('lastTrafficResetAt')),
+            trojan_password=user_data.get('trojanPassword'),
+            vless_uuid=user_data.get('vlessUuid'),
+            ss_password=user_data.get('ssPassword'),
+            first_connected_at=self._parse_optional_datetime(user_data.get('firstConnectedAt')),
+            last_triggered_threshold=user_data.get('lastTriggeredThreshold', 0)
         )
+
+    def _parse_optional_datetime(self, date_str: Optional[str]) -> Optional[datetime]:
+        if date_str:
+            return datetime.fromisoformat(date_str.replace('Z', '+00:00'))
+        return None
     
     def _parse_internal_squad(self, squad_data: Dict) -> RemnaWaveInternalSquad:
         return RemnaWaveInternalSquad(
@@ -422,7 +551,6 @@ class RemnaWaveAPI:
         )
 
 
-
 def format_bytes(bytes_value: int) -> str:
     if bytes_value == 0:
         return "0 B"
@@ -467,55 +595,3 @@ async def test_api_connection(api: RemnaWaveAPI) -> bool:
     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/tribute.py

@@ -28,7 +28,6 @@ class TributeService:
             return None
         
         try:
-            
             payment_url = f"{self.donate_link}&user_id={user_id}"
             
             logger.info(f"Создана ссылка Tribute для пользователя {user_id}")
@@ -41,7 +40,7 @@ class TributeService:
     def verify_webhook_signature(self, payload: str, signature: str) -> bool:
         
         if not self.webhook_secret:
-            logger.warning("Webhook secret не настроен")
+            logger.warning("Webhook secret не настроен, пропускаем проверку")
             return True 
         
         try:
@@ -51,31 +50,54 @@ class TributeService:
                 hashlib.sha256
             ).hexdigest()
             
-            return hmac.compare_digest(signature, expected_signature)
+            is_valid = hmac.compare_digest(signature, expected_signature)
+            
+            if is_valid:
+                logger.info("✅ Подпись Tribute webhook проверена успешно")
+            else:
+                logger.error("❌ Неверная подпись Tribute webhook")
+            
+            return is_valid
             
         except Exception as e:
             logger.error(f"Ошибка проверки подписи webhook: {e}")
             return False
     
-    async def process_webhook(self, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    async def process_webhook(self, payload_or_data) -> Optional[Dict[str, Any]]:
         
         try:
+            logger.info(f"🔄 Начинаем обработку Tribute webhook")
             
-            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 isinstance(payload_or_data, str):
+                try:
+                    webhook_data = json.loads(payload_or_data)
+                    logger.info(f"📊 Распарсенные данные: {webhook_data}")
+                except json.JSONDecodeError as e:
+                    logger.error(f"❌ Ошибка парсинга JSON: {e}")
+                    return None
+            else:
+                webhook_data = payload_or_data
             
-            if not payment_id and "payload" in payload:
-                data = payload["payload"]
+            payment_id = None
+            status = None
+            amount_kopeks = 0
+            telegram_user_id = None
+            
+            payment_id = webhook_data.get("id") or webhook_data.get("payment_id")
+            status = webhook_data.get("status")
+            amount_kopeks = webhook_data.get("amount", 0) 
+            telegram_user_id = webhook_data.get("telegram_user_id") or webhook_data.get("user_id")
+            
+            if not payment_id and "payload" in webhook_data:
+                data = webhook_data["payload"]
                 payment_id = data.get("id") or data.get("payment_id")
                 status = data.get("status")
-                amount_rubles = data.get("amount", 0)
+                amount_kopeks = 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", {})
+            if not payment_id and "name" in webhook_data:
+                event_name = webhook_data.get("name")
+                data = webhook_data.get("payload", {})
                 payment_id = str(data.get("donation_request_id")) 
                 amount_kopeks = data.get("amount", 0) 
                 telegram_user_id = data.get("telegram_user_id")
@@ -87,22 +109,54 @@ class TributeService:
                 else:
                     status = "unknown"
             
-            logger.info(f"Обработка Tribute webhook: payment_id={payment_id}, status={status}, amount_kopeks={amount_kopeks}, user_id={telegram_user_id}")
+            logger.info(f"📝 Извлеченные данные: 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 данных")
+                logger.error("❌ Не найден telegram_user_id в webhook данных")
+                logger.error(f"🔍 Полные данные для отладки: {json.dumps(webhook_data, ensure_ascii=False, indent=2)}")
                 return None
             
-            return {
+            try:
+                telegram_user_id = int(telegram_user_id)
+            except (ValueError, TypeError):
+                logger.error(f"❌ Некорректный telegram_user_id: {telegram_user_id}")
+                return None
+            
+            result = {
                 "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,
+                "user_id": telegram_user_id,
+                "amount_kopeks": int(amount_kopeks) if amount_kopeks else 0,
                 "status": status or "paid",
-                "external_id": f"donation_{payment_id}"
+                "external_id": f"donation_{payment_id or 'unknown'}",
+                "payment_system": "tribute"
             }
             
+            logger.info(f"✅ Tribute webhook обработан успешно: {result}")
+            return result
+            
         except Exception as e:
-            logger.error(f"Ошибка обработки Tribute webhook: {e}")
-            logger.error(f"Webhook payload: {json.dumps(payload, ensure_ascii=False)}")
-            return None
+            logger.error(f"❌ Ошибка обработки Tribute webhook: {e}", exc_info=True)
+            logger.error(f"🔍 Webhook data для отладки: {json.dumps(webhook_data, ensure_ascii=False, indent=2)}")
+            return None
+    
+    async def get_payment_status(self, payment_id: str) -> Optional[Dict[str, Any]]:
+        try:
+            logger.info(f"Запрос статуса платежа {payment_id}")
+            return {"status": "unknown", "payment_id": payment_id}
+        except Exception as e:
+            logger.error(f"Ошибка получения статуса платежа: {e}")
+            return None
+    
+    async def refund_payment(
+        self,
+        payment_id: str,
+        amount_kopeks: Optional[int] = None,
+        reason: str = "Возврат по запросу"
+    ) -> Optional[Dict[str, Any]]:
+        try:
+            logger.info(f"Создание возврата для платежа {payment_id}")
+            return {"refund_id": f"refund_{payment_id}", "status": "pending"}
+        except Exception as e:
+            logger.error(f"Ошибка создания возврата: {e}")
+            return None

app/external/webhook_server.py

@@ -1,4 +1,5 @@
 import logging
+import json
 from typing import Optional
 
 from aiohttp import web
@@ -26,9 +27,11 @@ class WebhookServer:
         self.app.router.add_post(settings.TRIBUTE_WEBHOOK_PATH, self._tribute_webhook_handler)
         self.app.router.add_get('/health', self._health_check)
         
+        self.app.router.add_options(settings.TRIBUTE_WEBHOOK_PATH, self._options_handler)
+        
         logger.info(f"Webhook сервер настроен:")
-        logger.info(f"  - Tribute webhook: {settings.TRIBUTE_WEBHOOK_PATH}")
-        logger.info(f"  - Health check: /health")
+        logger.info(f"  - Tribute webhook: POST {settings.TRIBUTE_WEBHOOK_PATH}")
+        logger.info(f"  - Health check: GET /health")
         
         return self.app
     
@@ -49,11 +52,11 @@ class WebhookServer:
             
             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}")
+            logger.info(f"✅ Tribute webhook сервер запущен на порту {settings.TRIBUTE_WEBHOOK_PORT}")
+            logger.info(f"🎯 Tribute webhook URL: http://0.0.0.0:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
             
         except Exception as e:
-            logger.error(f"❌ Ошибка запуска webhook сервера: {e}")
+            logger.error(f"❌ Ошибка запуска Tribute webhook сервера: {e}")
             raise
     
     async def stop(self):
@@ -61,31 +64,82 @@ class WebhookServer:
         try:
             if self.site:
                 await self.site.stop()
-                logger.info("Webhook сайт остановлен")
+                logger.info("Tribute webhook сайт остановлен")
             
             if self.runner:
                 await self.runner.cleanup()
-                logger.info("Webhook runner очищен")
+                logger.info("Tribute webhook runner очищен")
                 
         except Exception as e:
-            logger.error(f"Ошибка остановки webhook сервера: {e}")
+            logger.error(f"Ошибка остановки Tribute webhook сервера: {e}")
+    
+    async def _options_handler(self, request: web.Request) -> web.Response:
+        return web.Response(
+            status=200,
+            headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, X-Tribute-Signature',
+            }
+        )
     
     async def _tribute_webhook_handler(self, request: web.Request) -> web.Response:
         
         try:
+            logger.info(f"📥 Получен Tribute webhook: {request.method} {request.path}")
+            logger.info(f"📋 Headers: {dict(request.headers)}")
+            
             raw_body = await request.read()
+            
+            if not raw_body:
+                logger.warning("⚠️ Получен пустой webhook от Tribute")
+                return web.json_response(
+                    {"status": "error", "reason": "empty_body"},
+                    status=400
+                )
+            
             payload = raw_body.decode('utf-8')
+            logger.info(f"📄 Payload: {payload}")
+            
+            try:
+                webhook_data = json.loads(payload)
+                logger.info(f"📊 Распарсенные данные: {webhook_data}")
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ Ошибка парсинга JSON: {e}")
+                return web.json_response(
+                    {"status": "error", "reason": "invalid_json"},
+                    status=400
+                )
             
             signature = request.headers.get('X-Tribute-Signature')
+            logger.info(f"🔐 Signature: {signature}")
+            
+            if signature and settings.TRIBUTE_WEBHOOK_SECRET:
+                from app.external.tribute import TributeService as TributeAPI
+                tribute_api = TributeAPI()
+                if not tribute_api.verify_webhook_signature(payload, signature):
+                    logger.error("❌ Неверная подпись Tribute webhook")
+                    return web.json_response(
+                        {"status": "error", "reason": "invalid_signature"},
+                        status=401
+                    )
             
             result = await self.tribute_service.process_webhook(payload, signature)
             
-            return web.json_response(result, status=200)
+            if result:
+                logger.info(f"✅ Tribute webhook обработан успешно: {result}")
+                return web.json_response({"status": "ok", "result": result}, status=200)
+            else:
+                logger.error("❌ Ошибка обработки Tribute webhook")
+                return web.json_response(
+                    {"status": "error", "reason": "processing_failed"},
+                    status=400
+                )
             
         except Exception as e:
-            logger.error(f"Ошибка обработки Tribute webhook: {e}")
+            logger.error(f"❌ Критическая ошибка обработки Tribute webhook: {e}", exc_info=True)
             return web.json_response(
-                {"status": "error", "reason": "internal_error"},
+                {"status": "error", "reason": "internal_error", "message": str(e)},
                 status=500
             )
     
@@ -94,5 +148,7 @@ class WebhookServer:
         return web.json_response({
             "status": "ok",
             "service": "tribute-webhooks",
-            "tribute_enabled": settings.TRIBUTE_ENABLED
-        })
+            "tribute_enabled": settings.TRIBUTE_ENABLED,
+            "port": settings.TRIBUTE_WEBHOOK_PORT,
+            "path": settings.TRIBUTE_WEBHOOK_PATH
+        })

app/external/yookassa_webhook.py

@@ -0,0 +1,243 @@
+import asyncio
+import logging
+import json
+import hashlib
+import hmac
+import base64
+from typing import Optional, Dict, Any
+from aiohttp import web
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.services.payment_service import PaymentService
+from app.database.database import get_db
+
+logger = logging.getLogger(__name__)
+
+
+class YooKassaWebhookHandler:
+
+    @staticmethod
+    def verify_webhook_signature(body: str, signature: str, secret: str) -> bool:
+        try:
+            signature_parts = signature.strip().split(' ')
+            
+            if len(signature_parts) < 4:
+                logger.error(f"Неверный формат подписи YooKassa: {signature}")
+                return False
+            
+            version = signature_parts[0] 
+            payment_id = signature_parts[1] 
+            timestamp = signature_parts[2]  
+            received_signature = signature_parts[3]
+            
+            if version != "v1":
+                logger.error(f"Неподдерживаемая версия подписи: {version}")
+                return False
+            
+            logger.info(f"Проверка подписи v1 для платежа {payment_id}, timestamp: {timestamp}")
+            
+            
+            expected_signature_1 = hmac.new(
+                secret.encode('utf-8'),
+                body.encode('utf-8'),
+                hashlib.sha256
+            ).digest()
+            expected_signature_1_b64 = base64.b64encode(expected_signature_1).decode('utf-8')
+            
+            signed_payload_2 = f"{payment_id}.{timestamp}.{body}"
+            expected_signature_2 = hmac.new(
+                secret.encode('utf-8'),
+                signed_payload_2.encode('utf-8'),
+                hashlib.sha256
+            ).digest()
+            expected_signature_2_b64 = base64.b64encode(expected_signature_2).decode('utf-8')
+            
+            signed_payload_3 = f"{timestamp}.{body}"
+            expected_signature_3 = hmac.new(
+                secret.encode('utf-8'),
+                signed_payload_3.encode('utf-8'),
+                hashlib.sha256
+            ).digest()
+            expected_signature_3_b64 = base64.b64encode(expected_signature_3).decode('utf-8')
+            
+            logger.debug(f"Получена подпись: {received_signature}")
+            logger.debug(f"Ожидаемая подпись (вариант 1): {expected_signature_1_b64}")
+            logger.debug(f"Ожидаемая подпись (вариант 2): {expected_signature_2_b64}")
+            logger.debug(f"Ожидаемая подпись (вариант 3): {expected_signature_3_b64}")
+            
+            is_valid = (
+                hmac.compare_digest(received_signature, expected_signature_1_b64) or
+                hmac.compare_digest(received_signature, expected_signature_2_b64) or  
+                hmac.compare_digest(received_signature, expected_signature_3_b64)
+            )
+            
+            if is_valid:
+                logger.info("✅ Подпись YooKassa webhook проверена успешно")
+            else:
+                logger.warning("⚠️ Подпись YooKassa webhook не совпадает ни с одним вариантом")
+            
+            return is_valid
+            
+        except Exception as e:
+            logger.error(f"Ошибка проверки подписи YooKassa: {e}")
+            return False
+    
+    def __init__(self, payment_service: PaymentService):
+        self.payment_service = payment_service
+    
+    async def handle_webhook(self, request: web.Request) -> web.Response:
+        
+        try:
+            logger.info(f"📥 Получен YooKassa webhook: {request.method} {request.path}")
+            logger.info(f"📋 Headers: {dict(request.headers)}")
+            
+            body = await request.text()
+            
+            if not body:
+                logger.warning("⚠️ Получен пустой webhook от YooKassa")
+                return web.Response(status=400, text="Empty body")
+            
+            logger.info(f"📄 Body: {body}")
+            
+            signature = request.headers.get('Signature') or request.headers.get('X-YooKassa-Signature')
+            
+            if settings.YOOKASSA_WEBHOOK_SECRET and signature:
+                logger.info(f"🔐 Получена подпись: {signature}")
+                
+                if not YooKassaWebhookHandler.verify_webhook_signature(body, signature, settings.YOOKASSA_WEBHOOK_SECRET):
+                    logger.warning("❌ Подпись не совпала, но продолжаем обработку (режим отладки)")
+                else:
+                    logger.info("✅ Подпись webhook проверена успешно")
+                    
+            elif settings.YOOKASSA_WEBHOOK_SECRET and not signature:
+                logger.warning("⚠️ Webhook без подписи, но секрет настроен")
+                
+            elif signature and not settings.YOOKASSA_WEBHOOK_SECRET:
+                logger.info("ℹ️ Подпись получена, но проверка отключена (YOOKASSA_WEBHOOK_SECRET не настроен)")
+                
+            else:
+                logger.info("ℹ️ Проверка подписи отключена")
+            
+            try:
+                webhook_data = json.loads(body)
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ Ошибка парсинга JSON webhook YooKassa: {e}")
+                return web.Response(status=400, text="Invalid JSON")
+            
+            logger.info(f"📊 Обработка webhook YooKassa: {webhook_data.get('event', 'unknown_event')}")
+            logger.debug(f"🔍 Полные данные webhook: {webhook_data}")
+            
+            event_type = webhook_data.get("event")
+            if not event_type:
+                logger.warning("⚠️ Webhook YooKassa без типа события")
+                return web.Response(status=400, text="No event type")
+            
+            if event_type not in ["payment.succeeded", "payment.waiting_for_capture"]:
+                logger.info(f"ℹ️ Игнорируем событие YooKassa: {event_type}")
+                return web.Response(status=200, text="OK")
+            
+            async for db in get_db():
+                try:
+                    success = await self.payment_service.process_yookassa_webhook(db, webhook_data)
+                    
+                    if success:
+                        logger.info(f"✅ Успешно обработан webhook YooKassa: {event_type}")
+                        return web.Response(status=200, text="OK")
+                    else:
+                        logger.error(f"❌ Ошибка обработки webhook YooKassa: {event_type}")
+                        return web.Response(status=500, text="Processing error")
+                        
+                finally:
+                    await db.close()
+        
+        except Exception as e:
+            logger.error(f"❌ Критическая ошибка обработки webhook YooKassa: {e}", exc_info=True)
+            return web.Response(status=500, text="Internal server error")
+    
+    def setup_routes(self, app: web.Application) -> None:
+        
+        webhook_path = settings.YOOKASSA_WEBHOOK_PATH
+        app.router.add_post(webhook_path, self.handle_webhook)
+        app.router.add_get(webhook_path, self._get_handler) 
+        app.router.add_options(webhook_path, self._options_handler) 
+        
+        logger.info(f"✅ Настроен YooKassa webhook на пути: POST {webhook_path}")
+    
+    async def _get_handler(self, request: web.Request) -> web.Response:
+        return web.json_response({
+            "status": "ok",
+            "message": "YooKassa webhook endpoint is working",
+            "method": "GET",
+            "path": request.path,
+            "note": "Use POST method for actual webhooks"
+        })
+    
+    async def _options_handler(self, request: web.Request) -> web.Response:
+        return web.Response(
+            status=200,
+            headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, X-YooKassa-Signature',
+            }
+        )
+
+
+def create_yookassa_webhook_app(payment_service: PaymentService) -> web.Application:
+    
+    app = web.Application()
+    
+    webhook_handler = YooKassaWebhookHandler(payment_service)
+    webhook_handler.setup_routes(app)
+    
+    async def health_check(request):
+        return web.json_response({
+            "status": "ok", 
+            "service": "yookassa_webhook",
+            "port": settings.YOOKASSA_WEBHOOK_PORT,
+            "path": settings.YOOKASSA_WEBHOOK_PATH,
+            "enabled": settings.is_yookassa_enabled()
+        })
+    
+    app.router.add_get("/health", health_check)
+    
+    return app
+
+
+async def start_yookassa_webhook_server(payment_service: PaymentService) -> None:
+    
+    if not settings.is_yookassa_enabled():
+        logger.info("ℹ️ YooKassa отключена, webhook сервер не запускается")
+        return
+    
+    try:
+        app = create_yookassa_webhook_app(payment_service)
+        
+        runner = web.AppRunner(app)
+        await runner.setup()
+        
+        site = web.TCPSite(
+            runner, 
+            host='0.0.0.0',  
+            port=settings.YOOKASSA_WEBHOOK_PORT
+        )
+        
+        await site.start()
+        
+        logger.info(f"✅ YooKassa webhook сервер запущен на порту {settings.YOOKASSA_WEBHOOK_PORT}")
+        logger.info(f"🎯 YooKassa webhook URL: http://0.0.0.0:{settings.YOOKASSA_WEBHOOK_PORT}{settings.YOOKASSA_WEBHOOK_PATH}")
+        
+        try:
+            while True:
+                await asyncio.sleep(1)
+        except asyncio.CancelledError:
+            logger.info("🛑 YooKassa webhook сервер получил сигнал остановки")
+        finally:
+            await site.stop()
+            await runner.cleanup()
+            logger.info("✅ YooKassa webhook сервер остановлен")
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка запуска YooKassa webhook сервера: {e}", exc_info=True)
+        raise

app/handlers/admin/maintenance.py

@@ -0,0 +1,235 @@
+import logging
+from aiogram import Dispatcher, types, F
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database.models import User
+from app.services.maintenance_service import maintenance_service
+from app.keyboards.admin import get_maintenance_keyboard, get_admin_main_keyboard
+from app.localization.texts import get_texts
+from app.utils.decorators import admin_required, error_handler
+
+logger = logging.getLogger(__name__)
+
+
+class MaintenanceStates(StatesGroup):
+    waiting_for_reason = State()
+
+
+@admin_required
+@error_handler
+async def show_maintenance_panel(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    status_info = maintenance_service.get_status_info()
+    
+    status_emoji = "🔧" if status_info["is_active"] else "✅"
+    status_text = "Включен" if status_info["is_active"] else "Выключен"
+    
+    api_emoji = "✅" if status_info["api_status"] else "❌"
+    api_text = "Доступно" if status_info["api_status"] else "Недоступно"
+    
+    monitoring_emoji = "🔄" if status_info["monitoring_active"] else "⏹️"
+    monitoring_text = "Запущен" if status_info["monitoring_active"] else "Остановлен"
+    
+    enabled_info = ""
+    if status_info["is_active"] and status_info["enabled_at"]:
+        enabled_time = status_info["enabled_at"].strftime("%d.%m.%Y %H:%M:%S")
+        enabled_info = f"\n📅 <b>Включен:</b> {enabled_time}"
+        if status_info["reason"]:
+            enabled_info += f"\n📝 <b>Причина:</b> {status_info['reason']}"
+    
+    last_check_info = ""
+    if status_info["last_check"]:
+        last_check_time = status_info["last_check"].strftime("%H:%M:%S")
+        last_check_info = f"\n🕐 <b>Последняя проверка:</b> {last_check_time}"
+    
+    failures_info = ""
+    if status_info["consecutive_failures"] > 0:
+        failures_info = f"\n⚠️ <b>Неудачных проверок подряд:</b> {status_info['consecutive_failures']}"
+    
+    message_text = f"""
+🔧 <b>Режим технических работ</b>
+
+{status_emoji} <b>Статус:</b> {status_text}
+{api_emoji} <b>API RemnaWave:</b> {api_text}
+{monitoring_emoji} <b>Мониторинг:</b> {monitoring_text}
+⏱️ <b>Интервал проверки:</b> {status_info['check_interval']}с
+🤖 <b>Автовключение:</b> {'Включено' if status_info['auto_enable_configured'] else 'Отключено'}
+{enabled_info}
+{last_check_info}
+{failures_info}
+
+ℹ️ <i>В режиме техработ обычные пользователи не могут использовать бота. Администраторы имеют полный доступ.</i>
+"""
+    
+    await callback.message.edit_text(
+        message_text,
+        reply_markup=get_maintenance_keyboard(db_user.language, status_info["is_active"], status_info["monitoring_active"])
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def toggle_maintenance_mode(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession,
+    state: FSMContext
+):
+    is_active = maintenance_service.is_maintenance_active()
+    
+    if is_active:
+        success = await maintenance_service.disable_maintenance()
+        if success:
+            await callback.answer("Режим техработ выключен", show_alert=True)
+        else:
+            await callback.answer("Ошибка выключения режима техработ", show_alert=True)
+    else:
+        await state.set_state(MaintenanceStates.waiting_for_reason)
+        await callback.message.edit_text(
+            "🔧 <b>Включение режима техработ</b>\n\nВведите причину включения техработ или отправьте /skip для пропуска:",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="❌ Отмена", callback_data="maintenance_panel")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_maintenance_reason(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    state: FSMContext
+):
+    current_state = await state.get_state()
+    
+    if current_state != MaintenanceStates.waiting_for_reason:
+        return
+    
+    reason = None
+    if message.text and message.text != "/skip":
+        reason = message.text[:200] 
+    
+    success = await maintenance_service.enable_maintenance(reason=reason, auto=False)
+    
+    if success:
+        response_text = "Режим техработ включен"
+        if reason:
+            response_text += f"\nПричина: {reason}"
+    else:
+        response_text = "Ошибка включения режима техработ"
+    
+    await message.answer(response_text)
+    await state.clear()
+    
+    status_info = maintenance_service.get_status_info()
+    await message.answer(
+        "Вернуться к панели управления техработами:",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="🔧 Панель техработ", callback_data="maintenance_panel")]
+        ])
+    )
+
+
+@admin_required  
+@error_handler
+async def toggle_monitoring(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    status_info = maintenance_service.get_status_info()
+    
+    if status_info["monitoring_active"]:
+        success = await maintenance_service.stop_monitoring()
+        message = "Мониторинг остановлен" if success else "Ошибка остановки мониторинга"
+    else:
+        success = await maintenance_service.start_monitoring()
+        message = "Мониторинг запущен" if success else "Ошибка запуска мониторинга"
+    
+    await callback.answer(message, show_alert=True)
+    
+    await show_maintenance_panel(callback, db_user, db, None)
+
+
+@admin_required
+@error_handler
+async def force_api_check(
+    callback: types.CallbackQuery,
+    db_user: User, 
+    db: AsyncSession
+):
+    await callback.answer("Проверка API...", show_alert=False)
+    
+    check_result = await maintenance_service.force_api_check()
+    
+    if check_result["success"]:
+        status_text = "доступно" if check_result["api_available"] else "недоступно"
+        message = f"API {status_text}\nВремя ответа: {check_result['response_time']}с"
+    else:
+        message = f"Ошибка проверки: {check_result.get('error', 'Неизвестная ошибка')}"
+    
+    await callback.message.answer(message)
+    
+    await show_maintenance_panel(callback, db_user, db, None)
+
+
+@admin_required
+@error_handler
+async def back_to_admin_panel(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    texts = get_texts(db_user.language)
+    
+    await callback.message.edit_text(
+        texts.ADMIN_PANEL,
+        reply_markup=get_admin_main_keyboard(db_user.language)
+    )
+    await callback.answer()
+
+
+def register_handlers(dp: Dispatcher):
+    
+    dp.callback_query.register(
+        show_maintenance_panel,
+        F.data == "maintenance_panel"
+    )
+    
+    dp.callback_query.register(
+        toggle_maintenance_mode,
+        F.data == "maintenance_toggle"
+    )
+    
+    dp.callback_query.register(
+        toggle_monitoring,
+        F.data == "maintenance_monitoring"
+    )
+    
+    dp.callback_query.register(
+        force_api_check,
+        F.data == "maintenance_check_api"
+    )
+    
+    dp.callback_query.register(
+        back_to_admin_panel,
+        F.data == "admin_panel"
+    )
+    
+    dp.message.register(
+        process_maintenance_reason,
+        MaintenanceStates.waiting_for_reason
+    )

app/handlers/admin/remnawave.py

@@ -1315,27 +1315,417 @@ async def restart_all_nodes(
 @admin_required
 @error_handler
 async def show_sync_options(
-   callback: types.CallbackQuery,
-   db_user: User,
-   db: AsyncSession
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
 ):
-   text = """
+    text = """
 🔄 <b>Синхронизация с RemnaWave</b>
 
-Выберите тип синхронизации:
+🔄 <b>Полная синхронизация выполняет:</b>
+• Создание новых пользователей из панели в боте
+• Обновление данных существующих пользователей  
+• Деактивация подписок пользователей, отсутствующих в панели
+• Сохранение балансов пользователей
+• ⏱️ Время выполнения: 2-5 минут
 
-- <b>Синхронизировать всех</b> - полная синхронизация всех пользователей
-- <b>Только новых</b> - создание пользователей из панели, которых нет в боте
-- <b>Обновить данные</b> - обновление информации о трафике и подписках
-
-⚠️ Процесс может занять несколько минут
+⚠️ <b>Важно:</b>
+• Во время синхронизации не выполняйте другие операции
+• При полной синхронизации подписки пользователей, отсутствующих в панели, будут деактивированы
+• Рекомендуется делать полную синхронизацию ежедневно
+• Баланс пользователей НЕ удаляется
 """
-   
-   await callback.message.edit_text(
-       text,
-       reply_markup=get_sync_options_keyboard(db_user.language)
-   )
-   await callback.answer()
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="🔄 Запустить полную синхронизацию", callback_data="sync_all_users")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def sync_all_users(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    """Выполняет полную синхронизацию всех пользователей"""
+    
+    progress_text = """
+🔄 <b>Выполняется полная синхронизация...</b>
+
+📋 Этапы:
+• Загрузка ВСЕХ пользователей из панели RemnaWave
+• Создание новых пользователей в боте
+• Обновление существующих пользователей
+• Деактивация подписок отсутствующих пользователей
+• Сохранение балансов
+
+⏳ Пожалуйста, подождите...
+"""
+    
+    await callback.message.edit_text(progress_text, reply_markup=None)
+    
+    remnawave_service = RemnaWaveService()
+    stats = await remnawave_service.sync_users_from_panel(db, "all")
+    
+    total_operations = stats['created'] + stats['updated'] + stats.get('deleted', 0)
+    
+    if stats['errors'] == 0:
+        status_emoji = "✅"
+        status_text = "успешно завершена"
+    elif stats['errors'] < total_operations:
+        status_emoji = "⚠️"
+        status_text = "завершена с предупреждениями"
+    else:
+        status_emoji = "❌"
+        status_text = "завершена с ошибками"
+    
+    text = f"""
+{status_emoji} <b>Полная синхронизация {status_text}</b>
+
+📊 <b>Результат:</b>
+• 🆕 Создано: {stats['created']}
+• 🔄 Обновлено: {stats['updated']}  
+• 🗑️ Деактивировано: {stats.get('deleted', 0)}
+• ❌ Ошибок: {stats['errors']}
+"""
+    
+    if stats.get('deleted', 0) > 0:
+        text += f"""
+
+🗑️ <b>Деактивированные подписки:</b>
+Деактивированы подписки пользователей, которые
+отсутствуют в панели RemnaWave.
+💰 Балансы пользователей сохранены.
+"""
+    
+    if stats['errors'] > 0:
+        text += f"""
+
+⚠️ <b>Внимание:</b>
+Некоторые операции завершились с ошибками.
+Проверьте логи для получения подробной информации.
+"""
+    
+    text += f"""
+
+💡 <b>Рекомендации:</b>
+• Полная синхронизация выполнена
+• Рекомендуется запускать раз в день
+• Все пользователи из панели синхронизированы
+"""
+    
+    keyboard = []
+    
+    if stats['errors'] > 0:
+        keyboard.append([
+            types.InlineKeyboardButton(
+                text="🔄 Повторить синхронизацию", 
+                callback_data="sync_all_users"
+            )
+        ])
+    
+    keyboard.extend([
+        [
+            types.InlineKeyboardButton(text="📊 Статистика системы", callback_data="admin_rw_system"),
+            types.InlineKeyboardButton(text="🌐 Ноды", callback_data="admin_rw_nodes")
+        ],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def show_sync_recommendations(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    await callback.message.edit_text(
+        "🔍 Анализируем состояние синхронизации...",
+        reply_markup=None
+    )
+    
+    remnawave_service = RemnaWaveService()
+    recommendations = await remnawave_service.get_sync_recommendations(db)
+    
+    priority_emoji = {
+        "low": "🟢",
+        "medium": "🟡", 
+        "high": "🔴"
+    }
+    
+    text = f"""
+💡 <b>Рекомендации по синхронизации</b>
+
+{priority_emoji.get(recommendations['priority'], '🟢')} <b>Приоритет:</b> {recommendations['priority'].upper()}
+⏱️ <b>Время выполнения:</b> {recommendations['estimated_time']}
+
+<b>Рекомендуемое действие:</b>
+"""
+    
+    if recommendations['sync_type'] == 'all':
+        text += "🔄 Полная синхронизация"
+    elif recommendations['sync_type'] == 'update_only':
+        text += "📈 Обновление данных"
+    elif recommendations['sync_type'] == 'new_only':
+        text += "🆕 Синхронизация новых"
+    else:
+        text += "✅ Синхронизация не требуется"
+    
+    text += "\n\n<b>Причины:</b>\n"
+    for reason in recommendations['reasons']:
+        text += f"• {reason}\n"
+    
+    keyboard = []
+    
+    if recommendations['should_sync'] and recommendations['sync_type'] != 'none':
+        keyboard.append([
+            types.InlineKeyboardButton(
+                text=f"✅ Выполнить рекомендацию", 
+                callback_data=f"sync_{recommendations['sync_type']}_users" if recommendations['sync_type'] != 'update_only' else "sync_update_data"
+            )
+        ])
+    
+    keyboard.extend([
+        [types.InlineKeyboardButton(text="🔄 Другие опции", callback_data="admin_rw_sync")],
+        [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+    ])
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def validate_subscriptions(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    await callback.message.edit_text(
+        "🔍 Выполняется валидация подписок...\n\nПроверяем данные, может занять несколько минут.",
+        reply_markup=None
+    )
+    
+    remnawave_service = RemnaWaveService()
+    stats = await remnawave_service.validate_and_fix_subscriptions(db)
+    
+    if stats['errors'] == 0:
+        status_emoji = "✅"
+        status_text = "успешно завершена"
+    else:
+        status_emoji = "⚠️"
+        status_text = "завершена с ошибками"
+    
+    text = f"""
+{status_emoji} <b>Валидация {status_text}</b>
+
+📊 <b>Результаты:</b>
+• 🔍 Проверено подписок: {stats['checked']}
+• 🔧 Исправлено подписок: {stats['fixed']}
+• ⚠️ Найдено проблем: {stats['issues_found']}
+• ❌ Ошибок: {stats['errors']}
+"""
+    
+    if stats['fixed'] > 0:
+        text += "\n✅ <b>Исправленные проблемы:</b>\n"
+        text += "• Статусы просроченных подписок\n"
+        text += "• Отсутствующие данные RemnaWave\n" 
+        text += "• Некорректные лимиты трафика\n"
+        text += "• Настройки устройств\n"
+    
+    if stats['errors'] > 0:
+        text += f"\n⚠️ Обнаружены ошибки при обработке.\nПроверьте логи для подробной информации."
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="🔄 Повторить валидацию", callback_data="sync_validate")],
+        [types.InlineKeyboardButton(text="🔄 Полная синхронизация", callback_data="sync_all_users")],
+        [types.InlineKeyboardButton(text="⬅️ К синхронизации", callback_data="admin_rw_sync")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def cleanup_subscriptions(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    await callback.message.edit_text(
+        "🧹 Выполняется очистка неактуальных подписок...\n\nУдаляем подписки пользователей, отсутствующих в панели.",
+        reply_markup=None
+    )
+    
+    remnawave_service = RemnaWaveService()
+    stats = await remnawave_service.cleanup_orphaned_subscriptions(db)
+    
+    if stats['errors'] == 0:
+        status_emoji = "✅"
+        status_text = "успешно завершена"
+    else:
+        status_emoji = "⚠️"
+        status_text = "завершена с ошибками"
+    
+    text = f"""
+{status_emoji} <b>Очистка {status_text}</b>
+
+📊 <b>Результаты:</b>
+• 🔍 Проверено подписок: {stats['checked']}
+• 🗑️ Деактивировано: {stats['deactivated']}
+• ❌ Ошибок: {stats['errors']}
+"""
+    
+    if stats['deactivated'] > 0:
+        text += f"\n🗑️ <b>Деактивированные подписки:</b>\n"
+        text += f"Отключены подписки пользователей, которые\n"
+        text += f"отсутствуют в панели RemnaWave.\n"
+    else:
+        text += f"\n✅ Все подписки актуальны!\nНеактуальных подписок не найдено."
+    
+    if stats['errors'] > 0:
+        text += f"\n⚠️ Обнаружены ошибки при обработке.\nПроверьте логи для подробной информации."
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="🔄 Повторить очистку", callback_data="sync_cleanup")],
+        [types.InlineKeyboardButton(text="🔍 Валидация", callback_data="sync_validate")],
+        [types.InlineKeyboardButton(text="⬅️ К синхронизации", callback_data="admin_rw_sync")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+@admin_required
+@error_handler
+async def force_cleanup_all_orphaned_users(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    await callback.message.edit_text(
+        "🗑️ Выполняется принудительная очистка всех пользователей, отсутствующих в панели...\n\n"
+        "⚠️ ВНИМАНИЕ: Это полностью удалит ВСЕ данные пользователей!\n"
+        "📊 Включая: транзакции, реферальные доходы, промокоды, серверы, балансы\n\n"
+        "⏳ Пожалуйста, подождите...",
+        reply_markup=None
+    )
+    
+    remnawave_service = RemnaWaveService()
+    stats = await remnawave_service.cleanup_orphaned_subscriptions(db)
+    
+    if stats['errors'] == 0:
+        status_emoji = "✅"
+        status_text = "успешно завершена"
+    else:
+        status_emoji = "⚠️"
+        status_text = "завершена с ошибками"
+    
+    text = f"""
+{status_emoji} <b>Принудительная очистка {status_text}</b>
+
+📊 <b>Результаты:</b>
+• 🔍 Проверено подписок: {stats['checked']}
+• 🗑️ Полностью очищено: {stats['deactivated']}
+• ❌ Ошибок: {stats['errors']}
+"""
+    
+    if stats['deactivated'] > 0:
+        text += f"""
+
+🗑️ <b>Полностью очищенные данные:</b>
+• Подписки сброшены к начальному состоянию
+• Удалены ВСЕ транзакции пользователей
+• Удалены ВСЕ реферальные доходы  
+• Удалены использования промокодов
+• Сброшены балансы к нулю
+• Удалены подключенные серверы
+• Сброшены HWID устройства в RemnaWave
+• Очищены RemnaWave UUID
+"""
+    else:
+        text += f"\n✅ Неактуальных подписок не найдено!\nВсе пользователи синхронизированы с панелью."
+    
+    if stats['errors'] > 0:
+        text += f"\n⚠️ Обнаружены ошибки при обработке.\nПроверьте логи для подробной информации."
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="🔄 Повторить очистку", callback_data="force_cleanup_orphaned")],
+        [types.InlineKeyboardButton(text="🔄 Полная синхронизация", callback_data="sync_all_users")],
+        [types.InlineKeyboardButton(text="⬅️ К синхронизации", callback_data="admin_rw_sync")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def confirm_force_cleanup(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    
+    text = """
+⚠️ <b>ВНИМАНИЕ! ОПАСНАЯ ОПЕРАЦИЯ!</b>
+
+🗑️ <b>Принудительная очистка полностью удалит:</b>
+• ВСЕ транзакции пользователей отсутствующих в панели
+• ВСЕ реферальные доходы и связи
+• ВСЕ использования промокодов
+• ВСЕ подключенные серверы подписок
+• ВСЕ балансы (сброс к нулю)
+• ВСЕ HWID устройства в RemnaWave
+• ВСЕ RemnaWave UUID и ссылки
+
+⚡ <b>Это действие НЕОБРАТИМО!</b>
+
+Используйте только если:
+• Обычная синхронизация не помогает
+• Нужно полностью очистить "мусорные" данные
+• После массового удаления пользователей из панели
+
+❓ <b>Вы действительно хотите продолжить?</b>
+"""
+    
+    keyboard = [
+        [types.InlineKeyboardButton(text="🗑️ ДА, ОЧИСТИТЬ ВСЕ", callback_data="force_cleanup_orphaned")],
+        [types.InlineKeyboardButton(text="❌ Отмена", callback_data="admin_rw_sync")]
+    ]
+    
+    await callback.message.edit_text(
+        text,
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+    )
+    await callback.answer()
 
 
 @admin_required
@@ -1347,37 +1737,124 @@ async def sync_users(
 ):
    sync_type = callback.data.split('_')[-2] + "_" + callback.data.split('_')[-1]
    
+   progress_text = "🔄 Выполняется синхронизация...\n\n"
+   
+   if sync_type == "all_users":
+       progress_text += "📋 Тип: Полная синхронизация\n"
+       progress_text += "• Создание новых пользователей\n"
+       progress_text += "• Обновление существующих\n"
+       progress_text += "• Удаление неактуальных подписок\n"
+   elif sync_type == "new_users":
+       progress_text += "📋 Тип: Только новые пользователи\n"
+       progress_text += "• Создание пользователей из панели\n"
+   elif sync_type == "update_data":
+       progress_text += "📋 Тип: Обновление данных\n"
+       progress_text += "• Обновление информации о трафике\n"
+       progress_text += "• Синхронизация подписок\n"
+   
+   progress_text += "\n⏳ Пожалуйста, подождите..."
+   
    await callback.message.edit_text(
-       "🔄 Выполняется синхронизация...\n\nПожалуйста, подождите.",
+       progress_text,
        reply_markup=None
    )
    
    remnawave_service = RemnaWaveService()
    
-   if sync_type in ["all_users", "new_users", "update_data"]:
-       sync_map = {
-           "all_users": "all",
-           "new_users": "new_only", 
-           "update_data": "update_only"
-       }
-       stats = await remnawave_service.sync_users_from_panel(db, sync_map[sync_type])
+   sync_map = {
+       "all_users": "all",
+       "new_users": "new_only", 
+       "update_data": "update_only"
+   }
+   
+   stats = await remnawave_service.sync_users_from_panel(db, sync_map.get(sync_type, "all"))
+   
+   total_operations = stats['created'] + stats['updated'] + stats.get('deleted', 0)
+   success_operations = stats['created'] + stats['updated'] + stats.get('deleted', 0)
+   
+   if stats['errors'] == 0:
+       status_emoji = "✅"
+       status_text = "успешно завершена"
+   elif stats['errors'] < total_operations:
+       status_emoji = "⚠️"
+       status_text = "завершена с предупреждениями"
    else:
-       stats = {"created": 0, "updated": 0, "errors": 0}
+       status_emoji = "❌"
+       status_text = "завершена с ошибками"
    
    text = f"""
-✅ <b>Синхронизация завершена</b>
+{status_emoji} <b>Синхронизация {status_text}</b>
 
 📊 <b>Результат:</b>
-- Создано: {stats['created']}
-- Обновлено: {stats['updated']}
-- Ошибок: {stats['errors']}
 """
    
+   if sync_type == "all_users":
+       text += f"• 🆕 Создано: {stats['created']}\n"
+       text += f"• 🔄 Обновлено: {stats['updated']}\n"
+       if 'deleted' in stats:
+           text += f"• 🗑️ Удалено: {stats['deleted']}\n"
+       text += f"• ❌ Ошибок: {stats['errors']}\n"
+   elif sync_type == "new_users":
+       text += f"• 🆕 Создано: {stats['created']}\n"
+       text += f"• ❌ Ошибок: {stats['errors']}\n"
+       if stats['created'] == 0 and stats['errors'] == 0:
+           text += "\n💡 Новых пользователей не найдено"
+   elif sync_type == "update_data":
+       text += f"• 🔄 Обновлено: {stats['updated']}\n"
+       text += f"• ❌ Ошибок: {stats['errors']}\n"
+       if stats['updated'] == 0 and stats['errors'] == 0:
+           text += "\n💡 Все данные актуальны"
+   
+   if stats['errors'] > 0:
+       text += f"\n⚠️ <b>Внимание:</b>\n"
+       text += f"Некоторые операции завершились с ошибками.\n"
+       text += f"Проверьте логи для получения подробной информации."
+   
+   if sync_type == "all_users" and 'deleted' in stats and stats['deleted'] > 0:
+       text += f"\n🗑️ <b>Удаленные подписки:</b>\n"
+       text += f"Деактивированы подписки пользователей,\n"
+       text += f"которые отсутствуют в панели RemnaWave."
+   
+   text += f"\n\n💡 <b>Рекомендации:</b>\n"
+   if sync_type == "all_users":
+       text += "• Полная синхронизация выполнена\n"
+       text += "• Рекомендуется запускать раз в день\n"
+   elif sync_type == "new_users":
+       text += "• Синхронизация новых пользователей\n"
+       text += "• Используйте при массовом добавлении\n"
+   elif sync_type == "update_data":
+       text += "• Обновление данных о трафике\n"
+       text += "• Запускайте для актуализации статистики\n"
+   
+   keyboard = []
+   
+   if stats['errors'] > 0:
+       keyboard.append([
+           types.InlineKeyboardButton(
+               text="🔄 Повторить синхронизацию", 
+               callback_data=callback.data
+           )
+       ])
+   
+   if sync_type != "all_users":
+       keyboard.append([
+           types.InlineKeyboardButton(
+               text="🔄 Полная синхронизация", 
+               callback_data="sync_all_users"
+           )
+       ])
+   
+   keyboard.extend([
+       [
+           types.InlineKeyboardButton(text="📊 Статистика системы", callback_data="admin_rw_system"),
+           types.InlineKeyboardButton(text="🌐 Ноды", callback_data="admin_rw_nodes")
+       ],
+       [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+   ])
+   
    await callback.message.edit_text(
        text,
-       reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
-           [types.InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
-       ])
+       reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
    )
    await callback.answer()
 
@@ -1434,34 +1911,22 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(manage_node, F.data.startswith("node_restart_"))
     dp.callback_query.register(restart_all_nodes, F.data == "admin_restart_all_nodes")
     dp.callback_query.register(show_sync_options, F.data == "admin_rw_sync")
-    dp.callback_query.register(sync_users, F.data.startswith("sync_"))
+    dp.callback_query.register(sync_all_users, F.data == "sync_all_users")
     dp.callback_query.register(show_squads_management, F.data == "admin_rw_squads")
-    
     dp.callback_query.register(show_squad_details, F.data.startswith("admin_squad_manage_"))
-    
     dp.callback_query.register(manage_squad_action, F.data.startswith("squad_add_users_"))
     dp.callback_query.register(manage_squad_action, F.data.startswith("squad_remove_users_"))
     dp.callback_query.register(manage_squad_action, F.data.startswith("squad_delete_"))
-    
     dp.callback_query.register(show_squad_edit_menu, F.data.startswith("squad_edit_") & ~F.data.startswith("squad_edit_inbounds_"))
-    
     dp.callback_query.register(show_squad_inbounds_selection, F.data.startswith("squad_edit_inbounds_"))
     dp.callback_query.register(show_squad_rename_form, F.data.startswith("squad_rename_"))
-    
     dp.callback_query.register(cancel_squad_rename, F.data.startswith("cancel_rename_"))
-    
     dp.callback_query.register(toggle_squad_inbound, F.data.startswith("sqd_tgl_"))
     dp.callback_query.register(save_squad_inbounds, F.data.startswith("sqd_save_"))
-    
     dp.callback_query.register(show_squad_edit_menu_short, F.data.startswith("sqd_edit_"))
-    
-    
     dp.callback_query.register(start_squad_creation, F.data == "admin_squad_create")
-    
     dp.callback_query.register(cancel_squad_creation, F.data == "cancel_squad_create")
-    
     dp.callback_query.register(toggle_create_inbound, F.data.startswith("create_tgl_"))
-    
     dp.callback_query.register(finish_squad_creation, F.data == "create_squad_finish")
     
     dp.message.register(
@@ -1474,4 +1939,4 @@ def register_handlers(dp: Dispatcher):
         process_squad_name,
         SquadCreateStates.waiting_for_name,
         F.text
-    )
+    )

app/handlers/admin/users.py

@@ -274,7 +274,7 @@ async def show_user_subscription(
         text += f"<b>Окончание:</b> {format_datetime(subscription.end_date)}\n"
         text += f"<b>Трафик:</b> {subscription.traffic_used_gb:.1f}/{subscription.traffic_limit_gb} ГБ\n"
         text += f"<b>Устройства:</b> {subscription.device_limit}\n"
-        text += f"<b>Подключенных устройств:</b> {len(subscription.connected_devices) if subscription.connected_devices else 0}\n"
+        text += f"<b>Подключенных устройств:</b> {subscription.device_limit}\n"
         
         if subscription.is_active:
             days_left = (subscription.end_date - datetime.utcnow()).days
@@ -521,7 +521,14 @@ async def show_user_management(
     user = profile["user"]
     subscription = profile["subscription"]
     
-    status_text = "✅ Активен" if user.status == UserStatus.ACTIVE.value else "❌ Заблокирован"
+    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>
@@ -558,7 +565,7 @@ async def show_user_management(
     
     await callback.message.edit_text(
         text,
-        reply_markup=get_user_management_keyboard(user.id, db_user.language)
+        reply_markup=get_user_management_keyboard(user.id, user.status, db_user.language)
     )
     await callback.answer()
 
@@ -746,6 +753,712 @@ async def show_inactive_users(
     )
     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 extend_user_subscription(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    await state.update_data(extending_user_id=user_id)
+    
+    await callback.message.edit_text(
+        "⏰ <b>Продление подписки</b>\n\n"
+        "Введите количество дней для продления:\n"
+        "• Например: 30, 7, 90\n"
+        "• Максимум: 365 дней\n\n"
+        "Или нажмите /cancel для отмены",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [
+                types.InlineKeyboardButton(text="7 дней", callback_data=f"admin_sub_extend_days_{user_id}_7"),
+                types.InlineKeyboardButton(text="30 дней", callback_data=f"admin_sub_extend_days_{user_id}_30")
+            ],
+            [
+                types.InlineKeyboardButton(text="90 дней", callback_data=f"admin_sub_extend_days_{user_id}_90"),
+                types.InlineKeyboardButton(text="180 дней", callback_data=f"admin_sub_extend_days_{user_id}_180")
+            ],
+            [
+                types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
+            ]
+        ])
+    )
+    
+    await state.set_state(AdminStates.extending_subscription)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_subscription_extension_days(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    parts = callback.data.split('_')
+    user_id = int(parts[-2])
+    days = int(parts[-1])
+    
+    success = await _extend_subscription_by_days(db, user_id, days, db_user.id)
+    
+    if success:
+        await callback.message.edit_text(
+            f"✅ Подписка пользователя продлена на {days} дней",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка продления подписки",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_subscription_extension_text(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    user_id = data.get("extending_user_id")
+    
+    if not user_id:
+        await message.answer("❌ Ошибка: пользователь не найден")
+        await state.clear()
+        return
+    
+    try:
+        days = int(message.text.strip())
+        
+        if days <= 0 or days > 365:
+            await message.answer("❌ Количество дней должно быть от 1 до 365")
+            return
+        
+        success = await _extend_subscription_by_days(db, user_id, days, db_user.id)
+        
+        if success:
+            await message.answer(
+                f"✅ Подписка пользователя продлена на {days} дней",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+                ])
+            )
+        else:
+            await message.answer("❌ Ошибка продления подписки")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число дней")
+        return
+    
+    await state.clear()
+
+
+@admin_required
+@error_handler
+async def add_subscription_traffic(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    await state.update_data(traffic_user_id=user_id)
+    
+    await callback.message.edit_text(
+        "📊 <b>Добавление трафика</b>\n\n"
+        "Введите количество ГБ для добавления:\n"
+        "• Например: 50, 100, 500\n"
+        "• Максимум: 10000 ГБ\n\n"
+        "Или нажмите /cancel для отмены",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [
+                types.InlineKeyboardButton(text="50 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_50"),
+                types.InlineKeyboardButton(text="100 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_100")
+            ],
+            [
+                types.InlineKeyboardButton(text="500 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_500"),
+                types.InlineKeyboardButton(text="1000 ГБ", callback_data=f"admin_sub_traffic_add_{user_id}_1000")
+            ],
+            [
+                types.InlineKeyboardButton(text="♾️ Безлимит", callback_data=f"admin_sub_traffic_add_{user_id}_0"),
+            ],
+            [
+                types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
+            ]
+        ])
+    )
+    
+    await state.set_state(AdminStates.adding_traffic)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_traffic_addition_button(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    parts = callback.data.split('_')
+    user_id = int(parts[-2])
+    gb = int(parts[-1])
+    
+    success = await _add_subscription_traffic(db, user_id, gb, db_user.id)
+    
+    if success:
+        traffic_text = "♾️ безлимитный" if gb == 0 else f"{gb} ГБ"
+        await callback.message.edit_text(
+            f"✅ К подписке пользователя добавлен трафик: {traffic_text}",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка добавления трафика",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_traffic_addition_text(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    user_id = data.get("traffic_user_id")
+    
+    if not user_id:
+        await message.answer("❌ Ошибка: пользователь не найден")
+        await state.clear()
+        return
+    
+    try:
+        gb = int(message.text.strip())
+        
+        if gb < 0 or gb > 10000:
+            await message.answer("❌ Количество ГБ должно быть от 0 до 10000 (0 = безлимит)")
+            return
+        
+        success = await _add_subscription_traffic(db, user_id, gb, db_user.id)
+        
+        if success:
+            traffic_text = "♾️ безлимитный" if gb == 0 else f"{gb} ГБ"
+            await message.answer(
+                f"✅ К подписке пользователя добавлен трафик: {traffic_text}",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+                ])
+            )
+        else:
+            await message.answer("❌ Ошибка добавления трафика")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число ГБ")
+        return
+    
+    await state.clear()
+
+
+@admin_required
+@error_handler
+async def deactivate_user_subscription(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    await callback.message.edit_text(
+        "🚫 <b>Деактивация подписки</b>\n\n"
+        "Вы уверены, что хотите деактивировать подписку этого пользователя?\n"
+        "Пользователь потеряет доступ к сервису.",
+        reply_markup=get_confirmation_keyboard(
+            f"admin_sub_deactivate_confirm_{user_id}",
+            f"admin_user_subscription_{user_id}",
+            db_user.language
+        )
+    )
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def confirm_subscription_deactivation(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    success = await _deactivate_user_subscription(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_subscription_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка деактивации подписки",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def activate_user_subscription(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    success = await _activate_user_subscription(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_subscription_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка активации подписки",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def grant_trial_subscription(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    success = await _grant_trial_subscription(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_subscription_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка выдачи триального периода",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def grant_paid_subscription(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    user_id = int(callback.data.split('_')[-1])
+    
+    await state.update_data(granting_user_id=user_id)
+    
+    await callback.message.edit_text(
+        "💎 <b>Выдача подписки</b>\n\n"
+        "Введите количество дней подписки:\n"
+        "• Например: 30, 90, 180, 365\n"
+        "• Максимум: 730 дней\n\n"
+        "Или нажмите /cancel для отмены",
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+            [
+                types.InlineKeyboardButton(text="30 дней", callback_data=f"admin_sub_grant_days_{user_id}_30"),
+                types.InlineKeyboardButton(text="90 дней", callback_data=f"admin_sub_grant_days_{user_id}_90")
+            ],
+            [
+                types.InlineKeyboardButton(text="180 дней", callback_data=f"admin_sub_grant_days_{user_id}_180"),
+                types.InlineKeyboardButton(text="365 дней", callback_data=f"admin_sub_grant_days_{user_id}_365")
+            ],
+            [
+                types.InlineKeyboardButton(text="❌ Отмена", callback_data=f"admin_user_subscription_{user_id}")
+            ]
+        ])
+    )
+    
+    await state.set_state(AdminStates.granting_subscription)
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_subscription_grant_days(
+    callback: types.CallbackQuery,
+    db_user: User,
+    db: AsyncSession
+):
+    parts = callback.data.split('_')
+    user_id = int(parts[-2])
+    days = int(parts[-1])
+    
+    success = await _grant_paid_subscription(db, user_id, days, db_user.id)
+    
+    if success:
+        await callback.message.edit_text(
+            f"✅ Пользователю выдана подписка на {days} дней",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    else:
+        await callback.message.edit_text(
+            "❌ Ошибка выдачи подписки",
+            reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+            ])
+        )
+    
+    await callback.answer()
+
+
+@admin_required
+@error_handler
+async def process_subscription_grant_text(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext,
+    db: AsyncSession
+):
+    data = await state.get_data()
+    user_id = data.get("granting_user_id")
+    
+    if not user_id:
+        await message.answer("❌ Ошибка: пользователь не найден")
+        await state.clear()
+        return
+    
+    try:
+        days = int(message.text.strip())
+        
+        if days <= 0 or days > 730:
+            await message.answer("❌ Количество дней должно быть от 1 до 730")
+            return
+        
+        success = await _grant_paid_subscription(db, user_id, days, db_user.id)
+        
+        if success:
+            await message.answer(
+                f"✅ Пользователю выдана подписка на {days} дней",
+                reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
+                    [types.InlineKeyboardButton(text="📱 К подписке", callback_data=f"admin_user_subscription_{user_id}")]
+                ])
+            )
+        else:
+            await message.answer("❌ Ошибка выдачи подписки")
+        
+    except ValueError:
+        await message.answer("❌ Введите корректное число дней")
+        return
+    
+    await state.clear()
+
+
+async def _extend_subscription_by_days(db: AsyncSession, user_id: int, days: int, admin_id: int) -> bool:
+    try:
+        from app.database.crud.subscription import get_subscription_by_user_id, extend_subscription
+        from app.services.subscription_service import SubscriptionService
+        
+        subscription = await get_subscription_by_user_id(db, user_id)
+        if not subscription:
+            logger.error(f"Подписка не найдена для пользователя {user_id}")
+            return False
+        
+        await extend_subscription(db, subscription, days)
+        
+        subscription_service = SubscriptionService()
+        await subscription_service.update_remnawave_user(db, subscription)
+        
+        logger.info(f"Админ {admin_id} продлил подписку пользователя {user_id} на {days} дней")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка продления подписки: {e}")
+        return False
+
+
+async def _add_subscription_traffic(db: AsyncSession, user_id: int, gb: int, admin_id: int) -> bool:
+    try:
+        from app.database.crud.subscription import get_subscription_by_user_id, add_subscription_traffic
+        from app.services.subscription_service import SubscriptionService
+        
+        subscription = await get_subscription_by_user_id(db, user_id)
+        if not subscription:
+            logger.error(f"Подписка не найдена для пользователя {user_id}")
+            return False
+        
+        if gb == 0:  
+            subscription.traffic_limit_gb = 0
+            await db.commit()
+        else:
+            await add_subscription_traffic(db, subscription, gb)
+        
+        subscription_service = SubscriptionService()
+        await subscription_service.update_remnawave_user(db, subscription)
+        
+        traffic_text = "безлимитный" if gb == 0 else f"{gb} ГБ"
+        logger.info(f"Админ {admin_id} добавил трафик {traffic_text} пользователю {user_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка добавления трафика: {e}")
+        return False
+
+
+async def _deactivate_user_subscription(db: AsyncSession, user_id: int, admin_id: int) -> bool:
+    try:
+        from app.database.crud.subscription import get_subscription_by_user_id, deactivate_subscription
+        from app.services.subscription_service import SubscriptionService
+        
+        subscription = await get_subscription_by_user_id(db, user_id)
+        if not subscription:
+            logger.error(f"Подписка не найдена для пользователя {user_id}")
+            return False
+        
+        await deactivate_subscription(db, subscription)
+        
+        user = await get_user_by_id(db, user_id)
+        if user and user.remnawave_uuid:
+            subscription_service = SubscriptionService()
+            await subscription_service.disable_remnawave_user(user.remnawave_uuid)
+        
+        logger.info(f"Админ {admin_id} деактивировал подписку пользователя {user_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка деактивации подписки: {e}")
+        return False
+
+
+async def _activate_user_subscription(db: AsyncSession, user_id: int, admin_id: int) -> bool:
+    try:
+        from app.database.crud.subscription import get_subscription_by_user_id
+        from app.services.subscription_service import SubscriptionService
+        from app.database.models import SubscriptionStatus
+        from datetime import datetime
+        
+        subscription = await get_subscription_by_user_id(db, user_id)
+        if not subscription:
+            logger.error(f"Подписка не найдена для пользователя {user_id}")
+            return False
+        
+        subscription.status = SubscriptionStatus.ACTIVE.value
+        if subscription.end_date <= datetime.utcnow():
+            subscription.end_date = datetime.utcnow() + timedelta(days=1)
+        
+        await db.commit()
+        await db.refresh(subscription)
+        
+        subscription_service = SubscriptionService()
+        await subscription_service.update_remnawave_user(db, subscription)
+        
+        logger.info(f"Админ {admin_id} активировал подписку пользователя {user_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка активации подписки: {e}")
+        return False
+
+
+async def _grant_trial_subscription(db: AsyncSession, user_id: int, admin_id: int) -> bool:
+    try:
+        from app.database.crud.subscription import get_subscription_by_user_id, create_trial_subscription
+        from app.services.subscription_service import SubscriptionService
+        
+        existing_subscription = await get_subscription_by_user_id(db, user_id)
+        if existing_subscription:
+            logger.error(f"У пользователя {user_id} уже есть подписка")
+            return False
+        
+        subscription = await create_trial_subscription(db, user_id)
+        
+        subscription_service = SubscriptionService()
+        await subscription_service.create_remnawave_user(db, subscription)
+        
+        logger.info(f"Админ {admin_id} выдал триальную подписку пользователю {user_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка выдачи триальной подписки: {e}")
+        return False
+
+
+async def _grant_paid_subscription(db: AsyncSession, user_id: int, days: int, admin_id: int) -> bool:
+    try:
+        from app.database.crud.subscription import get_subscription_by_user_id, create_paid_subscription
+        from app.services.subscription_service import SubscriptionService
+        from app.config import settings
+        
+        existing_subscription = await get_subscription_by_user_id(db, user_id)
+        if existing_subscription:
+            logger.error(f"У пользователя {user_id} уже есть подписка")
+            return False
+        
+        subscription = await create_paid_subscription(
+            db=db,
+            user_id=user_id,
+            duration_days=days,
+            traffic_limit_gb=settings.DEFAULT_TRAFFIC_LIMIT_GB,
+            device_limit=settings.DEFAULT_DEVICE_LIMIT,
+            connected_squads=[settings.TRIAL_SQUAD_UUID] if settings.TRIAL_SQUAD_UUID else []
+        )
+        
+        subscription_service = SubscriptionService()
+        await subscription_service.create_remnawave_user(db, subscription)
+        
+        logger.info(f"Админ {admin_id} выдал платную подписку на {days} дней пользователю {user_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Ошибка выдачи платной подписки: {e}")
+        return False
 
 @admin_required
 @error_handler
@@ -787,23 +1500,48 @@ def register_handlers(dp: Dispatcher):
     
     dp.callback_query.register(
         show_user_subscription,
-        F.data.startswith("admin_user_sub_")
+        F.data.startswith("admin_user_subscription_")
     )
-    
+
     dp.callback_query.register(
         show_user_transactions,
-        F.data.startswith("admin_user_trans_")
+        F.data.startswith("admin_user_transactions_")
     )
-    
+
     dp.callback_query.register(
-        confirm_user_delete,
-        F.data.startswith("admin_user_delete_")
+        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_") & ~F.data.contains("confirm")
+    )
+
+    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_") & ~F.data.contains("confirm")
+    )
     
     dp.callback_query.register(
         handle_users_list_pagination_fixed,
@@ -835,16 +1573,6 @@ def register_handlers(dp: Dispatcher):
         AdminStates.editing_user_balance
     )
     
-    dp.callback_query.register(
-        confirm_user_block,
-        F.data.startswith("admin_user_block_")
-    )
-    
-    dp.callback_query.register(
-        block_user,
-        F.data.startswith("admin_user_block_confirm_")
-    )
-    
     dp.callback_query.register(
         show_inactive_users,
         F.data == "admin_users_inactive"
@@ -853,4 +1581,70 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(
         cleanup_inactive_users,
         F.data == "admin_cleanup_inactive"
-    )
+    )
+
+    
+    dp.callback_query.register(
+        extend_user_subscription,
+        F.data.startswith("admin_sub_extend_") & ~F.data.contains("days") & ~F.data.contains("confirm")
+    )
+    
+    dp.callback_query.register(
+        process_subscription_extension_days,
+        F.data.startswith("admin_sub_extend_days_")
+    )
+    
+    dp.message.register(
+        process_subscription_extension_text,
+        AdminStates.extending_subscription
+    )
+    
+    dp.callback_query.register(
+        add_subscription_traffic,
+        F.data.startswith("admin_sub_traffic_") & ~F.data.contains("add")
+    )
+    
+    dp.callback_query.register(
+        process_traffic_addition_button,
+        F.data.startswith("admin_sub_traffic_add_")
+    )
+    
+    dp.message.register(
+        process_traffic_addition_text,
+        AdminStates.adding_traffic
+    )
+    
+    dp.callback_query.register(
+        deactivate_user_subscription,
+        F.data.startswith("admin_sub_deactivate_") & ~F.data.contains("confirm")
+    )
+    
+    dp.callback_query.register(
+        confirm_subscription_deactivation,
+        F.data.startswith("admin_sub_deactivate_confirm_")
+    )
+    
+    dp.callback_query.register(
+        activate_user_subscription,
+        F.data.startswith("admin_sub_activate_")
+    )
+    
+    dp.callback_query.register(
+        grant_trial_subscription,
+        F.data.startswith("admin_sub_grant_trial_")
+    )
+    
+    dp.callback_query.register(
+        grant_paid_subscription,
+        F.data.startswith("admin_sub_grant_") & ~F.data.contains("trial") & ~F.data.contains("days")
+    )
+    
+    dp.callback_query.register(
+        process_subscription_grant_days,
+        F.data.startswith("admin_sub_grant_days_")
+    )
+    
+    dp.message.register(
+        process_subscription_grant_text,
+        AdminStates.granting_subscription
+    )

app/handlers/balance.py

@@ -55,15 +55,46 @@ async def show_balance_history(
     
     offset = (page - 1) * TRANSACTIONS_PER_PAGE
     
-    transactions = await get_user_transactions(
+    raw_transactions = await get_user_transactions(
         db, db_user.id, 
-        limit=TRANSACTIONS_PER_PAGE,
+        limit=TRANSACTIONS_PER_PAGE * 3, 
         offset=offset
     )
     
-    total_count = await get_user_transactions_count(db, db_user.id)
+    seen_transactions = set()
+    unique_transactions = []
     
-    if not transactions:
+    for transaction in raw_transactions:
+        rounded_time = transaction.created_at.replace(second=0, microsecond=0)
+        transaction_key = (
+            transaction.amount_kopeks,
+            transaction.description,
+            rounded_time
+        )
+        
+        if transaction_key not in seen_transactions:
+            seen_transactions.add(transaction_key)
+            unique_transactions.append(transaction)
+            
+            if len(unique_transactions) >= TRANSACTIONS_PER_PAGE:
+                break
+    
+    all_transactions = await get_user_transactions(db, db_user.id, limit=1000)
+    seen_all = set()
+    total_unique = 0
+    
+    for transaction in all_transactions:
+        rounded_time = transaction.created_at.replace(second=0, microsecond=0)
+        transaction_key = (
+            transaction.amount_kopeks,
+            transaction.description,
+            rounded_time
+        )
+        if transaction_key not in seen_all:
+            seen_all.add(transaction_key)
+            total_unique += 1
+    
+    if not unique_transactions:
         await callback.message.edit_text(
             "📊 История операций пуста",
             reply_markup=get_back_keyboard(db_user.language)
@@ -73,7 +104,7 @@ async def show_balance_history(
     
     text = "📊 <b>История операций</b>\n\n"
     
-    for transaction in transactions:
+    for transaction in unique_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)}"
         
@@ -82,7 +113,7 @@ async def show_balance_history(
         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
+    total_pages = (total_unique + TRANSACTIONS_PER_PAGE - 1) // TRANSACTIONS_PER_PAGE
     
     if total_pages > 1:
         pagination_row = get_pagination_keyboard(
@@ -96,7 +127,8 @@ async def show_balance_history(
     
     await callback.message.edit_text(
         text,
-        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard)
+        reply_markup=types.InlineKeyboardMarkup(inline_keyboard=keyboard),
+        parse_mode="HTML"
     )
     await callback.answer()
 
@@ -112,16 +144,43 @@ async def handle_balance_history_pagination(
 
 
 @error_handler
-async def start_balance_topup(
+async def show_payment_methods(
+    callback: types.CallbackQuery,
+    db_user: User,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    payment_text = """
+💳 <b>Способы пополнения баланса</b>
+
+Выберите удобный для вас способ оплаты:
+
+⭐ <b>Telegram Stars</b> - быстро и удобно
+💳 <b>Банковская карта</b> - через YooKassa/Tribute
+🛠️ <b>Через поддержку</b> - другие способы
+
+Выберите способ пополнения:
+"""
+    
+    await callback.message.edit_text(
+        payment_text,
+        reply_markup=get_payment_methods_keyboard(0, db_user.language), 
+        parse_mode="HTML"
+    )
+    await callback.answer()
+
+
+@error_handler
+async def start_stars_payment(
     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)
+        await callback.answer("❌ Пополнение через Stars временно недоступно", show_alert=True)
         return
     
     await callback.message.edit_text(
@@ -130,96 +189,39 @@ async def start_balance_topup(
     )
     
     await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(payment_method="stars")
     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(
+async def start_yookassa_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)
+    if not settings.is_yookassa_enabled():
+        await callback.answer("❌ Оплата картой через YooKassa временно недоступна", 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.message.edit_text(
+        "💳 <b>Оплата банковской картой</b>\n\n"
+        "Введите сумму для пополнения от 100 до 50,000 рублей:",
+        reply_markup=get_back_keyboard(db_user.language),
+        parse_mode="HTML"
+    )
     
+    await state.set_state(BalanceStates.waiting_for_amount)
+    await state.update_data(payment_method="yookassa")
     await callback.answer()
 
 
-@error_handler  
-async def process_tribute_quick_payment(
+@error_handler
+async def start_tribute_payment(
     callback: types.CallbackQuery,
     db_user: User
 ):
-    """Быстрое пополнение через Tribute - без выбора суммы"""
     texts = get_texts(db_user.language)
     
     if not settings.TRIBUTE_ENABLED:
@@ -242,17 +244,19 @@ async def process_tribute_quick_payment(
         
         keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
             [types.InlineKeyboardButton(text="💳 Перейти к оплате", url=payment_url)],
-            [types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")]
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
         ])
         
         await callback.message.edit_text(
             f"💳 <b>Пополнение банковской картой</b>\n\n"
-            f"• Введите любую сумму от 50 ₽\n"
+            f"• Введите любую сумму от 100₽\n"
             f"• Безопасная оплата через Tribute\n"
             f"• Мгновенное зачисление на баланс\n"
             f"• Принимаем карты Visa, MasterCard, МИР\n\n"
+            f"• 🚨 НЕ ОТПРАВЛЯТЬ ПЛАТЕЖ АНОНИМНО!\n\n"
             f"Нажмите кнопку для перехода к оплате:",
-            reply_markup=keyboard
+            reply_markup=keyboard,
+            parse_mode="HTML"
         )
         
     except Exception as e:
@@ -281,6 +285,11 @@ async def request_support_topup(
 • Способ оплаты
 
 ⏰ Время обработки: 1-24 часа
+
+<b>Доступные способы:</b>
+• Криптовалюта
+• Переводы между банками
+• Другие платежные системы
 """
     
     keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
@@ -288,16 +297,229 @@ async def request_support_topup(
             text="💬 Написать в поддержку", 
             url=f"https://t.me/{settings.SUPPORT_USERNAME.lstrip('@')}"
         )],
-        [types.InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")]
+        [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
     ])
     
     await callback.message.edit_text(
         support_text,
-        reply_markup=keyboard
+        reply_markup=keyboard,
+        parse_mode="HTML"
     )
     await callback.answer()
 
 
+@error_handler
+async def process_topup_amount(
+    message: types.Message,
+    db_user: User,
+    state: FSMContext
+):
+    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)
+        data = await state.get_data()
+        payment_method = data.get("payment_method", "stars")
+        
+        if payment_method == "stars":
+            await process_stars_payment_amount(message, db_user, amount_kopeks, state)
+        elif payment_method == "yookassa":
+            from app.database.database import AsyncSessionLocal
+            async with AsyncSessionLocal() as db:
+                await process_yookassa_payment_amount(message, db_user, db, amount_kopeks, state)
+        else:
+            await message.answer("Неизвестный способ оплаты")
+        
+    except ValueError:
+        await message.answer(
+            texts.INVALID_AMOUNT,
+            reply_markup=get_back_keyboard(db_user.language)
+        )
+
+@error_handler
+async def process_stars_payment_amount(
+    message: types.Message,
+    db_user: User,
+    amount_kopeks: int,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.TELEGRAM_STARS_ENABLED:
+        await message.answer("❌ Оплата Stars временно недоступна")
+        return
+    
+    try:
+        payment_service = PaymentService(message.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 message.answer(
+            f"⭐ <b>Оплата через Telegram Stars</b>\n\n"
+            f"Сумма: {texts.format_price(amount_kopeks)}\n\n"
+            f"Нажмите кнопку ниже для оплаты:",
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+        
+        await state.clear()
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания Stars invoice: {e}")
+        await message.answer("❌ Ошибка создания платежа")
+
+
+@error_handler
+async def process_yookassa_payment_amount(
+    message: types.Message,
+    db_user: User,
+    db: AsyncSession,
+    amount_kopeks: int,
+    state: FSMContext
+):
+    texts = get_texts(db_user.language)
+    
+    if not settings.is_yookassa_enabled():
+        await message.answer("❌ Оплата через YooKassa временно недоступна")
+        return
+    
+    if amount_kopeks < 10000:
+        await message.answer("❌ Минимальная сумма для оплаты картой: 100 ₽")
+        return
+    
+    try:
+        payment_service = PaymentService(message.bot)
+        
+        payment_result = await payment_service.create_yookassa_payment(
+            db=db,
+            user_id=db_user.id,
+            amount_kopeks=amount_kopeks,
+            description=f"Пополнение баланса VPN на {settings.format_price(amount_kopeks)}",
+            receipt_email=None,
+            receipt_phone=None,
+            metadata={
+                "user_telegram_id": str(db_user.telegram_id),
+                "user_username": db_user.username or "",
+                "purpose": "balance_topup"
+            }
+        )
+        
+        if not payment_result:
+            await message.answer("❌ Ошибка создания платежа. Попробуйте позже или обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        confirmation_url = payment_result.get("confirmation_url")
+        if not confirmation_url:
+            await message.answer("❌ Ошибка получения ссылки для оплаты. Обратитесь в поддержку.")
+            await state.clear()
+            return
+        
+        keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
+            [types.InlineKeyboardButton(text="💳 Оплатить картой", url=confirmation_url)],
+            [types.InlineKeyboardButton(text="📊 Проверить статус", callback_data=f"check_yookassa_{payment_result['local_payment_id']}")],
+            [types.InlineKeyboardButton(text=texts.BACK, callback_data="balance_topup")]
+        ])
+        
+        await message.answer(
+            f"💳 <b>Оплата банковской картой</b>\n\n"
+            f"💰 Сумма: {settings.format_price(amount_kopeks)}\n"
+            f"🆔 ID платежа: {payment_result['yookassa_payment_id'][:8]}...\n\n"
+            f"📱 <b>Инструкция:</b>\n"
+            f"1. Нажмите кнопку 'Оплатить картой'\n"
+            f"2. Введите данные вашей карты\n"
+            f"3. Подтвердите платеж\n"
+            f"4. Деньги поступят на баланс автоматически\n\n"
+            f"🔒 Оплата происходит через защищенную систему YooKassa\n"
+            f"✅ Принимаем карты: Visa, MasterCard, МИР\n\n"
+            f"❓ Если возникнут проблемы, обратитесь в {settings.SUPPORT_USERNAME}",
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+        
+        await state.clear()
+        
+        logger.info(f"Создан платеж YooKassa для пользователя {db_user.telegram_id}: "
+                   f"{amount_kopeks/100}₽, ID: {payment_result['yookassa_payment_id']}")
+        
+    except Exception as e:
+        logger.error(f"Ошибка создания YooKassa платежа: {e}")
+        await message.answer("❌ Ошибка создания платежа. Попробуйте позже или обратитесь в поддержку.")
+        await state.clear()
+
+
+@error_handler
+async def check_yookassa_payment_status(
+    callback: types.CallbackQuery,
+    db: AsyncSession
+):
+    try:
+        local_payment_id = int(callback.data.split('_')[-1])
+        
+        from app.database.crud.yookassa import get_yookassa_payment_by_local_id
+        payment = await get_yookassa_payment_by_local_id(db, local_payment_id)
+        
+        if not payment:
+            await callback.answer("❌ Платеж не найден", show_alert=True)
+            return
+        
+        status_emoji = {
+            "pending": "⏳",
+            "waiting_for_capture": "⌛",
+            "succeeded": "✅",
+            "canceled": "❌",
+            "failed": "❌"
+        }
+        
+        status_text = {
+            "pending": "Ожидает оплаты",
+            "waiting_for_capture": "Ожидает подтверждения",
+            "succeeded": "Оплачен",
+            "canceled": "Отменен",
+            "failed": "Ошибка"
+        }
+        
+        emoji = status_emoji.get(payment.status, "❓")
+        status = status_text.get(payment.status, "Неизвестно")
+        
+        message_text = (f"💳 Статус платежа:\n\n"
+                       f"🆔 ID: {payment.yookassa_payment_id[:8]}...\n"
+                       f"💰 Сумма: {settings.format_price(payment.amount_kopeks)}\n"
+                       f"📊 Статус: {emoji} {status}\n"
+                       f"📅 Создан: {payment.created_at.strftime('%d.%m.%Y %H:%M')}\n")
+        
+        if payment.is_succeeded:
+            message_text += "\n✅ Платеж успешно завершен!\n\nСредства зачислены на баланс."
+        elif payment.is_pending:
+            message_text += "\n⏳ Платеж ожидает оплаты. Нажмите кнопку 'Оплатить' выше."
+        elif payment.is_failed:
+            message_text += f"\n❌ Платеж не прошел. Обратитесь в {settings.SUPPORT_USERNAME}"
+        
+        await callback.answer(message_text, show_alert=True)
+        
+    except Exception as e:
+        logger.error(f"Ошибка проверки статуса платежа: {e}")
+        await callback.answer("❌ Ошибка проверки статуса", show_alert=True)
+
+
 def register_handlers(dp: Dispatcher):
     
     dp.callback_query.register(
@@ -316,26 +538,36 @@ def register_handlers(dp: Dispatcher):
     )
     
     dp.callback_query.register(
-        start_balance_topup,
+        show_payment_methods,
         F.data == "balance_topup"
     )
     
     dp.callback_query.register(
-        process_stars_payment,
-        F.data.startswith("pay_stars_")
+        start_stars_payment,
+        F.data == "topup_stars"
     )
     
     dp.callback_query.register(
-        process_tribute_quick_payment,
-        F.data == "tribute_quick_pay"
+        start_yookassa_payment,
+        F.data == "topup_yookassa"
+    )
+    
+    dp.callback_query.register(
+        start_tribute_payment,
+        F.data == "topup_tribute"
     )
     
     dp.callback_query.register(
         request_support_topup,
-        F.data == "balance_support"
+        F.data == "topup_support"
+    )
+    
+    dp.callback_query.register(
+        check_yookassa_payment_status,
+        F.data.startswith("check_yookassa_")
     )
     
     dp.message.register(
         process_topup_amount,
         BalanceStates.waiting_for_amount
-    )
+    )

app/handlers/menu.py

@@ -2,6 +2,7 @@ import logging
 from aiogram import Dispatcher, types, F
 from aiogram.fsm.context import FSMContext
 from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime, timedelta 
 
 from app.config import settings
 from app.database.crud.user import get_user_by_telegram_id, update_user
@@ -108,15 +109,33 @@ async def handle_back_to_menu(
 
 def _get_subscription_status(user: User, texts) -> str:
     if not user.subscription:
-        return texts.SUBSCRIPTION_NONE
+        return "⌐ Отсутствует"
     
-    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
+    subscription = user.subscription
+    current_time = datetime.utcnow()
+    
+    if subscription.end_date <= current_time:
+        return f"🔴 Истекла\n📅 {subscription.end_date.strftime('%d.%m.%Y')}"
+    
+    days_left = (subscription.end_date - current_time).days
+    
+    if subscription.is_trial:
+        if days_left > 1:
+            return f"🎁 Тестовая подписка\n📅 до {subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
+        elif days_left == 1:
+            return f"🎁 Тестовая подписка\n⚠️ истекает завтра!"
+        else:
+            return f"🎁 Тестовая подписка\n⚠️ истекает сегодня!"
+    
+    else: 
+        if days_left > 7:
+            return f"💎 Активна\n📅 до {subscription.end_date.strftime('%d.%m.%Y')} ({days_left} дн.)"
+        elif days_left > 1:
+            return f"💎 Активна\n⚠️ истекает через {days_left} дн."
+        elif days_left == 1:
+            return f"💎 Активна\n⚠️ истекает завтра!"
+        else:
+            return f"💎 Активна\n⚠️ истекает сегодня!"
 
 
 def register_handlers(dp: Dispatcher):
@@ -129,4 +148,4 @@ def register_handlers(dp: Dispatcher):
     dp.callback_query.register(
         show_service_rules,
         F.data == "menu_rules"
-    )
+    )

app/handlers/start.py

@@ -9,6 +9,7 @@ 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
 )
@@ -19,7 +20,7 @@ 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):
+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
@@ -31,10 +32,10 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession)
     if referral_code:
         await state.set_data({'referral_code': referral_code})
     
-    user = await get_user_by_telegram_id(db, message.from_user.id)
+    user = db_user if db_user else await get_user_by_telegram_id(db, message.from_user.id)
     
-    if user:
-        logger.info(f"✅ Пользователь найден: {user.telegram_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:
@@ -60,26 +61,82 @@ async def cmd_start(message: types.Message, state: FSMContext, db: AsyncSession)
                 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}")
+    
+    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(
@@ -125,7 +182,7 @@ async def process_rules_accept(
                 if referrer:
                     data['referrer_id'] = referrer.id
                     await state.set_data(data)
-                    logger.info(f"✅ Референс найден: {referrer.id}")
+                    logger.info(f"✅ Реферер найден: {referrer.id}")
                 
                 await complete_registration_from_callback(callback, state, db)
             else:
@@ -237,8 +294,9 @@ async def complete_registration_from_callback(
     logger.info(f"🏁 COMPLETE: Завершение регистрации для пользователя {callback.from_user.id}")
     
     existing_user = await get_user_by_telegram_id(db, callback.from_user.id)
-    if existing_user:
-        logger.warning(f"⚠️ Пользователь {callback.from_user.id} уже существует! Показываем главное меню.")
+    
+    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
@@ -282,18 +340,43 @@ async def complete_registration_from_callback(
         if referrer:
             referrer_id = referrer.id
     
-    referral_code = await generate_unique_referral_code(db, callback.from_user.id)
-    
-    user = await create_user(
-        db=db,
-        telegram_id=callback.from_user.id,
-        username=callback.from_user.username,
-        first_name=callback.from_user.first_name,
-        last_name=callback.from_user.last_name,
-        language=language,
-        referred_by_id=referrer_id,
-        referral_code=referral_code 
-    )
+    if 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:
@@ -355,7 +438,7 @@ async def complete_registration_from_callback(
             except Exception as final_error:
                 logger.error(f"❌ Критическая ошибка при отправке простого сообщения: {final_error}")
     
-    logger.info(f"✅ Зарегистрирован новый пользователь: {user_telegram_id}")
+    logger.info(f"✅ Регистрация завершена для пользователя: {user_telegram_id}")
 
 
 async def complete_registration(
@@ -366,6 +449,8 @@ async def complete_registration(
     
     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)
@@ -376,18 +461,43 @@ async def complete_registration(
         if referrer:
             referrer_id = referrer.id
     
-    referral_code = await generate_unique_referral_code(db, message.from_user.id)
-    
-    user = await create_user(
-        db=db,
-        telegram_id=message.from_user.id,
-        username=message.from_user.username,
-        first_name=message.from_user.first_name,
-        last_name=message.from_user.last_name,
-        language=language,
-        referred_by_id=referrer_id,
-        referral_code=referral_code
-    )
+    if 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:
@@ -449,7 +559,7 @@ async def complete_registration(
             except:
                 pass
     
-    logger.info(f"✅ Зарегистрирован новый пользователь: {user_telegram_id}")
+    logger.info(f"✅ Регистрация завершена для пользователя: {user_telegram_id}")
 
 
 def _get_subscription_status(user, texts):
@@ -504,4 +614,4 @@ def register_handlers(dp: Dispatcher):
     )
     logger.info("✅ Зарегистрирован process_referral_code_input")
     
-    logger.info("🔧 === КОНЕЦ регистрации обработчиков start.py ===")
+    logger.info("🔧 === КОНЕЦ регистрации обработчиков start.py ===")

app/handlers/subscription_notifications.py

@@ -0,0 +1,171 @@
+import logging
+from datetime import datetime, timedelta
+from typing import List, Optional
+from sqlalchemy.ext.asyncio import AsyncSession
+from aiogram import Bot
+from aiogram.exceptions import TelegramBadRequest
+
+from app.database.models import User, Subscription
+from app.database.crud.user import get_user_by_id, subtract_user_balance
+from app.database.crud.subscription import get_expiring_subscriptions, extend_subscription
+from app.database.crud.transaction import create_transaction
+from app.database.models import TransactionType
+from app.keyboards.inline import get_autopay_notification_keyboard, get_subscription_expiring_keyboard
+from app.localization.texts import get_texts
+from app.services.subscription_service import SubscriptionService
+
+logger = logging.getLogger(__name__)
+
+
+async def send_subscription_expiring_notification(
+    bot: Bot,
+    db: AsyncSession,
+    subscription: Subscription,
+    days_left: int
+) -> bool:
+    try:
+        user = await get_user_by_id(db, subscription.user_id)
+        if not user:
+            return False
+        
+        texts = get_texts(user.language)
+        
+        if subscription.is_trial:
+            text = texts.TRIAL_ENDING_SOON.format(
+                price=texts.format_price(30000) 
+            )
+        else:
+            autopay_status = texts.AUTOPAY_ENABLED_TEXT if subscription.autopay_enabled else texts.AUTOPAY_DISABLED_TEXT
+            
+            if subscription.autopay_enabled:
+                action_text = f"💰 Убедитесь, что на балансе достаточно средств: {texts.format_price(user.balance_kopeks)}"
+            else:
+                action_text = "💡 Включите автоплатеж или продлите подписку вручную"
+            
+            text = texts.SUBSCRIPTION_EXPIRING_PAID.format(
+                days=days_left,
+                end_date=subscription.end_date.strftime("%d.%m.%Y %H:%M"),
+                autopay_status=autopay_status,
+                action_text=action_text
+            )
+        
+        keyboard = get_subscription_expiring_keyboard(subscription.id, user.language)
+        
+        await bot.send_message(
+            chat_id=user.telegram_id,
+            text=text,
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+        
+        logger.info(f"✅ Отправлено уведомление об истечении подписки пользователю {user.telegram_id}")
+        return True
+        
+    except TelegramBadRequest as e:
+        logger.warning(f"⚠️ Не удалось отправить уведомление пользователю {user.telegram_id}: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Ошибка отправки уведомления об истечении подписки: {e}")
+        return False
+
+
+async def send_autopay_failed_notification(
+    bot: Bot,
+    db: AsyncSession,
+    subscription: Subscription,
+    required_amount: int
+) -> bool:
+    try:
+        user = await get_user_by_id(db, subscription.user_id)
+        if not user:
+            return False
+        
+        texts = get_texts(user.language)
+        
+        text = texts.AUTOPAY_FAILED.format(
+            balance=texts.format_price(user.balance_kopeks),
+            required=texts.format_price(required_amount)
+        )
+        
+        keyboard = get_autopay_notification_keyboard(subscription.id, user.language)
+        
+        await bot.send_message(
+            chat_id=user.telegram_id,
+            text=text,
+            reply_markup=keyboard,
+            parse_mode="HTML"
+        )
+        
+        logger.info(f"✅ Отправлено уведомление о неудачном автоплатеже пользователю {user.telegram_id}")
+        return True
+        
+    except TelegramBadRequest as e:
+        logger.warning(f"⚠️ Не удалось отправить уведомление пользователю {user.telegram_id}: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Ошибка отправки уведомления о неудачном автоплатеже: {e}")
+        return False
+
+
+async def process_autopayment(
+    bot: Bot,
+    db: AsyncSession,
+    subscription: Subscription
+) -> bool:
+    try:
+        user = await get_user_by_id(db, subscription.user_id)
+        if not user:
+            logger.error(f"Пользователь {subscription.user_id} не найден для автоплатежа")
+            return False
+        
+        subscription_service = SubscriptionService()
+        renewal_cost = await subscription_service.calculate_renewal_price(
+            subscription, 30, db 
+        )
+        
+        if user.balance_kopeks < renewal_cost:
+            logger.warning(f"Недостаточно средств для автоплатежа у пользователя {user.telegram_id}")
+            await send_autopay_failed_notification(bot, db, subscription, renewal_cost)
+            return False
+        
+        success = await subtract_user_balance(
+            db, user, renewal_cost,
+            f"Автопродление подписки на 30 дней"
+        )
+        
+        if not success:
+            logger.error(f"Ошибка списания средств для автоплатежа у пользователя {user.telegram_id}")
+            await send_autopay_failed_notification(bot, db, subscription, renewal_cost)
+            return False
+        
+        await extend_subscription(db, subscription, 30)
+        
+        await subscription_service.update_remnawave_user(db, subscription)
+        
+        await create_transaction(
+            db=db,
+            user_id=user.id,
+            type=TransactionType.SUBSCRIPTION_PAYMENT,
+            amount_kopeks=renewal_cost,
+            description="Автопродление подписки на 30 дней"
+        )
+        
+        texts = get_texts(user.language)
+        success_text = texts.AUTOPAY_SUCCESS.format(
+            days=30,
+            amount=texts.format_price(renewal_cost),
+            new_end_date=subscription.end_date.strftime("%d.%m.%Y %H:%M")
+        )
+        
+        await bot.send_message(
+            chat_id=user.telegram_id,
+            text=success_text,
+            parse_mode="HTML"
+        )
+        
+        logger.info(f"✅ Автоплатеж успешно выполнен для пользователя {user.telegram_id}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка обработки автоплатежа: {e}")
+        return False

app/keyboards/admin.py

@@ -25,7 +25,8 @@ def get_admin_main_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
             InlineKeyboardButton(text=texts.ADMIN_REMNAWAVE, callback_data="admin_remnawave")
         ],
         [
-            InlineKeyboardButton(text=texts.ADMIN_STATISTICS, callback_data="admin_statistics")
+            InlineKeyboardButton(text=texts.ADMIN_STATISTICS, callback_data="admin_statistics"),
+            InlineKeyboardButton(text="🔧 Техработы", callback_data="maintenance_panel")
         ],
         [
             InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
@@ -172,24 +173,38 @@ def get_admin_statistics_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     ])
 
 
-def get_user_management_keyboard(user_id: int, language: str = "ru") -> InlineKeyboardMarkup:
-    return InlineKeyboardMarkup(inline_keyboard=[
+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_sub_{user_id}")
-        ],
-        [
-            InlineKeyboardButton(text="📊 Статистика", callback_data=f"admin_user_stats_{user_id}"),
-            InlineKeyboardButton(text="📋 Транзакции", callback_data=f"admin_user_trans_{user_id}")
+            InlineKeyboardButton(text="📱 Подписка", callback_data=f"admin_user_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}")
-        ],
-        [
-            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_users_list")
-        ]
+        ])
+    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(
@@ -293,8 +308,8 @@ def get_custom_criteria_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
             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="👤 Неактивные 7+ дней", callback_data="criteria_inactive_week"),
+            InlineKeyboardButton(text="👤 Неактивные 30+ дней", callback_data="criteria_inactive_month")
         ],
         [
             InlineKeyboardButton(text="🤝 Через рефералов", callback_data="criteria_referrals"),
@@ -339,18 +354,52 @@ def get_broadcast_history_keyboard(page: int, total_pages: int, language: str =
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 def get_sync_options_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
-    return InlineKeyboardMarkup(inline_keyboard=[
+    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_all_users"),
-            InlineKeyboardButton(text="➕ Только новых", callback_data="sync_new_users")
+            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="sync_update_data")
+            InlineKeyboardButton(text="📊 Статистика", callback_data="admin_rw_system"),
+            InlineKeyboardButton(text="🔍 Валидация", callback_data="sync_validate")
         ],
-        [
-            InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")
-        ]
+        [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:
@@ -526,4 +575,35 @@ def get_admin_pagination_keyboard(
         InlineKeyboardButton(text="⬅️ Назад", callback_data=back_callback)
     ])
     
-    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_maintenance_keyboard(language: str = "ru", is_active: bool = False, monitoring_active: bool = False) -> InlineKeyboardMarkup:
+    """Клавиатура для управления техработами"""
+    
+    if language == "en":
+        toggle_text = "🔴 Disable maintenance" if is_active else "🔧 Enable maintenance"
+        monitoring_text = "⏹️ Stop monitoring" if monitoring_active else "🔄 Start monitoring"
+        check_api_text = "🔍 Check API"
+        back_text = "⬅️ Back to admin"
+    else:
+        toggle_text = "🔴 Выключить техработы" if is_active else "🔧 Включить техработы"
+        monitoring_text = "⏹️ Остановить мониторинг" if monitoring_active else "🔄 Запустить мониторинг"
+        check_api_text = "🔍 Проверить API"
+        back_text = "⬅️ Назад в админку"
+    
+    keyboard = [
+        [InlineKeyboardButton(text=toggle_text, callback_data="maintenance_toggle")],
+        [InlineKeyboardButton(text=monitoring_text, callback_data="maintenance_monitoring")],
+        [InlineKeyboardButton(text=check_api_text, callback_data="maintenance_check_api")],
+        [InlineKeyboardButton(text=back_text, callback_data="admin_panel")]
+    ]
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_sync_simplified_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    keyboard = [
+        [InlineKeyboardButton(text="🔄 Полная синхронизация", callback_data="sync_all_users")],
+        [InlineKeyboardButton(text="⬅️ Назад", callback_data="admin_remnawave")]
+    ]
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)

app/keyboards/inline.py

@@ -97,13 +97,34 @@ def get_subscription_keyboard(
     is_trial: bool = False,
     subscription=None
 ) -> InlineKeyboardMarkup:
+    from app.config import settings 
+    
     texts = get_texts(language)
     keyboard = []
     
     if has_subscription:
         if subscription and subscription.subscription_url:
+            connect_mode = settings.CONNECT_BUTTON_MODE
+            
+            if connect_mode == "miniapp_subscription":
+                button_text = "🚀 Открыть в мини-приложении"
+            elif connect_mode == "miniapp_custom":
+                button_text = "🚀 Открыть приложение"
+            else:
+                button_text = "🔗 Подключиться"
+                
             keyboard.append([
-                InlineKeyboardButton(text="🔗 Подключиться", callback_data="subscription_connect")
+                InlineKeyboardButton(text=button_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:
@@ -111,35 +132,9 @@ def get_subscription_keyboard(
                 InlineKeyboardButton(text=texts.MENU_BUY_SUBSCRIPTION, callback_data="subscription_upgrade")
             ])
         else:
-            row1 = []
-            row2 = []
-            row3 = []
-            row4 = [] 
-            
-            row1.append(InlineKeyboardButton(text="🌐 Добавить страны", callback_data="subscription_add_countries"))
-            
-            if subscription and subscription.traffic_limit_gb > 0:
-                row1.append(InlineKeyboardButton(text="📈 Добавить трафик", callback_data="subscription_add_traffic"))
-            
-            row2.append(InlineKeyboardButton(text="📱 Добавить устройства", callback_data="subscription_add_devices"))
-            
-            if subscription and subscription.days_left <= 3:
-                row2.append(InlineKeyboardButton(text="⏰ Продлить", callback_data="subscription_extend"))
-            
-            row3.append(InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="subscription_reset_traffic"))
-            
-            row3.append(InlineKeyboardButton(text="💳 Автоплатеж", callback_data="subscription_autopay"))
-            
-            row4.append(InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data="subscription_reset_devices"))
-            
-            if row1:
-                keyboard.append(row1)
-            if row2:
-                keyboard.append(row2)
-            if row3:
-                keyboard.append(row3)
-            if row4:
-                keyboard.append(row4)
+            keyboard.append([
+                InlineKeyboardButton(text="⚙️ Настройки подписки", callback_data="subscription_settings")
+            ])
     
     keyboard.append([
         InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
@@ -147,6 +142,36 @@ def get_subscription_keyboard(
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
+def get_subscription_settings_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    from app.config import settings
+    
+    texts = get_texts(language)
+    keyboard = [
+        [
+            InlineKeyboardButton(text="🌍 Добавить страны", callback_data="subscription_add_countries")
+        ],
+        [
+            InlineKeyboardButton(text="📱 Добавить устройства", callback_data="subscription_add_devices")
+        ],
+        [
+            InlineKeyboardButton(text="🔄 Сбросить устройства", callback_data="subscription_reset_devices")
+        ]
+    ]
+    
+    if settings.is_traffic_selectable():
+        keyboard.insert(1, [
+            InlineKeyboardButton(text="📈 Добавить трафик", callback_data="subscription_add_traffic")
+        ])
+        keyboard.insert(2, [
+            InlineKeyboardButton(text="🔄 Сбросить трафик", callback_data="subscription_reset_traffic")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
 
 def get_trial_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
@@ -162,19 +187,25 @@ def get_subscription_period_keyboard(language: str = "ru") -> InlineKeyboardMark
     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)
-    ]
+    available_periods = settings.get_available_subscription_periods()
     
-    for days, text in periods:
-        keyboard.append([
-            InlineKeyboardButton(text=text, callback_data=f"period_{days}")
-        ])
+    period_texts = {
+        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 in available_periods:
+        if days in period_texts:
+            keyboard.append([
+                InlineKeyboardButton(
+                    text=period_texts[days], 
+                    callback_data=f"period_{days}"
+                )
+            ])
     
     keyboard.append([
         InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
@@ -184,6 +215,11 @@ def get_subscription_period_keyboard(language: str = "ru") -> InlineKeyboardMark
 
 
 def get_traffic_packages_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    from app.config import settings
+    
+    if settings.is_traffic_fixed():
+        return get_back_keyboard(language)
+    
     texts = get_texts(language)
     keyboard = []
     
@@ -283,25 +319,16 @@ def get_subscription_confirm_keyboard(language: str = "ru") -> InlineKeyboardMar
 
 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")
-    ])
+    keyboard = [
+        [
+            InlineKeyboardButton(text=texts.BALANCE_HISTORY, callback_data="balance_history"),
+            InlineKeyboardButton(text=texts.BALANCE_TOP_UP, callback_data="balance_topup")
+        ],
+        [
+            InlineKeyboardButton(text=texts.BACK, callback_data="back_to_menu")
+        ]
+    ]
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
@@ -312,16 +339,110 @@ def get_payment_methods_keyboard(amount_kopeks: int, language: str = "ru") -> In
     
     if settings.TELEGRAM_STARS_ENABLED:
         keyboard.append([
-            InlineKeyboardButton(text=texts.TOP_UP_STARS, callback_data=f"pay_stars_{amount_kopeks}")
+            InlineKeyboardButton(
+                text="⭐ Telegram Stars", 
+                callback_data="topup_stars"
+            )
         ])
     
+    if settings.is_yookassa_enabled():
+        keyboard.append([
+            InlineKeyboardButton(
+                text="💳 Банковская карта (YooKassa)", 
+                callback_data="topup_yookassa"
+            )
+        ])
+    
+    if settings.TRIBUTE_ENABLED:
+        keyboard.append([
+            InlineKeyboardButton(
+                text="💎 Банковская карта (Tribute)", 
+                callback_data="topup_tribute"
+            )
+        ])
     
     keyboard.append([
-        InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance") 
+        InlineKeyboardButton(
+            text="🛠️ Через поддержку", 
+            callback_data="topup_support"
+        )
+    ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text=texts.BACK, callback_data="menu_balance")
     ])
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
+def get_yookassa_payment_keyboard(
+    payment_id: str, 
+    amount_kopeks: int, 
+    confirmation_url: str,
+    language: str = "ru"
+) -> InlineKeyboardMarkup:
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text="💳 Оплатить",
+                url=confirmation_url
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="📊 Проверить статус",
+                callback_data=f"check_yookassa_status_{payment_id}"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="💰 Мой баланс",
+                callback_data="menu_balance"
+            )
+        ]
+    ])
+
+def get_autopay_notification_keyboard(subscription_id: int, language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text="💳 Пополнить баланс", 
+                callback_data="balance_topup"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="📱 Моя подписка", 
+                callback_data="menu_subscription"
+            )
+        ]
+    ])
+
+def get_subscription_expiring_keyboard(subscription_id: int, language: str = "ru") -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    
+    return InlineKeyboardMarkup(inline_keyboard=[
+        [
+            InlineKeyboardButton(
+                text="⏰ Продлить подписку", 
+                callback_data="subscription_extend"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="💳 Пополнить баланс", 
+                callback_data="balance_topup"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="📱 Моя подписка", 
+                callback_data="menu_subscription"
+            )
+        ]
+    ])
 
 def get_referral_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
     texts = get_texts(language)
@@ -470,6 +591,11 @@ def get_extend_subscription_keyboard(language: str = "ru") -> InlineKeyboardMark
 
 
 def get_add_traffic_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
+    from app.config import settings
+    
+    if settings.is_traffic_fixed():
+        return get_back_keyboard(language)
+    
     texts = get_texts(language)
     keyboard = []
     
@@ -519,6 +645,11 @@ def get_add_devices_keyboard(current_devices: int, language: str = "ru") -> Inli
 
 
 def get_reset_traffic_confirm_keyboard(price_kopeks: int, language: str = "ru") -> InlineKeyboardMarkup:
+    from app.config import settings
+    
+    if settings.is_traffic_fixed():
+        return get_back_keyboard(language)
+    
     texts = get_texts(language)
     return InlineKeyboardMarkup(inline_keyboard=[
         [
@@ -528,7 +659,7 @@ def get_reset_traffic_confirm_keyboard(price_kopeks: int, language: str = "ru")
             )
         ],
         [
-            InlineKeyboardButton(text="❌ Отмена", callback_data="menu_subscription")
+            InlineKeyboardButton(text="⌛ Отмена", callback_data="menu_subscription")
         ]
     ])
 
@@ -596,25 +727,32 @@ def get_manage_countries_keyboard(
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 def get_device_selection_keyboard(language: str = "ru") -> InlineKeyboardMarkup:
-    return InlineKeyboardMarkup(inline_keyboard=[
+    from app.config import settings
+    
+    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="🎯 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")
         ]
+    ]
+    
+    if settings.CONNECT_BUTTON_MODE == "guide":
+        keyboard.append([
+            InlineKeyboardButton(text="📋 Показать ссылку подписки", callback_data="open_subscription_link")
+        ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
     ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)
 
 
 def get_connection_guide_keyboard(
@@ -622,6 +760,8 @@ def get_connection_guide_keyboard(
     app: dict, 
     language: str = "ru"
 ) -> InlineKeyboardMarkup:
+    from app.handlers.subscription import create_deep_link
+    
     keyboard = []
     
     if 'installationStep' in app and 'buttons' in app['installationStep']:
@@ -691,6 +831,8 @@ def get_specific_app_keyboard(
     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']:
@@ -731,3 +873,33 @@ def get_specific_app_keyboard(
     ])
     
     return InlineKeyboardMarkup(inline_keyboard=keyboard)
+
+def get_extend_subscription_keyboard_with_prices(language: str, prices: dict) -> InlineKeyboardMarkup:
+    texts = get_texts(language)
+    keyboard = []
+    
+    available_periods = settings.get_available_renewal_periods()
+    
+    period_display = {
+        14: "14 дней",
+        30: "30 дней", 
+        60: "60 дней",
+        90: "90 дней",
+        180: "180 дней",
+        360: "360 дней"
+    }
+    
+    for days in available_periods:
+        if days in prices and days in period_display:
+            keyboard.append([
+                InlineKeyboardButton(
+                    text=f"📅 {period_display[days]} - {texts.format_price(prices[days])}", 
+                    callback_data=f"extend_period_{days}"
+                )
+            ])
+    
+    keyboard.append([
+        InlineKeyboardButton(text="⬅️ Назад", callback_data="menu_subscription")
+    ])
+    
+    return InlineKeyboardMarkup(inline_keyboard=keyboard)

app/localization/texts.py

@@ -106,11 +106,11 @@ class RussianTexts(Texts):
     REFERRAL_CODE_INVALID = "❌ Неверный реферальный код"
     REFERRAL_CODE_SKIP = "⏭️ Пропустить"
     
-    MAIN_MENU = """
-👤 <b>{user_name}</b>
-
+    MAIN_MENU = """👤 <b>{user_name}</b>
+━━━━━━━━━━━━━━━━━
 💰 <b>Баланс:</b> {balance}
 📱 <b>Подписка:</b> {subscription_status}
+━━━━━━━━━━━━━━━━━
 
 Выберите действие:
 """
@@ -268,7 +268,7 @@ class RussianTexts(Texts):
     TRIAL_ENDING_SOON = """
 🎁 <b>Тестовая подписка скоро закончится!</b>
 
-Ваша тестовая подписка истекает через 2 часа.
+Ваша тестовая подписка истекает через несколько часов.
 
 💎 <b>Не хотите остаться без VPN?</b>
 Переходите на полную подписку!
@@ -280,10 +280,31 @@ class RussianTexts(Texts):
 • Поддержка до 3 устройств
 
 ⚡️ Успейте оформить до окончания тестового периода!
+"""
+
+    MAINTENANCE_MODE_ACTIVE = """
+🔧 Технические работы!
+
+Сервис временно недоступен. Ведутся технические работы по улучшению качества обслуживания.
+
+⏰ Ориентировочное время завершения: неизвестно
+🔄 Попробуйте позже
+
+Приносим извинения за временные неудобства.
+"""
+
+    MAINTENANCE_MODE_API_ERROR = """
+🔧 Технические работы!
+
+Сервис временно недоступен из-за проблем с подключением к серверам.
+
+⏰ Мы работаем над восстановлением. Попробуйте через несколько минут.
+
+🔄 Последняя проверка: {last_check}
 """
 
     SUBSCRIPTION_EXPIRING_PAID = """
-⚠️ <b>Подписка истекает через {days} дней!</b>
+⚠️ <b>Подписка истекает через {days_text}!</b>
 
 Ваша платная подписка истекает {end_date}.
 
@@ -354,7 +375,7 @@ class RussianTexts(Texts):
     ADMIN_MONITORING = "🔍 Мониторинг"
     ADMIN_REFERRALS = "🤝 Рефералы"
     ADMIN_RULES = "📋 Правила"
-    ADMIN_REMNAWAVE = "🖥️ RemnaWave"
+    ADMIN_REMNAWAVE = "🖥️ Remnawave"
     ADMIN_STATISTICS = "📊 Статистика"
     
     ACCESS_DENIED = "❌ Доступ запрещен"
@@ -485,4 +506,4 @@ async def refresh_rules_cache(language: str = "ru"):
 def clear_rules_cache():
     global _cached_rules
     _cached_rules.clear()
-    print("✅ Кеш правил очищен")
+    print("✅ Кеш правил очищен")

app/middlewares/auth.py

@@ -56,7 +56,7 @@ class AuthMiddleware(BaseMiddleware):
                     )
                     
                     if is_registration_process:
-                        logger.info(f"🔓 Пропускаем пользователя {user.id} в процессе регистрации")
+                        logger.info(f"📝 Пропускаем пользователя {user.id} в процессе регистрации")
                         data['db'] = db
                         data['db_user'] = None
                         data['is_admin'] = False
@@ -64,24 +64,74 @@ class AuthMiddleware(BaseMiddleware):
                     else:
                         if isinstance(event, Message):
                             await event.answer(
-                                "◀️ Для начала работы необходимо выполнить команду /start"
+                                "▶️ Для начала работы необходимо выполнить команду /start"
                             )
                         elif isinstance(event, CallbackQuery):
                             await event.answer(
-                                "◀️ Необходимо начать с команды /start",
+                                "▶️ Необходимо начать с команды /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:
@@ -90,4 +140,4 @@ class AuthMiddleware(BaseMiddleware):
                 if hasattr(event, 'data'):
                     logger.error(f"Callback data: {event.data}")
                 await db.rollback()
-                raise
+                raise

app/middlewares/maintenance.py

@@ -0,0 +1,45 @@
+import logging
+from typing import Callable, Dict, Any, Awaitable
+from aiogram import BaseMiddleware
+from aiogram.types import Message, CallbackQuery, TelegramObject, User as TgUser
+
+from app.config import settings
+from app.services.maintenance_service import maintenance_service
+
+logger = logging.getLogger(__name__)
+
+
+class MaintenanceMiddleware(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 or user.is_bot:
+            return await handler(event, data)
+        
+        if not maintenance_service.is_maintenance_active():
+            return await handler(event, data)
+        
+        if settings.is_admin(user.id):
+            return await handler(event, data)
+        
+        maintenance_message = maintenance_service.get_maintenance_message()
+        
+        try:
+            if isinstance(event, Message):
+                await event.answer(maintenance_message, parse_mode="HTML")
+            elif isinstance(event, CallbackQuery):
+                await event.answer(maintenance_message, show_alert=True)
+        except Exception as e:
+            logger.error(f"Ошибка отправки сообщения о техработах пользователю {user.id}: {e}")
+        
+        logger.info(f"🔧 Пользователь {user.id} заблокирован во время техработ")
+        return 

app/middlewares/subscription_checker.py

@@ -0,0 +1,53 @@
+import logging
+from typing import Callable, Dict, Any, Awaitable
+from datetime import datetime
+from aiogram import BaseMiddleware
+from aiogram.types import TelegramObject, Update, Message, CallbackQuery
+
+from app.database.database import get_db
+from app.database.crud.user import get_user_by_telegram_id
+from app.database.models import SubscriptionStatus
+
+logger = logging.getLogger(__name__)
+
+
+class SubscriptionStatusMiddleware(BaseMiddleware):
+    
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: Dict[str, Any]
+    ) -> Any:
+        
+        telegram_id = None
+        if isinstance(event, (Message, CallbackQuery)):
+            telegram_id = event.from_user.id
+        elif isinstance(event, Update):
+            if event.message:
+                telegram_id = event.message.from_user.id
+            elif event.callback_query:
+                telegram_id = event.callback_query.from_user.id
+        
+        if telegram_id:
+            try:
+                async for db in get_db():
+                    user = await get_user_by_telegram_id(db, telegram_id)
+                    if user and user.subscription:
+                        current_time = datetime.utcnow()
+                        subscription = user.subscription
+                        
+                        if (subscription.status == SubscriptionStatus.ACTIVE.value and 
+                            subscription.end_date <= current_time):
+                            
+                            subscription.status = SubscriptionStatus.EXPIRED.value
+                            subscription.updated_at = current_time
+                            await db.commit()
+                            
+                            logger.info(f"⏰ Middleware: Статус подписки пользователя {user.id} изменен на 'expired' (время истекло)")
+                    break
+                    
+            except Exception as e:
+                logger.error(f"Ошибка проверки статуса подписки для пользователя {telegram_id}: {e}")
+        
+        return await handler(event, data)

app/services/maintenance_service.py

@@ -0,0 +1,268 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+
+from app.config import settings
+from app.external.remnawave_api import RemnaWaveAPI, test_api_connection
+from app.utils.cache import cache
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MaintenanceStatus:
+    is_active: bool
+    enabled_at: Optional[datetime] = None
+    last_check: Optional[datetime] = None
+    reason: Optional[str] = None
+    auto_enabled: bool = False
+    api_status: bool = True
+    consecutive_failures: int = 0
+
+
+class MaintenanceService:
+    
+    def __init__(self):
+        self._status = MaintenanceStatus(is_active=False)
+        self._check_task: Optional[asyncio.Task] = None
+        self._is_checking = False
+        self._max_consecutive_failures = 3 
+        
+    @property
+    def status(self) -> MaintenanceStatus:
+        return self._status
+    
+    def is_maintenance_active(self) -> bool:
+        return self._status.is_active
+    
+    def get_maintenance_message(self) -> str:
+        if self._status.auto_enabled:
+            return f"""
+🔧 Технические работы!
+
+Сервис временно недоступен из-за проблем с подключением к серверам.
+
+⏰ Мы работаем над восстановлением. Попробуйте через несколько минут.
+
+🔄 Последняя проверка: {self._status.last_check.strftime('%H:%M:%S') if self._status.last_check else 'неизвестно'}
+"""
+        else:
+            return settings.get_maintenance_message()
+    
+    async def enable_maintenance(self, reason: Optional[str] = None, auto: bool = False) -> bool:
+        try:
+            if self._status.is_active:
+                logger.warning("Режим техработ уже включен")
+                return True
+            
+            self._status.is_active = True
+            self._status.enabled_at = datetime.utcnow()
+            self._status.reason = reason or ("Автоматическое включение" if auto else "Включено администратором")
+            self._status.auto_enabled = auto
+            
+            await self._save_status_to_cache()
+            
+            logger.warning(f"🔧 Режим техработ ВКЛЮЧЕН. Причина: {self._status.reason}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка включения режима техработ: {e}")
+            return False
+    
+    async def disable_maintenance(self) -> bool:
+        try:
+            if not self._status.is_active:
+                logger.info("Режим техработ уже выключен")
+                return True
+            
+            self._status.is_active = False
+            self._status.enabled_at = None
+            self._status.reason = None
+            self._status.auto_enabled = False
+            self._status.consecutive_failures = 0
+            
+            await self._save_status_to_cache()
+            
+            logger.info("✅ Режим техработ ВЫКЛЮЧЕН")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка выключения режима техработ: {e}")
+            return False
+    
+    async def start_monitoring(self) -> bool:
+        try:
+            if self._check_task and not self._check_task.done():
+                logger.warning("Мониторинг уже запущен")
+                return True
+            
+            await self._load_status_from_cache()
+            
+            self._check_task = asyncio.create_task(self._monitoring_loop())
+            logger.info(f"🔄 Запущен мониторинг API RemnaWave (интервал: {settings.get_maintenance_check_interval()}с)")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка запуска мониторинга: {e}")
+            return False
+    
+    async def stop_monitoring(self) -> bool:
+        try:
+            if self._check_task and not self._check_task.done():
+                self._check_task.cancel()
+                try:
+                    await self._check_task
+                except asyncio.CancelledError:
+                    pass
+            
+            logger.info("⏹️ Мониторинг API остановлен")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка остановки мониторинга: {e}")
+            return False
+    
+    async def check_api_status(self) -> bool:
+        try:
+            if self._is_checking:
+                return self._status.api_status
+            
+            self._is_checking = True
+            self._status.last_check = datetime.utcnow()
+            
+            api = RemnaWaveAPI(settings.REMNAWAVE_API_URL, settings.REMNAWAVE_API_KEY)
+            
+            async with api:
+                is_connected = await test_api_connection(api)
+                
+                if is_connected:
+                    self._status.api_status = True
+                    self._status.consecutive_failures = 0
+                    
+                    if self._status.is_active and self._status.auto_enabled:
+                        await self.disable_maintenance()
+                        logger.info("✅ API восстановился, режим техработ автоматически отключен")
+                    
+                    return True
+                else:
+                    self._status.api_status = False
+                    self._status.consecutive_failures += 1
+                    
+                    if (self._status.consecutive_failures >= self._max_consecutive_failures and
+                        not self._status.is_active and
+                        settings.is_maintenance_auto_enable()):
+                        
+                        await self.enable_maintenance(
+                            reason=f"Автоматическое включение после {self._status.consecutive_failures} неудачных проверок API",
+                            auto=True
+                        )
+                    
+                    return False
+                    
+        except Exception as e:
+            logger.error(f"Ошибка проверки API: {e}")
+            self._status.api_status = False
+            self._status.consecutive_failures += 1
+            return False
+        finally:
+            self._is_checking = False
+            await self._save_status_to_cache()
+    
+    async def _monitoring_loop(self):
+        while True:
+            try:
+                await self.check_api_status()
+                await asyncio.sleep(settings.get_maintenance_check_interval())
+                
+            except asyncio.CancelledError:
+                logger.info("Мониторинг отменен")
+                break
+            except Exception as e:
+                logger.error(f"Ошибка в цикле мониторинга: {e}")
+                await asyncio.sleep(30) 
+    
+    async def _save_status_to_cache(self):
+        try:
+            status_data = {
+                "is_active": self._status.is_active,
+                "enabled_at": self._status.enabled_at.isoformat() if self._status.enabled_at else None,
+                "reason": self._status.reason,
+                "auto_enabled": self._status.auto_enabled,
+                "consecutive_failures": self._status.consecutive_failures,
+                "last_check": self._status.last_check.isoformat() if self._status.last_check else None
+            }
+            
+            await cache.set("maintenance_status", status_data, expire=3600)
+            
+        except Exception as e:
+            logger.error(f"Ошибка сохранения состояния в кеш: {e}")
+    
+    async def _load_status_from_cache(self):
+        try:
+            status_data = await cache.get("maintenance_status")
+            if not status_data:
+                return
+            
+            self._status.is_active = status_data.get("is_active", False)
+            self._status.reason = status_data.get("reason")
+            self._status.auto_enabled = status_data.get("auto_enabled", False)
+            self._status.consecutive_failures = status_data.get("consecutive_failures", 0)
+            
+            if status_data.get("enabled_at"):
+                self._status.enabled_at = datetime.fromisoformat(status_data["enabled_at"])
+            
+            if status_data.get("last_check"):
+                self._status.last_check = datetime.fromisoformat(status_data["last_check"])
+            
+            logger.info(f"📥 Состояние техработ загружено из кеша: активен={self._status.is_active}")
+            
+        except Exception as e:
+            logger.error(f"Ошибка загрузки состояния из кеша: {e}")
+    
+    def get_status_info(self) -> Dict[str, Any]:
+        return {
+            "is_active": self._status.is_active,
+            "enabled_at": self._status.enabled_at,
+            "last_check": self._status.last_check,
+            "reason": self._status.reason,
+            "auto_enabled": self._status.auto_enabled,
+            "api_status": self._status.api_status,
+            "consecutive_failures": self._status.consecutive_failures,
+            "monitoring_active": self._check_task is not None and not self._check_task.done(),
+            "auto_enable_configured": settings.is_maintenance_auto_enable(),
+            "check_interval": settings.get_maintenance_check_interval()
+        }
+    
+    async def force_api_check(self) -> Dict[str, Any]:
+        start_time = datetime.utcnow()
+        
+        try:
+            api_status = await self.check_api_status()
+            end_time = datetime.utcnow()
+            response_time = (end_time - start_time).total_seconds()
+            
+            return {
+                "success": True,
+                "api_available": api_status,
+                "response_time": round(response_time, 2),
+                "checked_at": end_time,
+                "consecutive_failures": self._status.consecutive_failures
+            }
+            
+        except Exception as e:
+            end_time = datetime.utcnow()
+            response_time = (end_time - start_time).total_seconds()
+            
+            return {
+                "success": False,
+                "api_available": False,
+                "error": str(e),
+                "response_time": round(response_time, 2),
+                "checked_at": end_time,
+                "consecutive_failures": self._status.consecutive_failures
+            }
+
+
+maintenance_service = MaintenanceService()

app/services/monitoring_service.py

@@ -22,6 +22,10 @@ from app.services.subscription_service import SubscriptionService
 from app.services.payment_service import PaymentService
 from app.localization.texts import get_texts
 
+from app.external.remnawave_api import (
+    RemnaWaveUser, UserStatus, TrafficLimitStrategy, RemnaWaveAPIError
+)
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,7 +36,7 @@ class MonitoringService:
         self.subscription_service = SubscriptionService()
         self.payment_service = PaymentService()
         self.bot = bot
-        self._notified_users: Set[str] = set()  # Защита от дублирования уведомлений
+        self._notified_users: Set[str] = set() 
     
     async def start_monitoring(self):
         if self.is_running:
@@ -60,12 +64,11 @@ class MonitoringService:
             try:
                 await self._check_expired_subscriptions(db)
                 await self._check_expiring_subscriptions(db)
-                await self._check_trial_expiring_soon(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()
@@ -88,40 +91,85 @@ class MonitoringService:
                 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)
+                from app.database.crud.subscription import expire_subscription
+                await expire_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} истекла и деактивирована")
+                logger.info(f"🔴 Подписка пользователя {subscription.user_id} истекла и статус изменен на 'expired'")
             
             if expired_subscriptions:
                 await self._log_monitoring_event(
                     db, "expired_subscriptions_processed",
-                    f"Обработано {len(expired_subscriptions)} истекших подписок",
+                    f"Обработано {len(expired_subscriptions)} истёкших подписок",
                     {"count": len(expired_subscriptions)}
                 )
                 
         except Exception as e:
-            logger.error(f"Ошибка проверки истекших подписок: {e}")
+            logger.error(f"Ошибка проверки истёкших подписок: {e}")
+
+    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
+            
+            current_time = datetime.utcnow()
+            is_active = (subscription.status == SubscriptionStatus.ACTIVE.value and 
+                        subscription.end_date > current_time)
+            
+            if (subscription.status == SubscriptionStatus.ACTIVE.value and 
+                subscription.end_date <= current_time):
+                subscription.status = SubscriptionStatus.EXPIRED.value
+                await db.commit()
+                is_active = False
+                logger.info(f"📝 Статус подписки {subscription.id} обновлен на 'expired'")
+            
+            async with self.api as api:
+                updated_user = await api.update_user(
+                    uuid=user.remnawave_uuid,
+                    status=UserStatus.ACTIVE if 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()
+                
+                status_text = "активным" if is_active else "истёкшим"
+                logger.info(f"✅ Обновлен RemnaWave пользователь {user.remnawave_uuid} со статусом {status_text}")
+                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 _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:
@@ -131,7 +179,7 @@ class MonitoringService:
                     
                     notification_key = f"expiring_{user.telegram_id}_{days}d"
                     if notification_key in self._notified_users:
-                        continue  # Уже уведомляли сегодня
+                        continue 
                     
                     if self.bot:
                         await self._send_subscription_expiring_notification(user, subscription, days)
@@ -150,9 +198,7 @@ class MonitoringService:
             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(
@@ -176,7 +222,7 @@ class MonitoringService:
                 
                 notification_key = f"trial_2h_{user.telegram_id}"
                 if notification_key in self._notified_users:
-                    continue  # Уже уведомляли
+                    continue  
                 
                 if self.bot:
                     await self._send_trial_ending_notification(user, subscription)
@@ -195,8 +241,8 @@ class MonitoringService:
             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)
+        current_time = datetime.utcnow()
+        threshold_date = current_time + timedelta(days=days_before)
         
         result = await db.execute(
             select(Subscription)
@@ -204,18 +250,24 @@ class MonitoringService:
             .where(
                 and_(
                     Subscription.status == SubscriptionStatus.ACTIVE.value,
-                    Subscription.is_trial == False,  # Только платные
-                    Subscription.end_date <= threshold_date,
-                    Subscription.end_date > datetime.utcnow()
+                    Subscription.is_trial == False, 
+                    Subscription.end_date > current_time,
+                    Subscription.end_date <= threshold_date
                 )
             )
         )
-        return result.scalars().all()
+        
+        logger.info(f"🔍 Поиск платных подписок, истекающих в ближайшие {days_before} дней")
+        logger.info(f"📅 Текущее время: {current_time}")
+        logger.info(f"📅 Пороговая дата: {threshold_date}")
+        
+        subscriptions = result.scalars().all()
+        logger.info(f"📊 Найдено {len(subscriptions)} платных подписок для уведомлений")
+        
+        return subscriptions
     
     async def _process_autopayments(self, db: AsyncSession):
-        """Обработка автоплатежей"""
         try:
-            # Исправленный запрос с использованием индивидуальных настроек
             current_time = datetime.utcnow()
             
             result = await db.execute(
@@ -225,13 +277,12 @@ class MonitoringService:
                     and_(
                         Subscription.status == SubscriptionStatus.ACTIVE.value,
                         Subscription.autopay_enabled == True,
-                        Subscription.is_trial == False  # Автооплата только для платных
+                        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
@@ -248,24 +299,20 @@ class MonitoringService:
                 
                 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)
                         
@@ -279,7 +326,6 @@ class MonitoringService:
                         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}")
@@ -294,54 +340,101 @@ class MonitoringService:
         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")
+            message = """
+    ❌ <b>Подписка истекла</b>
+
+    Ваша подписка истекла. Для восстановления доступа продлите подписку.
+
+    🔧 Доступ к серверам заблокирован до продления.
+    """
+            
+            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+            
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="💎 Купить подписку", callback_data="menu_buy")],
+                [InlineKeyboardButton(text="💳 Пополнить баланс", callback_data="balance_topup")]
+            ])
+            
+            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_subscription_expiring_notification(self, user: User, subscription: Subscription, days: int):
-        """Уведомление об истечении подписки через N дней"""
         try:
+            from app.utils.formatters import format_days_declension
+            
             texts = get_texts(user.language)
-            message = texts.SUBSCRIPTION_EXPIRING.format(days=days)
-            await self.bot.send_message(user.telegram_id, message, parse_mode="HTML")
+            days_text = format_days_declension(days, user.language)
+            
+            if subscription.autopay_enabled:
+                autopay_status = "✅ Включен - подписка продлится автоматически"
+                action_text = f"💰 Убедитесь, что на балансе достаточно средств: {texts.format_price(user.balance_kopeks)}"
+            else:
+                autopay_status = "❌ Отключен - не забудьте продлить вручную!"
+                action_text = "💡 Включите автоплатеж или продлите подписку вручную"
+            
+            message = f"""
+    ⚠️ <b>Подписка истекает через {days_text}!</b>
+
+    Ваша платная подписка истекает {subscription.end_date.strftime("%d.%m.%Y %H:%M")}.
+
+    💳 <b>Автоплатеж:</b> {autopay_status}
+
+    {action_text}
+    """
+            
+            from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+            
+            keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                [InlineKeyboardButton(text="⏰ Продлить подписку", callback_data="subscription_extend")],
+                [InlineKeyboardButton(text="💳 Пополнить баланс", callback_data="balance_topup")],
+                [InlineKeyboardButton(text="📱 Моя подписка", callback_data="menu_subscription")]
+            ])
+            
+            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_trial_ending_notification(self, user: User, subscription: Subscription):
-        """Уведомление об окончании тестовой подписки через 2 часа"""
         try:
             texts = get_texts(user.language)
             
-            # Создаем специальное сообщение для тестовой подписки
             message = f"""
-🎁 <b>Тестовая подписка скоро закончится!</b>
+    🎁 <b>Тестовая подписка скоро закончится!</b>
 
-Ваша тестовая подписка истекает через 2 часа.
+    Ваша тестовая подписка истекает через 2 часа.
 
-💎 <b>Не хотите остаться без VPN?</b>
-Переходите на полную подписку со скидкой!
+    💎 <b>Не хотите остаться без VPN?</b>
+    Переходите на полную подписку со скидкой!
 
-🔥 <b>Специальное предложение:</b>
-• 30 дней всего за {settings.format_price(settings.PRICE_30_DAYS)}
-• Безлимитный трафик
-• Все серверы доступны
-• Поддержка до 3 устройств
+    🔥 <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")]
+                [InlineKeyboardButton(text="💎 Купить подписку", callback_data="menu_buy")],
+                [InlineKeyboardButton(text="💰 Пополнить баланс", callback_data="balance_topup")]
             ])
             
             await self.bot.send_message(
@@ -355,7 +448,6 @@ class MonitoringService:
             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(
@@ -367,7 +459,6 @@ class MonitoringService:
             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(
@@ -375,11 +466,11 @@ class MonitoringService:
                 required=settings.format_price(required)
             )
             
-            # Добавляем кнопку пополнения баланса
             from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
             
             keyboard = InlineKeyboardMarkup(inline_keyboard=[
-                [InlineKeyboardButton(text="💰 Пополнить баланс", callback_data="balance_top_up")]
+                [InlineKeyboardButton(text="💳 Пополнить баланс", callback_data="balance_topup")],
+                [InlineKeyboardButton(text="📱 Моя подписка", callback_data="menu_subscription")]
             ])
             
             await self.bot.send_message(
@@ -392,7 +483,6 @@ class MonitoringService:
         except Exception as e:
             logger.error(f"Ошибка отправки уведомления о неудачном автоплатеже пользователю {user.telegram_id}: {e}")
     
-    # Остальные методы остаются без изменений...
     async def _cleanup_inactive_users(self, db: AsyncSession):
         try:
             now = datetime.utcnow()
@@ -523,7 +613,6 @@ class MonitoringService:
     
     async def force_check_subscriptions(self, db: AsyncSession) -> Dict[str, int]:
         try:
-            # Проверяем истекшие
             expired_subscriptions = await get_expired_subscriptions(db)
             expired_count = 0
             
@@ -618,4 +707,4 @@ class MonitoringService:
             return 0
 
 
-monitoring_service = MonitoringService()
+monitoring_service = MonitoringService()

app/services/payment_service.py

@@ -1,11 +1,18 @@
 import logging
 import hashlib
 import hmac
-from typing import Optional
+from typing import Optional, Dict, Any
+from datetime import datetime
 from aiogram import Bot
 from aiogram.types import LabeledPrice
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.config import settings
+from app.services.yookassa_service import YooKassaService
+from app.database.crud.yookassa import create_yookassa_payment, link_yookassa_payment_to_transaction
+from app.database.crud.transaction import create_transaction
+from app.database.crud.user import add_user_balance, get_user_by_id
+from app.database.models import TransactionType, PaymentMethod
 
 logger = logging.getLogger(__name__)
 
@@ -14,6 +21,7 @@ class PaymentService:
     
     def __init__(self, bot: Optional[Bot] = None):
         self.bot = bot
+        self.yookassa_service = YooKassaService() if settings.is_yookassa_enabled() else None
     
     async def create_stars_invoice(
         self,
@@ -44,6 +52,237 @@ class PaymentService:
             logger.error(f"Ошибка создания Stars invoice: {e}")
             raise
     
+    async def create_yookassa_payment(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        amount_kopeks: int,
+        description: str,
+        receipt_email: Optional[str] = None,
+        receipt_phone: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Optional[Dict[str, Any]]:
+        
+        if not self.yookassa_service:
+            logger.error("YooKassa сервис не инициализирован")
+            return None
+        
+        try:
+            amount_rubles = amount_kopeks / 100
+            
+            payment_metadata = metadata or {}
+            payment_metadata.update({
+                "user_id": str(user_id),
+                "amount_kopeks": str(amount_kopeks),
+                "type": "balance_topup"
+            })
+            
+            yookassa_response = await self.yookassa_service.create_payment(
+                amount=amount_rubles,
+                currency="RUB",
+                description=description,
+                metadata=payment_metadata,
+                receipt_email=receipt_email,
+                receipt_phone=receipt_phone
+            )
+            
+            if not yookassa_response or yookassa_response.get("error"):
+                logger.error(f"Ошибка создания платежа YooKassa: {yookassa_response}")
+                return None
+            
+            yookassa_created_at = None
+            if yookassa_response.get("created_at"):
+                try:
+                    dt_with_tz = datetime.fromisoformat(
+                        yookassa_response["created_at"].replace('Z', '+00:00')
+                    )
+                    yookassa_created_at = dt_with_tz.replace(tzinfo=None)
+                except Exception as e:
+                    logger.warning(f"Не удалось парсить created_at: {e}")
+                    yookassa_created_at = None
+            
+            local_payment = await create_yookassa_payment(
+                db=db,
+                user_id=user_id,
+                yookassa_payment_id=yookassa_response["id"],
+                amount_kopeks=amount_kopeks,
+                currency="RUB",
+                description=description,
+                status=yookassa_response["status"],
+                confirmation_url=yookassa_response.get("confirmation_url"),
+                metadata_json=payment_metadata,
+                payment_method_type=None, 
+                yookassa_created_at=yookassa_created_at, 
+                test_mode=yookassa_response.get("test_mode", False)
+            )
+            
+            logger.info(f"Создан платеж YooKassa {yookassa_response['id']} на {amount_rubles}₽ для пользователя {user_id}")
+            
+            return {
+                "local_payment_id": local_payment.id,
+                "yookassa_payment_id": yookassa_response["id"],
+                "confirmation_url": yookassa_response.get("confirmation_url"),
+                "amount_kopeks": amount_kopeks,
+                "amount_rubles": amount_rubles,
+                "status": yookassa_response["status"],
+                "created_at": local_payment.created_at
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка создания платежа YooKassa: {e}")
+            return None
+    
+    async def process_yookassa_webhook(self, db: AsyncSession, webhook_data: dict) -> bool:
+        try:
+            from app.database.crud.yookassa import (
+                get_yookassa_payment_by_id, 
+                update_yookassa_payment_status,
+                link_yookassa_payment_to_transaction
+            )
+            from app.database.crud.transaction import create_transaction
+            from app.database.models import TransactionType, PaymentMethod
+            
+            payment_object = webhook_data.get("object", {})
+            yookassa_payment_id = payment_object.get("id")
+            status = payment_object.get("status")
+            paid = payment_object.get("paid", False)
+            
+            if not yookassa_payment_id:
+                logger.error("Webhook без ID платежа")
+                return False
+            
+            payment = await get_yookassa_payment_by_id(db, yookassa_payment_id)
+            if not payment:
+                logger.error(f"Платеж не найден в БД: {yookassa_payment_id}")
+                return False
+            
+            captured_at = None
+            if status == "succeeded":
+                captured_at = datetime.utcnow() 
+            
+            updated_payment = await update_yookassa_payment_status(
+                db, 
+                yookassa_payment_id, 
+                status, 
+                is_paid=paid,
+                is_captured=(status == "succeeded"),
+                captured_at=captured_at,
+                payment_method_type=payment_object.get("payment_method", {}).get("type")
+            )
+            
+            if status == "succeeded" and paid and not updated_payment.transaction_id:
+                transaction = await create_transaction(
+                    db,
+                    user_id=updated_payment.user_id,
+                    type=TransactionType.DEPOSIT, 
+                    amount_kopeks=updated_payment.amount_kopeks,
+                    description=f"Пополнение через YooKassa ({yookassa_payment_id[:8]}...)",
+                    payment_method=PaymentMethod.YOOKASSA,
+                    external_id=yookassa_payment_id,
+                    is_completed=True
+                )
+                
+                await link_yookassa_payment_to_transaction(
+                    db, yookassa_payment_id, transaction.id
+                )
+                
+                user = await get_user_by_id(db, updated_payment.user_id)
+                if user:
+                    await add_user_balance(db, user, updated_payment.amount_kopeks, f"Пополнение YooKassa: {updated_payment.amount_kopeks/100:.2f}₽")
+                    
+                    if self.bot:
+                        try:
+                            await self.bot.send_message(
+                                user.telegram_id,
+                                f"✅ <b>Пополнение успешно!</b>\n\n"
+                                f"💰 Сумма: {settings.format_price(updated_payment.amount_kopeks)}\n"
+                                f"🏦 Способ: Банковская карта\n"
+                                f"🆔 Транзакция: {yookassa_payment_id[:8]}...\n\n"
+                                f"Баланс пополнен автоматически!",
+                                parse_mode="HTML"
+                            )
+                            logger.info(f"✅ Отправлено уведомление пользователю {user.telegram_id} о пополнении на {updated_payment.amount_kopeks/100:.2f}₽")
+                        except Exception as e:
+                            logger.error(f"Ошибка отправки уведомления о пополнении: {e}")
+                else:
+                    logger.error(f"Пользователь с ID {updated_payment.user_id} не найден при пополнении баланса")
+                    return False
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка обработки YooKassa webhook: {e}", exc_info=True)
+            return False
+    
+    async def _process_successful_yookassa_payment(
+        self,
+        db: AsyncSession,
+        payment: "YooKassaPayment"
+    ) -> bool:
+        
+        try:
+            transaction = await create_transaction(
+                db=db,
+                user_id=payment.user_id,
+                transaction_type=TransactionType.DEPOSIT,
+                amount_kopeks=payment.amount_kopeks,
+                description=f"Пополнение через YooKassa: {payment.description}",
+                payment_method=PaymentMethod.YOOKASSA,
+                external_id=payment.yookassa_payment_id,
+                is_completed=True
+            )
+            
+            await link_yookassa_payment_to_transaction(
+                db=db,
+                yookassa_payment_id=payment.yookassa_payment_id,
+                transaction_id=transaction.id
+            )
+            
+            user = await get_user_by_id(db, payment.user_id)
+            if user:
+                await add_user_balance(db, user, payment.amount_kopeks, f"Пополнение YooKassa: {payment.amount_kopeks/100:.2f}₽")
+            
+            logger.info(f"Успешно обработан платеж YooKassa {payment.yookassa_payment_id}: "
+                       f"пользователь {payment.user_id} получил {payment.amount_kopeks/100}₽")
+            
+            if self.bot and user:
+                try:
+                    await self._send_payment_success_notification(
+                        user.telegram_id, 
+                        payment.amount_kopeks
+                    )
+                except Exception as e:
+                    logger.error(f"Ошибка отправки уведомления о платеже: {e}")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Ошибка обработки успешного платежа YooKassa {payment.yookassa_payment_id}: {e}")
+            return False
+    
+    async def _send_payment_success_notification(
+        self,
+        telegram_id: int,
+        amount_kopeks: int
+    ) -> None:
+        
+        if not self.bot:
+            return
+        
+        try:
+            message = (f"✅ <b>Платеж успешно завершен!</b>\n\n"
+                      f"💰 Сумма: {settings.format_price(amount_kopeks)}\n"
+                      f"💳 Способ: Банковская карта (YooKassa)\n\n"
+                      f"Средства зачислены на ваш баланс!")
+            
+            await self.bot.send_message(
+                chat_id=telegram_id,
+                text=message,
+                parse_mode="HTML"
+            )
+        except Exception as e:
+            logger.error(f"Ошибка отправки уведомления пользователю {telegram_id}: {e}")
+    
     async def create_tribute_payment(
         self,
         amount_kopeks: int,
@@ -104,12 +343,9 @@ class PaymentService:
     ) -> bool:
         
         try:
-            # Здесь должна быть логика обработки платежа
-            # Например, пополнение баланса пользователя
-            
             logger.info(f"Обработан успешный платеж: {payment_id}, {amount_kopeks/100}₽, {user_id}")
             return True
             
         except Exception as e:
             logger.error(f"Ошибка обработки платежа: {e}")
-            return False
+            return False

app/services/promocode_service.py

@@ -86,32 +86,59 @@ class PromoCodeService:
             effects.append(f"💰 Баланс пополнен на {balance_bonus_rubles}₽")
         
         if promocode.subscription_days > 0:
-            from app.database.crud.subscription import create_paid_subscription
+            from app.config import settings
             
             subscription = await get_subscription_by_user_id(db, user.id)
             
             if subscription:
                 await extend_subscription(db, subscription, promocode.subscription_days)
+                
+                await self.subscription_service.update_remnawave_user(db, subscription)
+                
                 effects.append(f"⏰ Подписка продлена на {promocode.subscription_days} дней")
+                logger.info(f"✅ Подписка пользователя {user.telegram_id} продлена на {promocode.subscription_days} дней в RemnaWave с текущими сквадами")
+                
             else:
-                await create_paid_subscription(
+                from app.database.crud.subscription import create_paid_subscription
+                
+                trial_squads = []
+                if hasattr(settings, 'TRIAL_SQUAD_UUID') and settings.TRIAL_SQUAD_UUID:
+                    trial_squads = [settings.TRIAL_SQUAD_UUID]
+                
+                new_subscription = await create_paid_subscription(
                     db=db,
                     user_id=user.id,
                     duration_days=promocode.subscription_days,
-                    traffic_limit_gb=0,
+                    traffic_limit_gb=0, 
                     device_limit=1,
-                    connected_squads=[]
+                    connected_squads=trial_squads 
                 )
+                
+                await self.subscription_service.create_remnawave_user(db, new_subscription)
+                
                 effects.append(f"🎉 Получена подписка на {promocode.subscription_days} дней")
+                logger.info(f"✅ Создана новая подписка для пользователя {user.telegram_id} на {promocode.subscription_days} дней с триал сквадом {trial_squads}")
         
         if promocode.type == PromoCodeType.TRIAL_SUBSCRIPTION.value:
             from app.database.crud.subscription import create_trial_subscription
+            from app.config import settings
             
             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("🎁 Активирована тестовая подписка")
+            
+            if not subscription:
+                trial_days = promocode.subscription_days if promocode.subscription_days > 0 else settings.TRIAL_DURATION_DAYS
+                
+                trial_subscription = await create_trial_subscription(
+                    db, 
+                    user.id, 
+                    duration_days=trial_days 
+                )
+                
+                await self.subscription_service.create_remnawave_user(db, trial_subscription)
+                
+                effects.append(f"🎁 Активирована тестовая подписка на {trial_days} дней")
+                logger.info(f"✅ Создана триал подписка для пользователя {user.telegram_id} на {trial_days} дней")
             else:
-                effects.append("ℹ️ Тестовая подписка уже недоступна")
+                effects.append("ℹ️ У вас уже есть активная подписка")
         
-        return "\n".join(effects) if effects else "✅ Промокод активирован"
+        return "\n".join(effects) if effects else "✅ Промокод активирован"

app/services/referral_service.py

@@ -20,7 +20,7 @@ async def process_referral_registration(
         referrer = await get_user_by_id(db, referrer_id)
         
         if not new_user or not referrer:
-            logger.error(f"Пользователи не найдены: {new_user_id}, {referrer_id}")
+            logger.error(f"Пользователи не найдены: new_user_id={new_user_id}, referrer_id={referrer_id}")
             return False
         
         if new_user.referred_by_id != referrer_id:
@@ -81,9 +81,13 @@ async def process_referral_purchase(
         
         logger.info(f"🔍 Покупка реферала {user_id}: первая = {is_first_purchase}, сумма = {purchase_amount_kopeks/100}₽")
         
-        if is_first_purchase:
+        if is_first_purchase and settings.REFERRAL_REGISTRATION_REWARD > 0:
             reward_amount = settings.REFERRAL_REGISTRATION_REWARD
             
+            if reward_amount > 1000000: 
+                logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА: reward_amount = {reward_amount} слишком большой! Проверьте настройки REFERRAL_REGISTRATION_REWARD")
+                reward_amount = 10000 
+            
             await add_user_balance(
                 db, referrer, reward_amount,
                 f"Реферальная награда за первую покупку {user.full_name}"
@@ -100,12 +104,18 @@ async def process_referral_purchase(
             
             logger.info(f"🎉 Первая покупка реферала: {referrer.telegram_id} получил {reward_amount/100}₽")
         
-        commission_amount = int(purchase_amount_kopeks * settings.REFERRAL_COMMISSION_PERCENT / 100)
+        if not (0 <= settings.REFERRAL_COMMISSION_PERCENT <= 100):
+            logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА: REFERRAL_COMMISSION_PERCENT = {settings.REFERRAL_COMMISSION_PERCENT} некорректный! Должен быть от 0 до 100")
+            commission_percent = 10 
+        else:
+            commission_percent = settings.REFERRAL_COMMISSION_PERCENT
+            
+        commission_amount = int(purchase_amount_kopeks * commission_percent / 100)
         
         if commission_amount > 0:
             await add_user_balance(
                 db, referrer, commission_amount,
-                f"Комиссия {settings.REFERRAL_COMMISSION_PERCENT}% с покупки {user.full_name}"
+                f"Комиссия {commission_percent}% с покупки {user.full_name}"
             )
             
             await create_referral_earning(
@@ -128,6 +138,8 @@ async def process_referral_purchase(
         
     except Exception as e:
         logger.error(f"Ошибка обработки покупки реферала: {e}")
+        import traceback
+        logger.error(f"Полный traceback: {traceback.format_exc()}")
         return False
 
 
@@ -141,7 +153,7 @@ async def get_referral_stats_for_user(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()
+        invited_count = invited_count_result.scalar() or 0
         
         paid_referrals_result = await db.execute(
             select(func.count(User.id)).where(
@@ -149,13 +161,13 @@ async def get_referral_stats_for_user(db: AsyncSession, user_id: int) -> dict:
                 User.has_had_paid_subscription == True
             )
         )
-        paid_referrals_count = paid_referrals_result.scalar()
+        paid_referrals_count = paid_referrals_result.scalar() or 0
         
-        total_earned = await get_referral_earnings_sum(db, user_id)
+        total_earned = await get_referral_earnings_sum(db, user_id) or 0
         
         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)
+        month_earned = await get_referral_earnings_sum(db, user_id, start_date=month_ago) or 0
         
         return {
             "invited_count": invited_count,
@@ -171,4 +183,4 @@ async def get_referral_stats_for_user(db: AsyncSession, user_id: int) -> dict:
             "paid_referrals_count": 0,
             "total_earned_kopeks": 0,
             "month_earned_kopeks": 0
-        }
+        }

app/services/remnawave_service.py

@@ -1,6 +1,9 @@
 import logging
 from typing import Dict, List, Any, Optional
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import delete
+from datetime import datetime, timedelta
+import re
 
 from app.config import settings
 from app.external.remnawave_api import (
@@ -9,7 +12,10 @@ from app.external.remnawave_api import (
 )
 from app.database.crud.user import get_users_list, get_user_by_telegram_id, update_user
 from app.database.crud.subscription import get_subscription_by_user_id, update_subscription_usage
-from app.database.models import User
+from app.database.models import (
+    User, SubscriptionServer, Transaction, ReferralEarning, 
+    PromoCodeUse, SubscriptionStatus
+)
 
 logger = logging.getLogger(__name__)
 
@@ -21,6 +27,34 @@ class RemnaWaveService:
             base_url=settings.REMNAWAVE_API_URL,
             api_key=settings.REMNAWAVE_API_KEY
         )
+
+    def _parse_remnawave_date(self, date_str: str) -> datetime:
+        if not date_str:
+            return datetime.utcnow() + timedelta(days=30)
+        
+        try:
+            
+            cleaned_date = date_str.strip()
+            
+            if cleaned_date.endswith('Z'):
+                cleaned_date = cleaned_date[:-1] + '+00:00'
+            
+            if '+00:00+00:00' in cleaned_date:
+                cleaned_date = cleaned_date.replace('+00:00+00:00', '+00:00')
+            
+            cleaned_date = re.sub(r'(\+\d{2}:\d{2})\+\d{2}:\d{2}$', r'\1', cleaned_date)
+            
+            parsed_date = datetime.fromisoformat(cleaned_date)
+            
+            if parsed_date.tzinfo is not None:
+                parsed_date = parsed_date.replace(tzinfo=None)
+            
+            logger.debug(f"Успешно распарсена дата: {date_str} -> {parsed_date}")
+            return parsed_date
+            
+        except Exception as e:
+            logger.warning(f"⚠️ Не удалось распарсить дату '{date_str}': {e}. Используем дефолтную дату.")
+            return datetime.utcnow() + timedelta(days=30)
     
     async def get_system_statistics(self) -> Dict[str, Any]:
             try:
@@ -54,7 +88,6 @@ class RemnaWaveService:
                         logger.error(f"Ошибка получения статистики нод: {e}")
                         nodes_stats = {}
                 
-                    from datetime import datetime
                 
                     total_download = sum(node.get('downloadBytes', 0) for node in realtime_usage)
                     total_upload = sum(node.get('uploadBytes', 0) for node in realtime_usage)
@@ -195,7 +228,6 @@ class RemnaWaveService:
                     'GBPS': 1024 ** 3
                 }
             
-                import re
                 match = re.match(r'([0-9.,]+)([A-Z]+)', bandwidth_str)
                 if match:
                     value_str = match.group(1).replace(',', '.') 
@@ -392,95 +424,186 @@ class RemnaWaveService:
     
     async def sync_users_from_panel(self, db: AsyncSession, sync_type: str = "all") -> Dict[str, int]:
         try:
-            stats = {"created": 0, "updated": 0, "errors": 0}
-        
+            stats = {"created": 0, "updated": 0, "errors": 0, "deleted": 0}
+            
             logger.info(f"🔄 Начинаем синхронизацию типа: {sync_type}")
-        
+            
             async with self.api as api:
-                panel_users_data = await api._make_request('GET', '/api/users')
-                panel_users = panel_users_data['response']['users']
-            
-                logger.info(f"👥 Найдено пользователей в панели: {len(panel_users)}")
-            
-                for i, panel_user in enumerate(panel_users):
-                    try:
-                        telegram_id = panel_user.get('telegramId')
-                        if not telegram_id:
-                            logger.debug(f"➡️ Пропускаем пользователя без telegram_id")
-                            continue
+                panel_users = []
+                start = 0
+                size = 100 
+                
+                while True:
+                    logger.info(f"📥 Загружаем пользователей: start={start}, size={size}")
+                    
+                    response = await api.get_all_users(start=start, size=size)
+                    users_batch = response['users']
+                    total_users = response['total']
+                    
+                    logger.info(f"📊 Получено {len(users_batch)} пользователей из {total_users}")
+                    
+                    for user_obj in users_batch:
+                        user_dict = {
+                            'uuid': user_obj.uuid,
+                            'shortUuid': user_obj.short_uuid,
+                            'username': user_obj.username,
+                            'status': user_obj.status.value,
+                            'telegramId': user_obj.telegram_id,
+                            'expireAt': user_obj.expire_at.isoformat() + 'Z',
+                            'trafficLimitBytes': user_obj.traffic_limit_bytes,
+                            'usedTrafficBytes': user_obj.used_traffic_bytes,
+                            'hwidDeviceLimit': user_obj.hwid_device_limit,
+                            'subscriptionUrl': user_obj.subscription_url,
+                            'activeInternalSquads': user_obj.active_internal_squads
+                        }
+                        panel_users.append(user_dict)
+                    
+                    if len(users_batch) < size:
+                        break
                         
-                        logger.info(f"🔄 Обрабатываем пользователя {i+1}/{len(panel_users)}: {telegram_id}")
+                    start += size
                     
-                        db_user = await get_user_by_telegram_id(db, telegram_id)
+                    if start > total_users:
+                        break
+                
+                logger.info(f"✅ Всего загружено пользователей из панели: {len(panel_users)}")
+            
+            bot_users = await get_users_list(db, offset=0, limit=10000)
+            bot_users_by_telegram_id = {user.telegram_id: user for user in bot_users}
+            
+            logger.info(f"📊 Пользователей в боте: {len(bot_users)}")
+            
+            panel_users_with_tg = [
+                user for user in panel_users 
+                if user.get('telegramId') is not None
+            ]
+            
+            logger.info(f"📊 Пользователей в панели с Telegram ID: {len(panel_users_with_tg)}")
+            
+            panel_telegram_ids = set()
+            
+            for i, panel_user in enumerate(panel_users_with_tg):
+                try:
+                    telegram_id = panel_user.get('telegramId')
+                    if not telegram_id:
+                        continue
                     
-                        if not db_user:
-                            if sync_type in ["new_only", "all"]:
-                                logger.info(f"📝 Создание пользователя для telegram_id {telegram_id}")
-                                
-                                from app.database.crud.user import create_user
+                    panel_telegram_ids.add(telegram_id)
+                    
+                    if (i + 1) % 10 == 0: 
+                        logger.info(f"🔄 Обрабатываем пользователя {i+1}/{len(panel_users_with_tg)}: {telegram_id}")
+                    
+                    db_user = bot_users_by_telegram_id.get(telegram_id)
+                    
+                    if not db_user:
+                        if sync_type in ["new_only", "all"]:
+                            logger.info(f"🆕 Создание пользователя для telegram_id {telegram_id}")
                             
-                                db_user = await create_user(
-                                    db=db,
-                                    telegram_id=telegram_id,
-                                    username=panel_user.get('username') or f"user_{telegram_id}",
-                                    first_name=f"Panel User {telegram_id}",
-                                    language="ru"
-                                )
+                            from app.database.crud.user import create_user
                             
+                            db_user = await create_user(
+                                db=db,
+                                telegram_id=telegram_id,
+                                username=panel_user.get('username') or f"user_{telegram_id}",
+                                first_name=f"Panel User {telegram_id}",
+                                language="ru"
+                            )
+                            
+                            await update_user(db, db_user, remnawave_uuid=panel_user.get('uuid'))
+                            
+                            await self._create_subscription_from_panel_data(db, db_user, panel_user)
+                            
+                            stats["created"] += 1
+                            logger.info(f"✅ Создан пользователь {telegram_id} с подпиской")
+                    
+                    else:
+                        if sync_type in ["update_only", "all"]:
+                            logger.debug(f"🔄 Обновление пользователя {telegram_id}")
+                            
+                            if not db_user.remnawave_uuid:
                                 await update_user(db, db_user, remnawave_uuid=panel_user.get('uuid'))
                             
-                                await self._create_subscription_from_panel_data(db, db_user, panel_user)
+                            await self._update_subscription_from_panel_data(db, db_user, panel_user)
                             
-                                stats["created"] += 1
-                                logger.info(f"✅ Создан пользователь {telegram_id} с подпиской")
+                            stats["updated"] += 1
+                            logger.debug(f"✅ Обновлён пользователь {telegram_id}")
                             
-                        else:
-                            if sync_type in ["update_only", "all"]:
-                                logger.debug(f"🔄 Обновление пользователя {telegram_id}")
+                except Exception as user_error:
+                    logger.error(f"❌ Ошибка обработки пользователя {telegram_id}: {user_error}")
+                    stats["errors"] += 1
+                    continue
+            
+            if sync_type == "all":
+                logger.info("🗑️ Деактивация подписок пользователей, отсутствующих в панели...")
+                
+                for telegram_id, db_user in bot_users_by_telegram_id.items():
+                    if telegram_id not in panel_telegram_ids and db_user.subscription:
+                        try:
+                            logger.info(f"🗑️ Деактивация подписки пользователя {telegram_id} (нет в панели)")
                             
-                                if not db_user.remnawave_uuid:
-                                    await update_user(db, db_user, remnawave_uuid=panel_user.get('uuid'))
+                            subscription = db_user.subscription
                             
-                                await self._update_subscription_from_panel_data(db, db_user, panel_user)
+                            if db_user.remnawave_uuid:
+                                try:
+                                    async with self.api as api:
+                                        devices_reset = await api.reset_user_devices(db_user.remnawave_uuid)
+                                        if devices_reset:
+                                            logger.info(f"🔧 Сброшены HWID устройства для пользователя {telegram_id}")
+                                except Exception as hwid_error:
+                                    logger.error(f"❌ Ошибка сброса HWID устройств для {telegram_id}: {hwid_error}")
                             
-                                stats["updated"] += 1
-                                logger.debug(f"✅ Обновлён пользователь {telegram_id}")
+                            try:
+                                from sqlalchemy import delete
+                                from app.database.models import SubscriptionServer
+                                
+                                await db.execute(
+                                    delete(SubscriptionServer).where(
+                                        SubscriptionServer.subscription_id == subscription.id
+                                    )
+                                )
+                                logger.info(f"🗑️ Удалены серверы подписки для {telegram_id}")
+                            except Exception as servers_error:
+                                logger.warning(f"⚠️ Не удалось удалить серверы подписки: {servers_error}")
                             
-                    except Exception as user_error:
-                        logger.error(f"❌ Ошибка обработки пользователя {telegram_id}: {user_error}")
-                        stats["errors"] += 1
-                        continue
-        
-            logger.info(f"🎯 Синхронизация завершена: создано {stats['created']}, обновлено {stats['updated']}, ошибок {stats['errors']}")
+                            from app.database.models import SubscriptionStatus
+                            
+                            subscription.status = SubscriptionStatus.DISABLED.value
+                            subscription.is_trial = True 
+                            subscription.end_date = datetime.utcnow()
+                            subscription.traffic_limit_gb = 0
+                            subscription.traffic_used_gb = 0.0
+                            subscription.device_limit = 1
+                            subscription.connected_squads = []
+                            subscription.autopay_enabled = False
+                            subscription.remnawave_short_uuid = None
+                            subscription.subscription_url = ""
+                            
+                            db_user.remnawave_uuid = None
+                            
+                            await db.commit()
+                            
+                            stats["deleted"] += 1
+                            logger.info(f"✅ Деактивирована подписка пользователя {telegram_id} (сохранен баланс)")
+                            
+                        except Exception as delete_error:
+                            logger.error(f"❌ Ошибка деактивации подписки {telegram_id}: {delete_error}")
+                            stats["errors"] += 1
+                            await db.rollback()
+            
+            logger.info(f"🎯 Синхронизация завершена: создано {stats['created']}, обновлено {stats['updated']}, деактивировано {stats['deleted']}, ошибок {stats['errors']}")
             return stats
         
         except Exception as e:
             logger.error(f"❌ Критическая ошибка синхронизации пользователей: {e}")
-            return {"created": 0, "updated": 0, "errors": 1}
+            return {"created": 0, "updated": 0, "errors": 1, "deleted": 0}
 
     async def _create_subscription_from_panel_data(self, db: AsyncSession, user, panel_user):
         try:
             from app.database.crud.subscription import create_subscription
             from app.database.models import SubscriptionStatus
-            from datetime import datetime, timedelta
-            import pytz
         
             expire_at_str = panel_user.get('expireAt', '')
-            try:
-                if expire_at_str:
-                    if expire_at_str.endswith('Z'):
-                        expire_at_str = expire_at_str[:-1] + '+00:00'
-                
-                    expire_at = datetime.fromisoformat(expire_at_str)
-                
-                    if expire_at.tzinfo is not None:
-                        expire_at = expire_at.replace(tzinfo=None)
-                    
-                else:
-                    expire_at = datetime.utcnow() + timedelta(days=30)
-            except Exception as date_error:
-                logger.warning(f"⚠️ Ошибка парсинга даты {expire_at_str}: {date_error}")
-                expire_at = datetime.utcnow() + timedelta(days=30)
+            expire_at = self._parse_remnawave_date(expire_at_str)
         
             panel_status = panel_user.get('status', 'ACTIVE')
             current_time = datetime.utcnow()
@@ -549,7 +672,7 @@ class RemnaWaveService:
     async def _update_subscription_from_panel_data(self, db: AsyncSession, user, panel_user):
         try:
             from app.database.crud.subscription import get_subscription_by_user_id
-            from datetime import datetime, timedelta
+            from app.database.models import SubscriptionStatus
         
             subscription = await get_subscription_by_user_id(db, user.id)
             
@@ -557,17 +680,55 @@ class RemnaWaveService:
                 await self._create_subscription_from_panel_data(db, user, panel_user)
                 return
         
+            panel_status = panel_user.get('status', 'ACTIVE')
+            expire_at_str = panel_user.get('expireAt', '')
+            
+            if expire_at_str:
+                expire_at = self._parse_remnawave_date(expire_at_str)
+                
+                if abs((subscription.end_date - expire_at).total_seconds()) > 60: 
+                    subscription.end_date = expire_at
+                    logger.debug(f"Обновлена дата окончания подписки до {expire_at}")
+            
+            current_time = datetime.utcnow()
+            if panel_status == 'ACTIVE' and subscription.end_date > current_time:
+                new_status = SubscriptionStatus.ACTIVE.value
+            elif subscription.end_date <= current_time:
+                new_status = SubscriptionStatus.EXPIRED.value
+            elif panel_status == 'DISABLED':
+                new_status = SubscriptionStatus.DISABLED.value
+            else:
+                new_status = subscription.status 
+            
+            if subscription.status != new_status:
+                subscription.status = new_status
+                logger.debug(f"Обновлен статус подписки: {new_status}")
+        
             used_traffic_bytes = panel_user.get('usedTrafficBytes', 0)
             traffic_used_gb = used_traffic_bytes / (1024**3)
         
             if abs(subscription.traffic_used_gb - traffic_used_gb) > 0.01:
                 subscription.traffic_used_gb = traffic_used_gb
+                logger.debug(f"Обновлен использованный трафик: {traffic_used_gb} GB")
+            
+            traffic_limit_bytes = panel_user.get('trafficLimitBytes', 0)
+            traffic_limit_gb = traffic_limit_bytes // (1024**3) if traffic_limit_bytes > 0 else 0
+            
+            if subscription.traffic_limit_gb != traffic_limit_gb:
+                subscription.traffic_limit_gb = traffic_limit_gb
+                logger.debug(f"Обновлен лимит трафика: {traffic_limit_gb} GB")
+            
+            device_limit = panel_user.get('hwidDeviceLimit', 1) or 1
+            if subscription.device_limit != device_limit:
+                subscription.device_limit = device_limit
+                logger.debug(f"Обновлен лимит устройств: {device_limit}")
         
             if not subscription.remnawave_short_uuid:
                 subscription.remnawave_short_uuid = panel_user.get('shortUuid')
         
-            if not subscription.subscription_url:
-                subscription.subscription_url = panel_user.get('subscriptionUrl', '')
+            panel_url = panel_user.get('subscriptionUrl', '')
+            if not subscription.subscription_url or subscription.subscription_url != panel_url:
+                subscription.subscription_url = panel_url
         
             active_squads = panel_user.get('activeInternalSquads', [])
             squad_uuids = []
@@ -578,14 +739,19 @@ class RemnaWaveService:
                     elif isinstance(squad, str):
                         squad_uuids.append(squad)
         
-            if squad_uuids != subscription.connected_squads:
+            current_squads = set(subscription.connected_squads or [])
+            new_squads = set(squad_uuids)
+            
+            if current_squads != new_squads:
                 subscription.connected_squads = squad_uuids
+                logger.debug(f"Обновлены подключенные сквады: {squad_uuids}")
         
             await db.commit()
             logger.debug(f"✅ Обновлена подписка для пользователя {user.telegram_id}")
         
         except Exception as e:
             logger.error(f"❌ Ошибка обновления подписки для пользователя {user.telegram_id}: {e}")
+            await db.rollback()
     
     async def sync_users_to_panel(self, db: AsyncSession) -> Dict[str, int]:
         try:
@@ -627,7 +793,6 @@ class RemnaWaveService:
                                 active_internal_squads=subscription.connected_squads
                             )
                             
-                            # Обновляем UUID в нашей базе
                             await update_user(db, user, remnawave_uuid=new_user.uuid)
                             subscription.remnawave_short_uuid = new_user.short_uuid
                             await db.commit()
@@ -829,7 +994,6 @@ class RemnaWaveService:
                     node_realtime = stats
                     break
             
-            from datetime import datetime, timedelta
             end_date = datetime.now()
             start_date = end_date - timedelta(days=7)
             
@@ -865,4 +1029,355 @@ class RemnaWaveService:
         
         except Exception as e:
             logger.error(f"Ошибка валидации данных пользователя: {e}")
-            return False
+            return False
+
+    async def force_cleanup_user_data(self, db: AsyncSession, user: User) -> bool:
+        try:
+            logger.info(f"🗑️ ПРИНУДИТЕЛЬНАЯ полная очистка данных пользователя {user.telegram_id}")
+            
+            if user.remnawave_uuid:
+                try:
+                    async with self.api as api:
+                        devices_reset = await api.reset_user_devices(user.remnawave_uuid)
+                        if devices_reset:
+                            logger.info(f"🔧 Сброшены HWID устройства для {user.telegram_id}")
+                except Exception as hwid_error:
+                    logger.warning(f"⚠️ Ошибка сброса HWID устройств: {hwid_error}")
+            
+            try:
+                from sqlalchemy import delete
+                from app.database.models import (
+                    SubscriptionServer, Transaction, ReferralEarning, 
+                    PromoCodeUse, SubscriptionStatus
+                )
+                
+                if user.subscription:
+                    await db.execute(
+                        delete(SubscriptionServer).where(
+                            SubscriptionServer.subscription_id == user.subscription.id
+                        )
+                    )
+                    logger.info(f"🗑️ Удалены серверы подписки для {user.telegram_id}")
+                
+                await db.execute(
+                    delete(Transaction).where(Transaction.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены транзакции для {user.telegram_id}")
+                
+                await db.execute(
+                    delete(ReferralEarning).where(ReferralEarning.user_id == user.id)
+                )
+                await db.execute(
+                    delete(ReferralEarning).where(ReferralEarning.referral_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены реферальные доходы для {user.telegram_id}")
+                
+                await db.execute(
+                    delete(PromoCodeUse).where(PromoCodeUse.user_id == user.id)
+                )
+                logger.info(f"🗑️ Удалены использования промокодов для {user.telegram_id}")
+                
+            except Exception as records_error:
+                logger.error(f"❌ Ошибка удаления связанных записей: {records_error}")
+            
+            try:
+                
+                user.balance_kopeks = 0
+                user.remnawave_uuid = None
+                user.has_had_paid_subscription = False
+                user.used_promocodes = 0
+                user.updated_at = datetime.utcnow()
+                
+                if user.subscription:
+                    user.subscription.status = SubscriptionStatus.DISABLED.value
+                    user.subscription.is_trial = True
+                    user.subscription.end_date = datetime.utcnow()
+                    user.subscription.traffic_limit_gb = 0
+                    user.subscription.traffic_used_gb = 0.0
+                    user.subscription.device_limit = 1
+                    user.subscription.connected_squads = []
+                    user.subscription.autopay_enabled = False
+                    user.subscription.autopay_days_before = 3
+                    user.subscription.remnawave_short_uuid = None
+                    user.subscription.subscription_url = ""
+                    user.subscription.updated_at = datetime.utcnow()
+                
+                await db.commit()
+                
+                logger.info(f"✅ ПРИНУДИТЕЛЬНО очищены ВСЕ данные пользователя {user.telegram_id}")
+                return True
+                
+            except Exception as cleanup_error:
+                logger.error(f"❌ Ошибка финальной очистки пользователя: {cleanup_error}")
+                await db.rollback()
+                return False
+        
+        except Exception as e:
+            logger.error(f"❌ Критическая ошибка принудительной очистки пользователя {user.telegram_id}: {e}")
+            await db.rollback()
+            return False
+
+    async def cleanup_orphaned_subscriptions(self, db: AsyncSession) -> Dict[str, int]:
+        """
+        Усиленная версия очистки с полным удалением данных
+        """
+        try:
+            stats = {"deactivated": 0, "errors": 0, "checked": 0}
+        
+            logger.info("🧹 Начинаем усиленную очистку неактуальных подписок...")
+        
+            async with self.api as api:
+                panel_users_data = await api._make_request('GET', '/api/users')
+                panel_users = panel_users_data['response']['users']
+        
+            panel_telegram_ids = set()
+            for panel_user in panel_users:
+                telegram_id = panel_user.get('telegramId')
+                if telegram_id:
+                    panel_telegram_ids.add(telegram_id)
+        
+            logger.info(f"📊 Найдено {len(panel_telegram_ids)} пользователей в панели")
+        
+            from app.database.crud.subscription import get_all_subscriptions
+            from app.database.models import SubscriptionStatus
+        
+            page = 1
+            limit = 100
+        
+            while True:
+                subscriptions, total_count = await get_all_subscriptions(db, page, limit)
+                
+                if not subscriptions:
+                    break
+            
+                for subscription in subscriptions:
+                    try:
+                        stats["checked"] += 1
+                        user = subscription.user
+                    
+                        if subscription.status == SubscriptionStatus.DISABLED.value:
+                            continue
+                    
+                        if user.telegram_id not in panel_telegram_ids:
+                            logger.info(f"🗑️ ПОЛНАЯ деактивация подписки пользователя {user.telegram_id} (отсутствует в панели)")
+                            
+                            cleanup_success = await self.force_cleanup_user_data(db, user)
+                            
+                            if cleanup_success:
+                                stats["deactivated"] += 1
+                            else:
+                                stats["errors"] += 1
+                        
+                    except Exception as sub_error:
+                        logger.error(f"❌ Ошибка обработки подписки {subscription.id}: {sub_error}")
+                        stats["errors"] += 1
+            
+                page += 1
+                if len(subscriptions) < limit:
+                    break
+        
+            logger.info(f"🧹 Усиленная очистка завершена: проверено {stats['checked']}, деактивировано {stats['deactivated']}, ошибок {stats['errors']}")
+            return stats
+        
+        except Exception as e:
+            logger.error(f"❌ Критическая ошибка усиленной очистки подписок: {e}")
+            return {"deactivated": 0, "errors": 1, "checked": 0}
+
+
+    async def sync_subscription_statuses(self, db: AsyncSession) -> Dict[str, int]:
+        try:
+            stats = {"updated": 0, "errors": 0, "checked": 0}
+        
+            logger.info("🔄 Начинаем синхронизацию статусов подписок...")
+        
+            async with self.api as api:
+                panel_users_data = await api._make_request('GET', '/api/users')
+                panel_users = panel_users_data['response']['users']
+        
+            panel_users_dict = {}
+            for panel_user in panel_users:
+                telegram_id = panel_user.get('telegramId')
+                if telegram_id:
+                    panel_users_dict[telegram_id] = panel_user
+        
+            logger.info(f"📊 Найдено {len(panel_users_dict)} пользователей в панели для синхронизации")
+        
+            from app.database.crud.subscription import get_all_subscriptions
+            from app.database.models import SubscriptionStatus
+        
+            page = 1
+            limit = 100
+        
+            while True:
+                subscriptions, total_count = await get_all_subscriptions(db, page, limit)
+            
+                if not subscriptions:
+                    break
+            
+                for subscription in subscriptions:
+                    try:
+                        stats["checked"] += 1
+                        user = subscription.user
+                    
+                        panel_user = panel_users_dict.get(user.telegram_id)
+                    
+                        if panel_user:
+                            await self._update_subscription_from_panel_data(db, user, panel_user)
+                            stats["updated"] += 1
+                        else:
+                            if subscription.status != SubscriptionStatus.DISABLED.value:
+                                logger.info(f"🗑️ Деактивируем подписку пользователя {user.telegram_id} (нет в панели)")
+                            
+                                from app.database.crud.subscription import deactivate_subscription
+                                await deactivate_subscription(db, subscription)
+                                stats["updated"] += 1
+                        
+                    except Exception as sub_error:
+                        logger.error(f"❌ Ошибка синхронизации подписки {subscription.id}: {sub_error}")
+                        stats["errors"] += 1
+            
+                page += 1
+                if len(subscriptions) < limit:
+                    break
+        
+            logger.info(f"🔄 Синхронизация статусов завершена: проверено {stats['checked']}, обновлено {stats['updated']}, ошибок {stats['errors']}")
+            return stats
+        
+        except Exception as e:
+            logger.error(f"❌ Критическая ошибка синхронизации статусов: {e}")
+            return {"updated": 0, "errors": 1, "checked": 0}
+
+
+    async def validate_and_fix_subscriptions(self, db: AsyncSession) -> Dict[str, int]:
+        try:
+            stats = {"fixed": 0, "errors": 0, "checked": 0, "issues_found": 0}
+        
+            logger.info("🔍 Начинаем валидацию подписок...")
+            
+            from app.database.crud.subscription import get_all_subscriptions
+            from app.database.models import SubscriptionStatus
+        
+            page = 1
+            limit = 100
+        
+            while True:
+                subscriptions, total_count = await get_all_subscriptions(db, page, limit)
+            
+                if not subscriptions:
+                    break
+            
+                for subscription in subscriptions:
+                    try:
+                        stats["checked"] += 1
+                        user = subscription.user
+                        issues_fixed = 0
+                    
+                        current_time = datetime.utcnow()
+                        if subscription.end_date <= current_time and subscription.status == SubscriptionStatus.ACTIVE.value:
+                            logger.info(f"🔧 Исправляем статус просроченной подписки {user.telegram_id}")
+                            subscription.status = SubscriptionStatus.EXPIRED.value
+                            issues_fixed += 1
+                
+                        if not subscription.remnawave_short_uuid and user.remnawave_uuid:
+                            try:
+                                async with self.api as api:
+                                    rw_user = await api.get_user_by_uuid(user.remnawave_uuid)
+                                    if rw_user:
+                                        subscription.remnawave_short_uuid = rw_user.short_uuid
+                                        subscription.subscription_url = rw_user.subscription_url
+                                        logger.info(f"🔧 Восстановлены данные RemnaWave для {user.telegram_id}")
+                                        issues_fixed += 1
+                            except Exception as rw_error:
+                                logger.warning(f"⚠️ Не удалось получить данные RemnaWave для {user.telegram_id}: {rw_error}")
+                    
+                        if subscription.traffic_limit_gb < 0:
+                            subscription.traffic_limit_gb = 0
+                            logger.info(f"🔧 Исправлен некорректный лимит трафика для {user.telegram_id}")
+                            issues_fixed += 1
+                    
+                        if subscription.traffic_used_gb < 0:
+                            subscription.traffic_used_gb = 0.0
+                            logger.info(f"🔧 Исправлено некорректное использование трафика для {user.telegram_id}")
+                            issues_fixed += 1
+                    
+                        if subscription.device_limit <= 0:
+                            subscription.device_limit = 1
+                            logger.info(f"🔧 Исправлен лимит устройств для {user.telegram_id}")
+                            issues_fixed += 1
+                    
+                        if subscription.connected_squads is None:
+                            subscription.connected_squads = []
+                            logger.info(f"🔧 Инициализирован список сквадов для {user.telegram_id}")
+                            issues_fixed += 1
+                    
+                        if issues_fixed > 0:
+                            stats["issues_found"] += issues_fixed
+                            stats["fixed"] += 1
+                            await db.commit()
+                        
+                    except Exception as sub_error:
+                        logger.error(f"❌ Ошибка валидации подписки {subscription.id}: {sub_error}")
+                        stats["errors"] += 1
+                        await db.rollback()
+            
+                page += 1
+                if len(subscriptions) < limit:
+                    break
+        
+            logger.info(f"🔍 Валидация завершена: проверено {stats['checked']}, исправлено подписок {stats['fixed']}, найдено проблем {stats['issues_found']}, ошибок {stats['errors']}")
+            return stats
+        
+        except Exception as e:
+            logger.error(f"❌ Критическая ошибка валидации: {e}")
+            return {"fixed": 0, "errors": 1, "checked": 0, "issues_found": 0}
+
+
+    async def get_sync_recommendations(self, db: AsyncSession) -> Dict[str, Any]:
+        try:
+            recommendations = {
+                "should_sync": False,
+                "sync_type": "none",
+                "reasons": [],
+                "priority": "low",
+                "estimated_time": "1-2 минуты"
+            }
+        
+            from app.database.crud.user import get_users_list
+            bot_users = await get_users_list(db, offset=0, limit=10000)
+        
+            users_without_uuid = sum(1 for user in bot_users if not user.remnawave_uuid and user.subscription)
+        
+            from app.database.crud.subscription import get_expired_subscriptions
+            expired_subscriptions = await get_expired_subscriptions(db)
+            active_expired = sum(1 for sub in expired_subscriptions if sub.status == "active")
+        
+            if users_without_uuid > 10:
+                recommendations["should_sync"] = True
+                recommendations["sync_type"] = "all"
+                recommendations["priority"] = "high"
+                recommendations["reasons"].append(f"Найдено {users_without_uuid} пользователей без связи с RemnaWave")
+                recommendations["estimated_time"] = "3-5 минут"
+        
+            if active_expired > 5:
+                recommendations["should_sync"] = True
+                if recommendations["sync_type"] == "none":
+                    recommendations["sync_type"] = "update_only"
+                recommendations["priority"] = "medium" if recommendations["priority"] == "low" else recommendations["priority"]
+                recommendations["reasons"].append(f"Найдено {active_expired} активных подписок с истекшим сроком")
+        
+            if not recommendations["should_sync"]:
+                recommendations["sync_type"] = "update_only"
+                recommendations["reasons"].append("Рекомендуется регулярная синхронизация данных")
+                recommendations["estimated_time"] = "1-2 минуты"
+        
+            return recommendations
+        
+        except Exception as e:
+            logger.error(f"❌ Ошибка получения рекомендаций: {e}")
+            return {
+                "should_sync": True,
+                "sync_type": "all",
+                "reasons": ["Ошибка анализа - рекомендуется полная синхронизация"],
+                "priority": "medium",
+                "estimated_time": "3-5 минут"
+            }

app/services/subscription_service.py

@@ -4,7 +4,7 @@ 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.database.models import Subscription, User, SubscriptionStatus
 from app.external.remnawave_api import (
     RemnaWaveAPI, RemnaWaveUser, UserStatus, 
     TrafficLimitStrategy, RemnaWaveAPIError
@@ -34,10 +34,23 @@ class SubscriptionService:
                 logger.error(f"Пользователь {subscription.user_id} не найден")
                 return None
             
+            validation_success = await self.validate_and_clean_subscription(db, subscription, user)
+            if not validation_success:
+                logger.error(f"Ошибка валидации подписки для пользователя {user.telegram_id}")
+                return None
+            
             async with self.api as api:
                 existing_users = await api.get_user_by_telegram_id(user.telegram_id)
                 if existing_users:
+                    logger.info(f"🔄 Найден существующий пользователь в панели для {user.telegram_id}")
                     remnawave_user = existing_users[0]
+                    
+                    try:
+                        await api.reset_user_devices(remnawave_user.uuid)
+                        logger.info(f"🔧 Сброшены HWID устройства для пользователя {user.telegram_id}")
+                    except Exception as hwid_error:
+                        logger.warning(f"⚠️ Не удалось сбросить HWID: {hwid_error}")
+                    
                     updated_user = await api.update_user(
                         uuid=remnawave_user.uuid,
                         status=UserStatus.ACTIVE,
@@ -47,7 +60,9 @@ class SubscriptionService:
                         hwid_device_limit=subscription.device_limit,
                         active_internal_squads=subscription.connected_squads
                     )
+                    
                 else:
+                    logger.info(f"🆕 Создаем нового пользователя в панели для {user.telegram_id}")
                     username = f"user_{user.telegram_id}"
                     updated_user = await api.create_user(
                         username=username,
@@ -67,7 +82,7 @@ class SubscriptionService:
                 
                 await db.commit()
                 
-                logger.info(f"✅ Создан RemnaWave пользователь для подписки {subscription.id}")
+                logger.info(f"✅ Создан/обновлен RemnaWave пользователь для подписки {subscription.id}")
                 logger.info(f"🔗 Ссылка на подписку: {updated_user.subscription_url}")
                 logger.info(f"📊 Стратегия сброса трафика: MONTH") 
                 return updated_user
@@ -91,10 +106,23 @@ class SubscriptionService:
                 logger.error(f"RemnaWave UUID не найден для пользователя {subscription.user_id}")
                 return None
             
+            current_time = datetime.utcnow()
+            is_actually_active = (subscription.status == SubscriptionStatus.ACTIVE.value and 
+                                 subscription.end_date > current_time)
+            
+            if (subscription.status == SubscriptionStatus.ACTIVE.value and 
+                subscription.end_date <= current_time):
+                
+                subscription.status = SubscriptionStatus.EXPIRED.value
+                subscription.updated_at = current_time
+                await db.commit()
+                is_actually_active = False
+                logger.info(f"🔔 Статус подписки {subscription.id} автоматически изменен на 'expired'")
+            
             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,
+                    status=UserStatus.ACTIVE if is_actually_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, 
@@ -105,12 +133,13 @@ class SubscriptionService:
                 subscription.subscription_url = updated_user.subscription_url
                 await db.commit()
                 
-                logger.info(f"✅ Обновлен RemnaWave пользователь {user.remnawave_uuid}")
+                status_text = "активным" if is_actually_active else "истёкшим"
+                logger.info(f"✅ Обновлен RemnaWave пользователь {user.remnawave_uuid} со статусом {status_text}")
                 logger.info(f"📊 Стратегия сброса трафика: MONTH") 
                 return updated_user
                 
         except RemnaWaveAPIError as e:
-            logger.error(f"Ошибка обновления RemnaWave пользователя: {e}")
+            logger.error(f"Ошибка RemnaWave API: {e}")
             return None
         except Exception as e:
             logger.error(f"Ошибка обновления RemnaWave пользователя: {e}")
@@ -200,34 +229,161 @@ class SubscriptionService:
         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 _get_countries_price(self, country_uuids: List[str]) -> int:
-        # TODO: Реализовать получение цен из базы данных сквадов
-        # Пока возвращаем базовую логику
-        price_per_country = 1000 
-        return len(country_uuids) * price_per_country
+    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 validate_and_clean_subscription(
+        self,
+        db: AsyncSession,
+        subscription: Subscription,
+        user: User
+    ) -> bool:
+        try:
+            needs_cleanup = False
+            
+            if user.remnawave_uuid:
+                try:
+                    async with self.api as api:
+                        remnawave_user = await api.get_user_by_uuid(user.remnawave_uuid)
+                        
+                        if not remnawave_user:
+                            logger.warning(f"⚠️ Пользователь {user.telegram_id} имеет UUID {user.remnawave_uuid}, но не найден в панели")
+                            needs_cleanup = True
+                        else:
+                            if remnawave_user.telegram_id != user.telegram_id:
+                                logger.warning(f"⚠️ Несоответствие telegram_id для пользователя {user.telegram_id}")
+                                needs_cleanup = True
+                except Exception as api_error:
+                    logger.error(f"❌ Ошибка проверки пользователя в панели: {api_error}")
+                    needs_cleanup = True
+            
+            if subscription.remnawave_short_uuid and not user.remnawave_uuid:
+                logger.warning(f"⚠️ У подписки есть short_uuid, но у пользователя нет remnawave_uuid")
+                needs_cleanup = True
+                
+            if needs_cleanup:
+                logger.info(f"🧹 Очищаем мусорные данные подписки для пользователя {user.telegram_id}")
+                
+                subscription.remnawave_short_uuid = None
+                subscription.subscription_url = ""
+                subscription.connected_squads = []
+                
+                user.remnawave_uuid = None
+                
+                await db.commit()
+                logger.info(f"✅ Мусорные данные очищены для пользователя {user.telegram_id}")
+                
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка валидации подписки для пользователя {user.telegram_id}: {e}")
+            await db.rollback()
+            return False
+    
+    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: 
@@ -237,4 +393,4 @@ class SubscriptionService:
     def _bytes_to_gb(self, bytes_value: int) -> float:
         if bytes_value == 0:
             return 0.0
-        return bytes_value / (1024 * 1024 * 1024)
+        return bytes_value / (1024 * 1024 * 1024)

app/services/tribute_service.py

@@ -48,7 +48,6 @@ class TributeService:
             if not payment_url:
                 return None
             
-            
             return payment_url
             
         except Exception as e:
@@ -91,19 +90,28 @@ class TributeService:
         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"]
             
+            logger.info(f"Обрабатываем успешный Tribute платеж: user_id={user_id}, amount={amount_kopeks}, payment_id={payment_id}")
+            
             async for session in get_db():
-                existing_transaction = await get_transaction_by_external_id(
-                    session, f"donation_{payment_id}", PaymentMethod.TRIBUTE
+                from app.database.crud.transaction import check_tribute_payment_duplicate, create_unique_tribute_transaction
+                
+                duplicate_transaction = await check_tribute_payment_duplicate(
+                    session, payment_id, amount_kopeks, user_id
                 )
                 
-                if existing_transaction:
-                    logger.warning(f"Транзакция с donation_request_id {payment_id} уже существует")
+                if duplicate_transaction:
+                    logger.warning(f"Найден дубликат платежа:")
+                    logger.warning(f"   Transaction ID: {duplicate_transaction.id}")
+                    logger.warning(f"   Amount: {duplicate_transaction.amount_kopeks} коп")
+                    logger.warning(f"   Created: {duplicate_transaction.created_at}")
+                    logger.warning(f"Платеж игнорирован")
                     return
                 
                 user = await get_user_by_telegram_id(session, user_id)
@@ -111,29 +119,34 @@ class TributeService:
                     logger.error(f"Пользователь {user_id} не найден")
                     return
                 
-                transaction = await create_transaction(
+                logger.info(f"Найден пользователь {user.telegram_id}, текущий баланс: {user.balance_kopeks} коп")
+                
+                transaction = await create_unique_tribute_transaction(
                     db=session,
-                    user_id=user.id, 
-                    type=TransactionType.DEPOSIT,
+                    user_id=user.id,
+                    payment_id=payment_id,
                     amount_kopeks=amount_kopeks,
-                    description=f"Пополнение через Tribute: {amount_kopeks/100}₽",
-                    payment_method=PaymentMethod.TRIBUTE,
-                    external_id=f"donation_{payment_id}",
-                    is_completed=True
+                    description=f"Пополнение через Tribute: {amount_kopeks/100}₽ (ID: {payment_id})"
                 )
                 
+                old_balance = user.balance_kopeks
                 user.balance_kopeks += amount_kopeks
+                user.updated_at = datetime.utcnow()
+                
                 await session.commit()
                 
+                logger.info(f"Баланс пользователя {user_id} обновлен: {old_balance} -> {user.balance_kopeks} коп (+{amount_kopeks})")
+                
                 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}")
+            logger.error(f"Ошибка обработки успешного Tribute платежа: {e}", exc_info=True)
     
     async def _handle_failed_payment(self, payment_data: Dict[str, Any]):
+        """Обработка неудачного платежа"""
         
         try:
             user_id = payment_data["user_id"]
@@ -141,7 +154,7 @@ class TributeService:
             
             async for session in get_db():
                 transaction = await get_transaction_by_external_id(
-                    session, payment_id, PaymentMethod.TRIBUTE
+                    session, f"donation_{payment_id}", PaymentMethod.TRIBUTE
                 )
                 
                 if transaction:
@@ -157,6 +170,7 @@ class TributeService:
             logger.error(f"Ошибка обработки неудачного Tribute платежа: {e}")
     
     async def _handle_refund(self, refund_data: Dict[str, Any]):
+        """Обработка возврата"""
         
         try:
             user_id = refund_data["user_id"]
@@ -189,6 +203,7 @@ class TributeService:
             logger.error(f"Ошибка обработки возврата Tribute: {e}")
     
     async def _send_success_notification(self, user_id: int, amount_kopeks: int):
+        """Отправка уведомления об успешном платеже"""
         
         try:
             amount_rubles = amount_kopeks / 100
@@ -217,6 +232,7 @@ class TributeService:
             logger.error(f"Ошибка отправки уведомления об успешном платеже: {e}")
     
     async def _send_failure_notification(self, user_id: int):
+        """Отправка уведомления о неудачном платеже"""
         
         try:
             text = (
@@ -245,6 +261,7 @@ class TributeService:
             logger.error(f"Ошибка отправки уведомления о неудачном платеже: {e}")
     
     async def _send_refund_notification(self, user_id: int, amount_kopeks: int):
+        """Отправка уведомления о возврате"""
         
         try:
             amount_rubles = amount_kopeks / 100
@@ -272,6 +289,54 @@ class TributeService:
         except Exception as e:
             logger.error(f"Ошибка отправки уведомления о возврате: {e}")
     
+    async def force_process_payment(
+        self, 
+        payment_id: str, 
+        user_id: int, 
+        amount_kopeks: int,
+        description: str = "Принудительная обработка Tribute платежа"
+    ) -> bool:
+        """Принудительная обработка платежа (для отладки)"""
+        
+        try:
+            logger.info(f"🔧 ПРИНУДИТЕЛЬНАЯ ОБРАБОТКА: payment_id={payment_id}, user_id={user_id}, amount={amount_kopeks}")
+            
+            async for session in get_db():
+                user = await get_user_by_telegram_id(session, user_id)
+                if not user:
+                    logger.error(f"❌ Пользователь {user_id} не найден")
+                    return False
+                
+                external_id = f"force_donation_{payment_id}_{int(datetime.utcnow().timestamp())}"
+                
+                transaction = await create_transaction(
+                    db=session,
+                    user_id=user.id,
+                    type=TransactionType.DEPOSIT,
+                    amount_kopeks=amount_kopeks,
+                    description=description,
+                    payment_method=PaymentMethod.TRIBUTE,
+                    external_id=external_id,
+                    is_completed=True
+                )
+                
+                old_balance = user.balance_kopeks
+                user.balance_kopeks += amount_kopeks
+                user.updated_at = datetime.utcnow()
+                
+                await session.commit()
+                
+                logger.info(f"💰 ПРИНУДИТЕЛЬНО обновлен баланс: {old_balance} -> {user.balance_kopeks} коп")
+                
+                await self._send_success_notification(user_id, amount_kopeks)
+                
+                logger.info(f"✅ Принудительно обработан платеж {payment_id}")
+                return True
+                
+        except Exception as e:
+            logger.error(f"❌ Ошибка принудительной обработки: {e}", exc_info=True)
+            return False
+    
     async def get_payment_status(self, payment_id: str) -> Optional[Dict[str, Any]]:
         return await self.tribute_api.get_payment_status(payment_id)
     
@@ -281,4 +346,4 @@ class TributeService:
         amount_kopeks: Optional[int] = None,
         reason: str = "Возврат по запросу"
     ) -> Optional[Dict[str, Any]]:
-        return await self.tribute_api.refund_payment(payment_id, amount_kopeks, reason)
+        return await self.tribute_api.refund_payment(payment_id, amount_kopeks, reason)

app/services/user_service.py

@@ -2,6 +2,7 @@ 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,
@@ -10,7 +11,10 @@ from app.database.crud.user import (
 )
 from app.database.crud.transaction import get_user_transactions_count
 from app.database.crud.subscription import get_subscription_by_user_id
-from app.database.models import User, UserStatus
+from app.database.models import (
+    User, UserStatus, Subscription, Transaction, PromoCodeUse, 
+    ReferralEarning, SubscriptionServer
+)
 from app.config import settings
 
 logger = logging.getLogger(__name__)
@@ -131,16 +135,15 @@ class UserService:
                 return False
             
             if amount_kopeks > 0:
-                await add_user_balance(db, user, amount_kopeks, description)
+                await add_user_balance(db, user, amount_kopeks, description=description)
                 logger.info(f"Админ {admin_id} пополнил баланс пользователя {user_id} на {amount_kopeks/100}₽")
+                return True
             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
@@ -157,6 +160,19 @@ class UserService:
             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}")
@@ -179,6 +195,27 @@ class UserService:
             
             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
             
@@ -195,17 +232,100 @@ class UserService:
         try:
             user = await get_user_by_id(db, user_id)
             if not user:
+                logger.warning(f"Пользователь {user_id} не найден для удаления")
                 return False
             
-            success = await delete_user(db, user)
+            logger.info(f"🗑️ Начинаем полное удаление пользователя {user_id} (Telegram ID: {user.telegram_id})")
             
-            if success:
-                logger.info(f"Админ {admin_id} удалил пользователя {user_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}")
             
-            return success
+            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"Ошибка удаления пользователя: {e}")
+            logger.error(f"❌ Критическая ошибка удаления пользователя {user_id}: {e}")
+            await db.rollback()
             return False
     
     async def get_user_statistics(self, db: AsyncSession) -> Dict[str, Any]:
@@ -237,7 +357,7 @@ class UserService:
             deleted_count = 0
             
             for user in inactive_users:
-                success = await delete_user(db, user)
+                success = await self.delete_user_account(db, user.id, 0) 
                 if success:
                     deleted_count += 1
             
@@ -281,7 +401,7 @@ class UserService:
                 "subscription_active": subscription.is_active if subscription else False,
                 "subscription_trial": subscription.is_trial if subscription else False,
                 "transactions_count": transactions_count,
-                "referrer_id": user.referrer_id,
+                "referrer_id": user.referred_by_id,
                 "referral_code": user.referral_code
             }
             
@@ -330,4 +450,4 @@ class UserService:
             
         except Exception as e:
             logger.error(f"Ошибка получения пользователей по критериям: {e}")
-            return []
+            return []

app/services/yookassa_service.py

@@ -0,0 +1,194 @@
+import uuid
+import logging
+import asyncio
+from typing import Optional, Dict, Any, List
+
+from yookassa import Configuration, Payment as YooKassaPayment
+from yookassa.domain.request.payment_request_builder import PaymentRequestBuilder
+from yookassa.domain.common.confirmation_type import ConfirmationType
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class YooKassaService:
+    
+    def __init__(self,
+                 shop_id: Optional[str] = None,
+                 secret_key: Optional[str] = None,
+                 configured_return_url: Optional[str] = None,
+                 bot_username_for_default_return: Optional[str] = None):
+
+        shop_id = shop_id or getattr(settings, 'YOOKASSA_SHOP_ID', None)
+        secret_key = secret_key or getattr(settings, 'YOOKASSA_SECRET_KEY', None)
+        configured_return_url = configured_return_url or getattr(settings, 'YOOKASSA_RETURN_URL', None)
+
+        if not shop_id or not secret_key:
+            logger.warning(
+                "YooKassa SHOP_ID или SECRET_KEY не настроены в settings. "
+                "Функционал платежей будет ОТКЛЮЧЕН.")
+            self.configured = False
+        else:
+            try:
+                Configuration.configure(shop_id, secret_key)
+                self.configured = True
+                logger.info(
+                    f"YooKassa SDK сконфигурирован для shop_id: {shop_id[:5]}...")
+            except Exception as e:
+                logger.error(f"Ошибка конфигурации YooKassa SDK: {e}",
+                              exc_info=True)
+                self.configured = False
+
+        if configured_return_url:
+            self.return_url = configured_return_url
+        elif bot_username_for_default_return:
+            self.return_url = f"https://t.me/{bot_username_for_default_return}"
+            logger.info(
+                f"YOOKASSA_RETURN_URL не установлен, используем бота: {self.return_url}")
+        else:
+            self.return_url = "https://t.me/"
+            logger.warning(
+                f"КРИТИЧНО: YOOKASSA_RETURN_URL не установлен И username бота не предоставлен. "
+                f"Используем заглушку: {self.return_url}. Платежи могут работать некорректно.")
+        
+        logger.info(f"YooKassa Service return_url: {self.return_url}")
+
+    async def create_payment(
+            self,
+            amount: float,
+            currency: str,
+            description: str,
+            metadata: Dict[str, Any],
+            receipt_email: Optional[str] = None,
+            receipt_phone: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """Создает платеж в YooKassa"""
+        
+        if not self.configured:
+            logger.error("YooKassa не сконфигурирован. Невозможно создать платеж.")
+            return None
+
+        customer_contact_for_receipt = {}
+        if receipt_email:
+            customer_contact_for_receipt["email"] = receipt_email
+        elif receipt_phone:
+            customer_contact_for_receipt["phone"] = receipt_phone
+        elif hasattr(settings, 'YOOKASSA_DEFAULT_RECEIPT_EMAIL') and settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL:
+            customer_contact_for_receipt["email"] = settings.YOOKASSA_DEFAULT_RECEIPT_EMAIL
+        else:
+            logger.error(
+                "КРИТИЧНО: Не предоставлен email/телефон для чека YooKassa и YOOKASSA_DEFAULT_RECEIPT_EMAIL не установлен.")
+            return {
+                "error": True,
+                "internal_message": "Отсутствуют контактные данные для чека YooKassa и не настроен email по умолчанию."
+            }
+
+        try:
+            builder = PaymentRequestBuilder()
+            builder.set_amount({
+                "value": str(round(amount, 2)),
+                "currency": currency.upper()
+            })
+            builder.set_capture(True)
+            builder.set_confirmation({
+                "type": ConfirmationType.REDIRECT,
+                "return_url": self.return_url
+            })
+            builder.set_description(description)
+            builder.set_metadata(metadata)
+
+            receipt_items_list: List[Dict[str, Any]] = [{
+                "description": description[:128],
+                "quantity": "1.00",
+                "amount": {
+                    "value": str(round(amount, 2)),
+                    "currency": currency.upper()
+                },
+                "vat_code": str(getattr(settings, 'YOOKASSA_VAT_CODE', 1)),
+                "payment_mode": getattr(settings, 'YOOKASSA_PAYMENT_MODE', 'full_payment'),
+                "payment_subject": getattr(settings, 'YOOKASSA_PAYMENT_SUBJECT', 'service')
+            }]
+
+            receipt_data_dict: Dict[str, Any] = {
+                "customer": customer_contact_for_receipt,
+                "items": receipt_items_list
+            }
+
+            builder.set_receipt(receipt_data_dict)
+
+            idempotence_key = str(uuid.uuid4())
+            payment_request = builder.build()
+
+            logger.info(
+                f"Создание платежа YooKassa (Idempotence-Key: {idempotence_key}). "
+                f"Сумма: {amount} {currency}. Метаданные: {metadata}. Чек: {receipt_data_dict}")
+
+            loop = asyncio.get_running_loop()
+            response = await loop.run_in_executor(
+                None, lambda: YooKassaPayment.create(payment_request, idempotence_key))
+
+            logger.info(
+                f"Ответ YooKassa Payment.create: ID={response.id}, Status={response.status}, Paid={response.paid}")
+
+            return {
+                "id": response.id,
+                "confirmation_url": response.confirmation.confirmation_url if response.confirmation else None,
+                "status": response.status,
+                "metadata": response.metadata,
+                "amount_value": float(response.amount.value),
+                "amount_currency": response.amount.currency,
+                "idempotence_key_used": idempotence_key,
+                "paid": response.paid,
+                "refundable": response.refundable,
+                "created_at": response.created_at.isoformat() if hasattr(
+                    response.created_at, 'isoformat') else str(response.created_at),
+                "description_from_yk": response.description,
+                "test_mode": response.test if hasattr(response, 'test') else None
+            }
+        except Exception as e:
+            logger.error(f"Ошибка создания платежа YooKassa: {e}", exc_info=True)
+            return None
+
+    async def get_payment_info(
+            self, payment_id_in_yookassa: str) -> Optional[Dict[str, Any]]:
+        
+        if not self.configured:
+            logger.error("YooKassa не сконфигурирован. Невозможно получить информацию о платеже.")
+            return None
+            
+        try:
+            logger.info(f"Получение информации о платеже YooKassa ID: {payment_id_in_yookassa}")
+
+            loop = asyncio.get_running_loop()
+            payment_info_yk = await loop.run_in_executor(
+                None, lambda: YooKassaPayment.find_one(payment_id_in_yookassa))
+
+            if payment_info_yk:
+                logger.info(
+                    f"Информация о платеже YooKassa {payment_id_in_yookassa}: "
+                    f"Status={payment_info_yk.status}, Paid={payment_info_yk.paid}")
+                return {
+                    "id": payment_info_yk.id,
+                    "status": payment_info_yk.status,
+                    "paid": payment_info_yk.paid,
+                    "amount_value": float(payment_info_yk.amount.value),
+                    "amount_currency": payment_info_yk.amount.currency,
+                    "metadata": payment_info_yk.metadata,
+                    "description": payment_info_yk.description,
+                    "refundable": payment_info_yk.refundable,
+                    "created_at": payment_info_yk.created_at.isoformat() if hasattr(
+                        payment_info_yk.created_at, 'isoformat') else str(payment_info_yk.created_at),
+                    "captured_at": payment_info_yk.captured_at.isoformat()
+                    if payment_info_yk.captured_at and hasattr(
+                        payment_info_yk.captured_at, 'isoformat') else None,
+                    "payment_method_type": payment_info_yk.payment_method.type
+                    if payment_info_yk.payment_method else None,
+                    "test_mode": payment_info_yk.test if hasattr(payment_info_yk, 'test') else None
+                }
+            else:
+                logger.warning(f"Платеж не найден в YooKassa ID: {payment_id_in_yookassa}")
+                return None
+        except Exception as e:
+            logger.error(f"Ошибка получения информации о платеже YooKassa {payment_id_in_yookassa}: {e}",
+                         exc_info=True)
+            return None

app/states.py

@@ -35,6 +35,9 @@ class AdminStates(StatesGroup):
     
     waiting_for_user_search = State()
     editing_user_balance = State()
+    extending_subscription = State()
+    adding_traffic = State()
+    granting_subscription = State()
     editing_user_subscription = State()
     
     creating_promocode = State()
@@ -79,4 +82,4 @@ class SquadCreateStates(StatesGroup):
     selecting_inbounds = State()
 
 class SquadRenameStates(StatesGroup):
-    waiting_for_new_name = State()
+    waiting_for_new_name = State()

app/utils/formatters.py

@@ -67,6 +67,17 @@ def format_time_ago(dt: Union[datetime, str]) -> str:
     else:
         return "только что"
 
+def format_days_declension(days: int, language: str = "ru") -> str:
+    if language != "ru":
+        return f"{days} day{'s' if days != 1 else ''}"
+    
+    if days % 10 == 1 and days % 100 != 11:
+        return f"{days} день"
+    elif days % 10 in [2, 3, 4] and days % 100 not in [12, 13, 14]:
+        return f"{days} дня"
+    else:
+        return f"{days} дней"
+
 
 def format_duration(seconds: int) -> str:
     if seconds < 60:
@@ -204,4 +215,4 @@ def format_boolean(value: bool, language: str = "ru") -> str:
     if language == "ru":
         return "✅ Да" if value else "❌ Нет"
     else:
-        return "✅ Yes" if value else "❌ No"
+        return "✅ Yes" if value else "❌ No"

app/utils/subscription_utils.py

@@ -0,0 +1,97 @@
+import logging
+from datetime import datetime
+from typing import Optional
+from sqlalchemy import select, delete
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.database.models import Subscription, User
+
+logger = logging.getLogger(__name__)
+
+
+async def ensure_single_subscription(db: AsyncSession, user_id: int) -> Optional[Subscription]:
+    result = await db.execute(
+        select(Subscription)
+        .where(Subscription.user_id == user_id)
+        .order_by(Subscription.created_at.desc())
+    )
+    subscriptions = result.scalars().all()
+    
+    if len(subscriptions) <= 1:
+        return subscriptions[0] if subscriptions else None
+    
+    latest_subscription = subscriptions[0]
+    old_subscriptions = subscriptions[1:]
+    
+    logger.warning(f"🚨 Обнаружено {len(subscriptions)} подписок у пользователя {user_id}. Удаляем {len(old_subscriptions)} старых.")
+    
+    for old_sub in old_subscriptions:
+        await db.delete(old_sub)
+        logger.info(f"🗑️ Удалена подписка ID {old_sub.id} от {old_sub.created_at}")
+    
+    await db.commit()
+    await db.refresh(latest_subscription)
+    
+    logger.info(f"✅ Оставлена подписка ID {latest_subscription.id} от {latest_subscription.created_at}")
+    return latest_subscription
+
+
+async def update_or_create_subscription(
+    db: AsyncSession,
+    user_id: int,
+    **subscription_data
+) -> Subscription:
+    existing_subscription = await ensure_single_subscription(db, user_id)
+    
+    if existing_subscription:
+        for key, value in subscription_data.items():
+            if hasattr(existing_subscription, key):
+                setattr(existing_subscription, key, value)
+        
+        existing_subscription.updated_at = datetime.utcnow()
+        await db.commit()
+        await db.refresh(existing_subscription)
+        
+        logger.info(f"🔄 Обновлена существующая подписка ID {existing_subscription.id}")
+        return existing_subscription
+    
+    else:
+        new_subscription = Subscription(
+            user_id=user_id,
+            **subscription_data
+        )
+        
+        db.add(new_subscription)
+        await db.commit()
+        await db.refresh(new_subscription)
+        
+        logger.info(f"🆕 Создана новая подписка ID {new_subscription.id}")
+        return new_subscription
+
+
+async def cleanup_duplicate_subscriptions(db: AsyncSession) -> int:
+    result = await db.execute(
+        select(Subscription.user_id)
+        .group_by(Subscription.user_id)
+        .having(func.count(Subscription.id) > 1)
+    )
+    users_with_duplicates = result.scalars().all()
+    
+    total_deleted = 0
+    
+    for user_id in users_with_duplicates:
+        subscriptions_result = await db.execute(
+            select(Subscription)
+            .where(Subscription.user_id == user_id)
+            .order_by(Subscription.created_at.desc())
+        )
+        subscriptions = subscriptions_result.scalars().all()
+        
+        for old_subscription in subscriptions[1:]:
+            await db.delete(old_subscription)
+            total_deleted += 1
+            logger.info(f"🗑️ Удалена дублирующаяся подписка ID {old_subscription.id} пользователя {user_id}")
+    
+    await db.commit()
+    logger.info(f"🧹 Очищено {total_deleted} дублирующихся подписок")
+    
+    return total_deleted

main.py

@@ -1,6 +1,8 @@
 import asyncio
 import logging
 import sys
+import os
+import signal
 from pathlib import Path
 
 sys.path.append(str(Path(__file__).parent))
@@ -9,7 +11,21 @@ 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.services.maintenance_service import maintenance_service
+from app.services.payment_service import PaymentService
 from app.external.webhook_server import WebhookServer
+from app.external.yookassa_webhook import start_yookassa_webhook_server
+from app.database.universal_migration import run_universal_migration
+
+
+class GracefulExit:
+    
+    def __init__(self):
+        self.exit = False
+        
+    def exit_gracefully(self, signum, frame):
+        logging.getLogger(__name__).info(f"Получен сигнал {signum}. Корректное завершение работы...")
+        self.exit = True
 
 
 async def main():
@@ -23,52 +39,166 @@ async def main():
     )
     
     logger = logging.getLogger(__name__)
-    logger.info("🚀 Запуск VPN бота...")
+    logger.info("🚀 Запуск Bedolaga Remnawave Bot...")
+    
+    killer = GracefulExit()
+    signal.signal(signal.SIGINT, killer.exit_gracefully)
+    signal.signal(signal.SIGTERM, killer.exit_gracefully)
     
     webhook_server = None
+    yookassa_server_task = None
+    monitoring_task = None
+    maintenance_task = None
+    polling_task = None
     
     try:
         logger.info("📊 Инициализация базы данных...")
         await init_db()
         
+        skip_migration = os.getenv('SKIP_MIGRATION', 'false').lower() == 'true'
+        
+        if not skip_migration:
+            logger.info("🔧 Выполняем проверку и миграцию базы данных...")
+            try:
+                migration_success = await run_universal_migration()
+                
+                if migration_success:
+                    logger.info("✅ Миграция базы данных завершена успешно")
+                else:
+                    logger.warning("⚠️ Миграция завершилась с предупреждениями, но продолжаем запуск")
+                    
+            except Exception as migration_error:
+                logger.error(f"❌ Ошибка выполнения миграции: {migration_error}")
+                logger.warning("⚠️ Продолжаем запуск без миграции")
+        else:
+            logger.info("ℹ️ Миграция пропущена (SKIP_MIGRATION=true)")
+        
         logger.info("🤖 Настройка бота...")
         bot, dp = await setup_bot()
         
         monitoring_service.bot = bot
         
-        # Инициализируем webhook сервер если Tribute включен
+        payment_service = PaymentService(bot)
+        
         if settings.TRIBUTE_ENABLED:
-            logger.info("🌐 Запуск webhook сервера для Tribute...")
+            logger.info("🌐 Запуск Tribute webhook сервера...")
             webhook_server = WebhookServer(bot)
             await webhook_server.start()
         else:
             logger.info("ℹ️ Tribute отключен, webhook сервер не запускается")
         
+        if settings.is_yookassa_enabled():
+            logger.info("💳 Запуск YooKassa webhook сервера...")
+            yookassa_server_task = asyncio.create_task(
+                start_yookassa_webhook_server(payment_service)
+            )
+        else:
+            logger.info("ℹ️ YooKassa отключена, webhook сервер не запускается")
+        
         logger.info("🔍 Запуск службы мониторинга...")
         monitoring_task = asyncio.create_task(monitoring_service.start_monitoring())
         
+        logger.info("🔧 Запуск службы техработ...")
+        maintenance_task = asyncio.create_task(maintenance_service.start_monitoring())
+        
         logger.info("🔄 Запуск polling...")
+        polling_task = asyncio.create_task(dp.start_polling(bot, skip_updates=True))
+        
+        logger.info("=" * 50)
+        logger.info("🎯 Активные webhook endpoints:")
+        if settings.TRIBUTE_ENABLED:
+            logger.info(f"   Tribute: {settings.WEBHOOK_URL}:{settings.TRIBUTE_WEBHOOK_PORT}{settings.TRIBUTE_WEBHOOK_PATH}")
+        if settings.is_yookassa_enabled():
+            logger.info(f"   YooKassa: {settings.WEBHOOK_URL}:{settings.YOOKASSA_WEBHOOK_PORT}{settings.YOOKASSA_WEBHOOK_PATH}")
+        logger.info("=" * 50)
         
         try:
-            await asyncio.gather(
-                dp.start_polling(bot),
-                monitoring_task
-            )
+            while not killer.exit:
+                await asyncio.sleep(1)
+                
+                if yookassa_server_task and yookassa_server_task.done():
+                    exception = yookassa_server_task.exception()
+                    if exception:
+                        logger.error(f"YooKassa webhook сервер завершился с ошибкой: {exception}")
+                        logger.info("🔄 Перезапуск YooKassa webhook сервера...")
+                        yookassa_server_task = asyncio.create_task(
+                            start_yookassa_webhook_server(payment_service)
+                        )
+                
+                if monitoring_task.done():
+                    exception = monitoring_task.exception()
+                    if exception:
+                        logger.error(f"Служба мониторинга завершилась с ошибкой: {exception}")
+                        monitoring_task = asyncio.create_task(monitoring_service.start_monitoring())
+                        
+                if maintenance_task.done():
+                    exception = maintenance_task.exception()
+                    if exception:
+                        logger.error(f"Служба техработ завершилась с ошибкой: {exception}")
+                        maintenance_task = asyncio.create_task(maintenance_service.start_monitoring())
+                        
+                if polling_task.done():
+                    exception = polling_task.exception()
+                    if exception:
+                        logger.error(f"Polling завершился с ошибкой: {exception}")
+                        break
+                        
         except Exception as e:
             logger.error(f"Ошибка в основном цикле: {e}")
-            monitoring_service.stop_monitoring()
-            if webhook_server:
-                await webhook_server.stop()
-            raise
-        
+            
     except Exception as e:
         logger.error(f"❌ Критическая ошибка при запуске: {e}")
         raise
+        
     finally:
-        logger.info("🛑 Завершение работы бота")
-        monitoring_service.stop_monitoring()
+        logger.info("🛑 Начинается корректное завершение работы...")
+        
+        if yookassa_server_task and not yookassa_server_task.done():
+            logger.info("⏹️ Остановка YooKassa webhook сервера...")
+            yookassa_server_task.cancel()
+            try:
+                await yookassa_server_task
+            except asyncio.CancelledError:
+                pass
+        
+        if monitoring_task and not monitoring_task.done():
+            logger.info("⏹️ Остановка службы мониторинга...")
+            monitoring_service.stop_monitoring()
+            monitoring_task.cancel()
+            try:
+                await monitoring_task
+            except asyncio.CancelledError:
+                pass
+        
+        if maintenance_task and not maintenance_task.done():
+            logger.info("⏹️ Остановка службы техработ...")
+            await maintenance_service.stop_monitoring()
+            maintenance_task.cancel()
+            try:
+                await maintenance_task
+            except asyncio.CancelledError:
+                pass
+        
+        if polling_task and not polling_task.done():
+            logger.info("⏹️ Остановка polling...")
+            polling_task.cancel()
+            try:
+                await polling_task
+            except asyncio.CancelledError:
+                pass
+        
         if webhook_server:
+            logger.info("⏹️ Остановка Tribute webhook сервера...")
             await webhook_server.stop()
+        
+        if 'bot' in locals():
+            try:
+                await bot.session.close()
+                logger.info("✅ Сессия бота закрыта")
+            except Exception as e:
+                logger.error(f"Ошибка закрытия сессии бота: {e}")
+        
+        logger.info("✅ Завершение работы бота завершено")
 
 
 if __name__ == "__main__":
@@ -78,4 +208,4 @@ if __name__ == "__main__":
         print("\n🛑 Бот остановлен пользователем")
     except Exception as e:
         print(f"❌ Критическая ошибка: {e}")
-        sys.exit(1)
+        sys.exit(1)

migrations/alembic/versions/3d9b35c6bd8f_add_paid_price_to_subscription.py

@@ -0,0 +1,29 @@
+"""add_paid_price_to_subscription
+
+Revision ID: 3d9b35c6bd8f
+Revises: 
+Create Date: 2025-08-23 08:17:00.563340
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '3d9b35c6bd8f'
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('subscriptions', sa.Column('paid_price_kopeks', sa.Integer(), nullable=False, server_default='0'))
+    # ### end Alembic commands ###
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('subscriptions', 'paid_price_kopeks')
+    # ### end Alembic commands ###

requirements.txt

@@ -1,20 +1,26 @@
 # Основные зависимости
-aiogram==3.4.1
+aiogram==3.7.0
 aiohttp==3.9.1
 asyncpg==0.29.0
 SQLAlchemy==2.0.25
 alembic==1.13.1
 aiosqlite==0.19.0
 
-# Дополнительные зависимости
+# Дополнительные зависимости  
 pydantic==2.5.3
 pydantic-settings==2.1.0
 python-dotenv==1.0.0
 redis==5.0.1
 
+# YooKassa SDK
+yookassa==3.0.0
+
 # Логирование и мониторинг
 structlog==23.2.0
 
+# Планировщик задач для техработ
+APScheduler==3.10.4
+
 # Утилиты
 python-dateutil==2.8.2
 pytz==2023.4